Merge pull request #1264 from dart-lang/merge-sse-package
Merge `package:sse`
diff --git a/.github/ISSUE_TEMPLATE/sse.md b/.github/ISSUE_TEMPLATE/sse.md
new file mode 100644
index 0000000..17cc488
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/sse.md
@@ -0,0 +1,5 @@
+---
+name: "package:sse"
+about: "Create a bug or file a feature request against package:sse."
+labels: "package:sse"
+---
\ No newline at end of file
diff --git a/.github/labeler.yml b/.github/labeler.yml
index feae902..1cc4b20 100644
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -104,6 +104,10 @@
- changed-files:
- any-glob-to-any-file: 'pkgs/source_span/**'
+'package:sse':
+ - changed-files:
+ - any-glob-to-any-file: 'pkgs/sse/**'
+
'package:unified_analytics':
- changed-files:
- any-glob-to-any-file: 'pkgs/unified_analytics/**'
diff --git a/.github/workflows/sse.yaml b/.github/workflows/sse.yaml
new file mode 100644
index 0000000..9e2f212
--- /dev/null
+++ b/.github/workflows/sse.yaml
@@ -0,0 +1,73 @@
+name: package:sse
+
+on:
+ # Run on PRs and pushes to the default branch.
+ push:
+ branches: [ main ]
+ paths:
+ - '.github/workflows/sse.yaml'
+ - 'pkgs/sse/**'
+ pull_request:
+ branches: [ main ]
+ paths:
+ - '.github/workflows/sse.yaml'
+ - 'pkgs/sse/**'
+ schedule:
+ - cron: "0 0 * * 0"
+
+env:
+ PUB_ENVIRONMENT: bot.github
+
+
+defaults:
+ run:
+ working-directory: pkgs/sse/
+
+jobs:
+ # Check code formatting and static analysis on a single OS (linux)
+ # against Dart dev.
+ analyze:
+ runs-on: ubuntu-latest
+ strategy:
+ fail-fast: false
+ matrix:
+ sdk: [dev]
+ steps:
+ - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+ - uses: dart-lang/setup-dart@e630b99d28a3b71860378cafdc2a067c71107f94
+ with:
+ sdk: ${{ matrix.sdk }}
+ - id: install
+ name: Install dependencies
+ run: dart pub get
+ - name: Check formatting
+ run: dart format --output=none --set-exit-if-changed .
+ if: always() && steps.install.outcome == 'success'
+ - name: Analyze code
+ run: dart analyze --fatal-infos
+ if: always() && steps.install.outcome == 'success'
+
+ # Run tests on a matrix consisting of two dimensions:
+ # 1. OS: ubuntu-latest, (macos-latest, windows-latest)
+ # 2. release channel: dev
+ test:
+ needs: analyze
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ # Add macos-latest and/or windows-latest if relevant for this package.
+ os: [ubuntu-latest]
+ sdk: [3.3, dev]
+ steps:
+ - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+ - uses: dart-lang/setup-dart@e630b99d28a3b71860378cafdc2a067c71107f94
+ with:
+ sdk: ${{ matrix.sdk }}
+ - uses: nanasess/setup-chromedriver@42cc2998329f041de87dc3cfa33a930eacd57eaa
+ - id: install
+ name: Install dependencies
+ run: dart pub get
+ - name: Run VM tests
+ run: dart test --platform vm --test-randomize-ordering-seed=random -j 1
+ if: always() && steps.install.outcome == 'success'
diff --git a/README.md b/README.md
index 8920c02..79d1dde 100644
--- a/README.md
+++ b/README.md
@@ -39,6 +39,7 @@
| [source_map_stack_trace](pkgs/source_map_stack_trace/) | A package for applying source maps to stack traces. | [](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Asource_map_stack_trace) | [](https://pub.dev/packages/source_map_stack_trace) |
| [source_maps](pkgs/source_maps/) | A library to programmatically manipulate source map files. | [](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Asource_maps) | [](https://pub.dev/packages/source_maps) |
| [source_span](pkgs/source_span/) | Provides a standard representation for source code locations and spans. | [](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Asource_span) | [](https://pub.dev/packages/source_span) |
+| [sse](pkgs/sse/) | Provides client and server functionality for setting up bi-directional communication through Server Sent Events (SSE) and corresponding POST requests. | [](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Asse) | [](https://pub.dev/packages/sse) |
| [unified_analytics](pkgs/unified_analytics/) | A package for logging analytics for all Dart and Flutter related tooling to Google Analytics. | [](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Aunified_analytics) | [](https://pub.dev/packages/unified_analytics) |
## Publishing automation
diff --git a/pkgs/sse/.gitignore b/pkgs/sse/.gitignore
new file mode 100644
index 0000000..1467782
--- /dev/null
+++ b/pkgs/sse/.gitignore
@@ -0,0 +1,3 @@
+.dart_tool
+pubspec.lock
+test/web/index.dart.js.deps
diff --git a/pkgs/sse/AUTHORS b/pkgs/sse/AUTHORS
new file mode 100644
index 0000000..7c12ae6
--- /dev/null
+++ b/pkgs/sse/AUTHORS
@@ -0,0 +1,6 @@
+# Below is a list of people and organizations that have contributed
+# to the Dart project. Names should be added to the list like so:
+#
+# Name/Organization <email address>
+
+Google Inc.
diff --git a/pkgs/sse/CHANGELOG.md b/pkgs/sse/CHANGELOG.md
new file mode 100644
index 0000000..0387ba9
--- /dev/null
+++ b/pkgs/sse/CHANGELOG.md
@@ -0,0 +1,178 @@
+## 4.1.7
+
+- Move to `dart-lang/tools` monorepo.
+
+## 4.1.6
+
+- Require package `web: '>=0.5.0 <2.0.0'`.
+
+## 4.1.5
+
+- Drop unneeded dependency on `package:js`.
+- Update the minimum Dart SDK version to `3.3.0`.
+- Support the latest `package:web`.
+
+## 4.1.4
+
+- Fix incorrect cast causing failure with `dart2wasm`.
+
+## 4.1.3
+
+- Update the minimum Dart SDK version to `3.2.0`.
+
+## 4.1.2
+
+- Send `fetch` requests instead of `XHR` requests.
+- Add an optional `debugKey` parameter to `SseClient` to include in logging.
+- Add a dependency on `package:js`.
+- Update the minimum Dart SDK version to `2.16.0`.
+
+## 4.1.1
+
+- Apply `keepAlive` logic to `SocketException`s.
+- Switch from using `package:pedantic` to `package:lints`
+- Rev the minimum required SDK to 2.15.
+- Populate the pubspec `repository` field.
+
+## 4.1.0
+
+- Limit the number of concurrent requests to prevent Chrome from automatically
+ dropping them on the floor.
+
+## 4.0.0
+
+- Support null safety.
+
+## 3.8.3
+
+- Require the latest shelf and remove dead code.
+
+## 3.8.2
+
+- Complete `onConnected` with an error if the `SseClient` receives an error
+ before the connection is successfully opened.
+
+## 3.8.1
+
+- Fix an issue where closing the `SseConnection` stream would result in an
+ error.
+
+## 3.8.0
+
+- Add `onConnected` to replace `onOpen`.
+- Fix an issue where failed requests would not add a `done` event to the
+ connection `sink`.
+
+## 3.7.0
+
+- Deprecate the client's `onOpen` getter. Messages will now be buffered until a
+ connection is established.
+
+## 3.6.1
+
+- Drop dependency on `package:uuid`.
+
+## 3.6.0
+
+- Improve performance by buffering out of order messages in the server instead
+ of the client.
+
+\*\* Note \*\* This is not modelled as a breaking change as the server can
+handle messages from older clients. However, clients should be using the latest
+server if they require order guarantees.
+
+## 3.5.0
+
+- Add new `shutdown` methods on `SseHandler` and `SseConnection` to allow
+ closing connections immediately, ignoring any keep-alive periods.
+
+## 3.4.0
+
+- Remove `onClose` from `SseConnection` and ensure the corresponding
+ `sink.close` correctly fires.
+
+## 3.3.0
+
+- Add an `onClose` event to the `SseConnection`. This allows consumers to listen
+ to this event in lue of `sseConnection.sink.done` as that is not guaranteed to
+ fire.
+
+## 3.2.2
+
+- Fix an issue where `keepAlive` may cause state errors when attempting to send
+ messages on a closed stream.
+
+## 3.2.1
+
+- Fix an issue where `keepAlive` would only allow a single reconnection.
+
+## 3.2.0
+
+- Re-expose `isInKeepAlivePeriod` flag on `SseConnection`. This flag will be
+ `true` when a connection has been dropped and is in the keep-alive period
+ waiting for a client to reconnect.
+
+## 3.1.2
+
+- Fix an issue where the `SseClient` would not send a `done` event when there
+ was an error with the SSE connection.
+
+## 3.1.1
+
+- Make `isInKeepAlive` on `SseConnection` private.
+
+**Note that this is a breaking change but in actuality no one should be
+depending on this API.**
+
+## 3.1.0
+
+- Add optional `keepAlive` parameter to the `SseHandler`. If `keepAlive` is
+ supplied, the connection will remain active for this period after a disconnect
+ and can be reconnected transparently. If there is no reconnect within that
+ period, the connection will be closed normally.
+
+## 3.0.0
+
+- Add retry logic.
+
+**Possible Breaking Change Error messages may now be delayed up to 5 seconds in
+the client.**
+
+## 2.1.2
+
+- Remove `package:http` dependency.
+
+## 2.1.1
+
+- Use proper headers delimiter.
+
+## 2.1.0
+
+- Support Firefox.
+
+## 2.0.3
+
+- Fix an issue where messages could come out of order.
+
+## 2.0.2
+
+- Support the latest `package:stream_channel`.
+- Require Dart SDK `>=2.1.0 <3.0.0`.
+
+## 2.0.1
+
+- Update to `package:uuid` version 2.0.
+
+## 2.0.0
+
+- No longer expose `close` and `onClose` on an `SseConnection`. This is simply
+ handled by the underlying `stream` / `sink`.
+- Fix a bug where resources of the `SseConnection` were not properly closed.
+
+## 1.0.0
+
+- Internal cleanup.
+
+## 0.0.1
+
+- Initial commit.
diff --git a/pkgs/sse/LICENSE b/pkgs/sse/LICENSE
new file mode 100644
index 0000000..a0d5f54
--- /dev/null
+++ b/pkgs/sse/LICENSE
@@ -0,0 +1,27 @@
+Copyright 2019, the Dart project authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of Google LLC nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pkgs/sse/README.md b/pkgs/sse/README.md
new file mode 100644
index 0000000..ef51415
--- /dev/null
+++ b/pkgs/sse/README.md
@@ -0,0 +1,14 @@
+[](https://github.com/dart-lang/tools/actions/workflows/sse.yaml)
+[](https://pub.dev/packages/sse)
+[](https://pub.dev/packages/sse/publisher)
+
+This package provides support for bi-directional communication through Server
+Sent Events and corresponding POST requests.
+
+This package is not intended to be a general purpose SSE package, but instead is
+a bidirectional protocol for use when Websockets are unavailable. That is, both
+the client and the server expose a `sink` and `stream` on which to send and
+receive messages respectively.
+
+Both the server and client have implicit assumptions on each other and therefore
+a client from this package must be paired with a server from this package.
diff --git a/pkgs/sse/analysis_options.yaml b/pkgs/sse/analysis_options.yaml
new file mode 100644
index 0000000..6729bd9
--- /dev/null
+++ b/pkgs/sse/analysis_options.yaml
@@ -0,0 +1,13 @@
+# https://dart.dev/guides/language/analysis-options
+include: package:dart_flutter_team_lints/analysis_options.yaml
+
+analyzer:
+ language:
+ strict-casts: true
+
+linter:
+ rules:
+ - avoid_unused_constructor_parameters
+ - cancel_subscriptions
+ - literal_only_boolean_expressions
+ - no_adjacent_strings_in_list
diff --git a/pkgs/sse/example/index.dart b/pkgs/sse/example/index.dart
new file mode 100644
index 0000000..0ed7596
--- /dev/null
+++ b/pkgs/sse/example/index.dart
@@ -0,0 +1,15 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:sse/client/sse_client.dart';
+
+/// A basic example which should be used in a browser that supports SSE.
+void main() {
+ var channel = SseClient('/sseHandler');
+
+ channel.stream.listen((s) {
+ // Listen for messages and send them back.
+ channel.sink.add(s);
+ });
+}
diff --git a/pkgs/sse/example/server.dart b/pkgs/sse/example/server.dart
new file mode 100644
index 0000000..b6ee750
--- /dev/null
+++ b/pkgs/sse/example/server.dart
@@ -0,0 +1,21 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:shelf/shelf_io.dart' as io;
+import 'package:sse/server/sse_handler.dart';
+
+/// A basic server which sets up an SSE handler.
+///
+/// When a client connects it will send a simple message and print the
+/// response.
+void main() async {
+ var handler = SseHandler(Uri.parse('/sseHandler'));
+ await io.serve(handler.handler, 'localhost', 0);
+ var connections = handler.connections;
+ while (await connections.hasNext) {
+ var connection = await connections.next;
+ connection.sink.add('foo');
+ connection.stream.listen(print);
+ }
+}
diff --git a/pkgs/sse/lib/client/sse_client.dart b/pkgs/sse/lib/client/sse_client.dart
new file mode 100644
index 0000000..4d3df49
--- /dev/null
+++ b/pkgs/sse/lib/client/sse_client.dart
@@ -0,0 +1,166 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:js_interop';
+
+import 'package:logging/logging.dart';
+import 'package:pool/pool.dart';
+import 'package:stream_channel/stream_channel.dart';
+import 'package:web/web.dart';
+
+import '../src/util/uuid.dart';
+
+/// Limit for the number of concurrent outgoing requests.
+///
+/// Chrome drops outgoing requests on the floor after some threshold. To prevent
+/// these errors we buffer outgoing requests with a pool.
+///
+/// Note Chrome's limit is 6000. So this gives us plenty of headroom.
+final _requestPool = Pool(1000);
+
+/// A client for bi-directional sse communication.
+///
+/// The client can send any JSON-encodable messages to the server by adding
+/// them to the [sink] and listen to messages from the server on the [stream].
+class SseClient extends StreamChannelMixin<String?> {
+ final String _clientId;
+
+ final _incomingController = StreamController<String>();
+
+ final _outgoingController = StreamController<String>();
+
+ final _logger = Logger('SseClient');
+
+ final _onConnected = Completer<void>();
+
+ int _lastMessageId = -1;
+
+ late EventSource _eventSource;
+
+ late String _serverUrl;
+
+ Timer? _errorTimer;
+
+ /// [serverUrl] is the URL under which the server is listening for
+ /// incoming bi-directional SSE connections. [debugKey] is an optional key
+ /// that can be used to identify the SSE connection.
+ SseClient(String serverUrl, {String? debugKey})
+ : _clientId = debugKey == null
+ ? generateUuidV4()
+ : '$debugKey-${generateUuidV4()}' {
+ _serverUrl = '$serverUrl?sseClientId=$_clientId';
+ _eventSource =
+ EventSource(_serverUrl, EventSourceInit(withCredentials: true));
+ _eventSource.onOpen.first.whenComplete(() {
+ _onConnected.complete();
+ _outgoingController.stream
+ .listen(_onOutgoingMessage, onDone: _onOutgoingDone);
+ });
+ _eventSource.addEventListener('message', _onIncomingMessage.toJS);
+ _eventSource.addEventListener('control', _onIncomingControlMessage.toJS);
+
+ _eventSource.onOpen.listen((_) {
+ _errorTimer?.cancel();
+ });
+ _eventSource.onError.listen((error) {
+ if (!(_errorTimer?.isActive ?? false)) {
+ // By default the SSE client uses keep-alive.
+ // Allow for a retry to connect before giving up.
+ _errorTimer = Timer(const Duration(seconds: 5), () {
+ _closeWithError(error);
+ });
+ }
+ });
+ }
+
+ @Deprecated('Use onConnected instead.')
+ Stream<Event> get onOpen => _eventSource.onOpen;
+
+ Future<void> get onConnected => _onConnected.future;
+
+ /// Add messages to this [StreamSink] to send them to the server.
+ ///
+ /// The message added to the sink has to be JSON encodable. Messages that fail
+ /// to encode will be logged through a [Logger].
+ @override
+ StreamSink<String> get sink => _outgoingController.sink;
+
+ /// [Stream] of messages sent from the server to this client.
+ ///
+ /// A message is a decoded JSON object.
+ @override
+ Stream<String> get stream => _incomingController.stream;
+
+ void close() {
+ _eventSource.close();
+ // If the initial connection was never established. Add a listener so close
+ // adds a done event to [sink].
+ if (!_onConnected.isCompleted) _outgoingController.stream.drain<void>();
+ _incomingController.close();
+ _outgoingController.close();
+ }
+
+ void _closeWithError(Object error) {
+ _incomingController.addError(error);
+ close();
+ if (!_onConnected.isCompleted) {
+ // This call must happen after the call to close() which checks
+ // whether the completer was completed earlier.
+ _onConnected.completeError(error);
+ }
+ }
+
+ void _onIncomingControlMessage(Event message) {
+ var data = (message as MessageEvent).data;
+ if (data.dartify() == 'close') {
+ close();
+ } else {
+ throw UnsupportedError('[$_clientId] Illegal Control Message "$data"');
+ }
+ }
+
+ void _onIncomingMessage(Event message) {
+ var decoded =
+ jsonDecode(((message as MessageEvent).data as JSString).toDart);
+ _incomingController.add(decoded as String);
+ }
+
+ void _onOutgoingDone() {
+ close();
+ }
+
+ void _onOutgoingMessage(String? message) async {
+ String? encodedMessage;
+ await _requestPool.withResource(() async {
+ try {
+ encodedMessage = jsonEncode(message);
+ // ignore: avoid_catching_errors
+ } on JsonUnsupportedObjectError catch (e) {
+ _logger.warning('[$_clientId] Unable to encode outgoing message: $e');
+ // ignore: avoid_catching_errors
+ } on ArgumentError catch (e) {
+ _logger.warning('[$_clientId] Invalid argument: $e');
+ }
+ try {
+ final url = '$_serverUrl&messageId=${++_lastMessageId}';
+ await _fetch(
+ url,
+ RequestInit(
+ method: 'POST',
+ body: encodedMessage?.toJS,
+ credentials: 'include'));
+ } catch (error) {
+ final augmentedError =
+ '[$_clientId] SSE client failed to send $message:\n $error';
+ _logger.severe(augmentedError);
+ _closeWithError(augmentedError);
+ }
+ });
+ }
+}
+
+Future<void> _fetch(String resourceUrl, RequestInit options) =>
+ window.fetch(resourceUrl.toJS, options).toDart;
diff --git a/pkgs/sse/lib/server/sse_handler.dart b/pkgs/sse/lib/server/sse_handler.dart
new file mode 100644
index 0000000..bfed935
--- /dev/null
+++ b/pkgs/sse/lib/server/sse_handler.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+export 'package:sse/src/server/sse_handler.dart' show SseConnection, SseHandler;
diff --git a/pkgs/sse/lib/src/server/sse_handler.dart b/pkgs/sse/lib/src/server/sse_handler.dart
new file mode 100644
index 0000000..376fe27
--- /dev/null
+++ b/pkgs/sse/lib/src/server/sse_handler.dart
@@ -0,0 +1,299 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:async/async.dart';
+import 'package:collection/collection.dart';
+import 'package:logging/logging.dart';
+import 'package:shelf/shelf.dart' as shelf;
+import 'package:stream_channel/stream_channel.dart';
+
+// RFC 2616 requires carriage return delimiters.
+String _sseHeaders(String? origin) => 'HTTP/1.1 200 OK\r\n'
+ 'Content-Type: text/event-stream\r\n'
+ 'Cache-Control: no-cache\r\n'
+ 'Connection: keep-alive\r\n'
+ 'Access-Control-Allow-Credentials: true\r\n'
+ "${origin != null ? 'Access-Control-Allow-Origin: $origin\r\n' : ''}"
+ '\r\n\r\n';
+
+class _SseMessage {
+ final int id;
+ final String message;
+ _SseMessage(this.id, this.message);
+}
+
+/// A bi-directional SSE connection between server and browser.
+class SseConnection extends StreamChannelMixin<String> {
+ /// Incoming messages from the Browser client.
+ final _incomingController = StreamController<String>();
+
+ /// Outgoing messages to the Browser client.
+ final _outgoingController = StreamController<String>();
+
+ Sink _sink;
+
+ /// How long to wait after a connection drops before considering it closed.
+ final Duration? _keepAlive;
+
+ /// A timer counting down the KeepAlive period (null if hasn't disconnected).
+ Timer? _keepAliveTimer;
+
+ /// Whether this connection is currently in the KeepAlive timeout period.
+ bool get isInKeepAlivePeriod => _keepAliveTimer?.isActive ?? false;
+
+ /// The id of the last processed incoming message.
+ int _lastProcessedId = -1;
+
+ /// Incoming messages that have yet to be processed.
+ final _pendingMessages =
+ HeapPriorityQueue<_SseMessage>((a, b) => a.id.compareTo(b.id));
+
+ final _closedCompleter = Completer<void>();
+
+ /// Wraps the `_outgoingController.stream` to buffer events to enable keep
+ /// alive.
+ late StreamQueue _outgoingStreamQueue;
+
+ /// Creates an [SseConnection] for the supplied [_sink].
+ ///
+ /// If [keepAlive] is supplied, the connection will remain active for this
+ /// period after a disconnect and can be reconnected transparently. If there
+ /// is no reconnect within that period, the connection will be closed
+ /// normally.
+ ///
+ /// If [keepAlive] is not supplied, the connection will be closed immediately
+ /// after a disconnect.
+ SseConnection(this._sink, {Duration? keepAlive}) : _keepAlive = keepAlive {
+ _outgoingStreamQueue = StreamQueue(_outgoingController.stream);
+ unawaited(_setUpListener());
+ _outgoingController.onCancel = _close;
+ _incomingController.onCancel = _close;
+ }
+
+ Future<void> _setUpListener() async {
+ while (
+ !_outgoingController.isClosed && await _outgoingStreamQueue.hasNext) {
+ // If we're in a KeepAlive timeout, there's nowhere to send messages so
+ // wait a short period and check again.
+ if (isInKeepAlivePeriod) {
+ await Future<void>.delayed(const Duration(milliseconds: 200));
+ continue;
+ }
+
+ // Peek the data so we don't remove it from the stream if we're unable to
+ // send it.
+ final data = await _outgoingStreamQueue.peek;
+
+ // Ignore outgoing messages since the connection may have closed while
+ // waiting for the keep alive.
+ if (_closedCompleter.isCompleted) break;
+
+ try {
+ // JSON encode the message to escape new lines.
+ _sink.add('data: ${json.encode(data)}\n');
+ _sink.add('\n');
+ await _outgoingStreamQueue.next; // Consume from stream if no errors.
+ } catch (e) {
+ if ((e is StateError || e is SocketException) &&
+ (_keepAlive != null && !_closedCompleter.isCompleted)) {
+ // If we got here then the sink may have closed but the stream.onDone
+ // hasn't fired yet, so pause the subscription and skip calling
+ // `next` so the message remains in the queue to try again.
+ _handleDisconnect();
+ } else {
+ rethrow;
+ }
+ }
+ }
+ }
+
+ /// The message added to the sink has to be JSON encodable.
+ @override
+ StreamSink<String> get sink => _outgoingController.sink;
+
+ // Add messages to this [StreamSink] to send them to the server.
+ /// [Stream] of messages sent from the server to this client.
+ ///
+ /// A message is a decoded JSON object.
+ @override
+ Stream<String> get stream => _incomingController.stream;
+
+ /// Adds an incoming [message] to the [stream].
+ ///
+ /// This will buffer messages to guarantee order.
+ void _addIncomingMessage(int id, String message) {
+ _pendingMessages.add(_SseMessage(id, message));
+ while (_pendingMessages.isNotEmpty) {
+ var pendingMessage = _pendingMessages.first;
+ // Only process the next incremental message.
+ if (pendingMessage.id - _lastProcessedId <= 1) {
+ _incomingController.sink.add(pendingMessage.message);
+ _lastProcessedId = pendingMessage.id;
+ _pendingMessages.removeFirst();
+ } else {
+ // A message came out of order. Wait until we receive the previous
+ // messages to process.
+ break;
+ }
+ }
+ }
+
+ void _acceptReconnection(Sink sink) {
+ _keepAliveTimer?.cancel();
+ _sink = sink;
+ }
+
+ void _handleDisconnect() {
+ if (_keepAlive == null) {
+ // Close immediately if we're not keeping alive.
+ _close();
+ } else if (!isInKeepAlivePeriod && !_closedCompleter.isCompleted) {
+ // Otherwise if we didn't already have an active timer and we've not
+ // already been completely closed, set a timer to close after the timeout
+ // period.
+ // If the connection comes back, this will be cancelled and all messages
+ // left in the queue tried again.
+ _keepAliveTimer = Timer(_keepAlive, _close);
+ }
+ }
+
+ void _close() {
+ if (!_closedCompleter.isCompleted) {
+ _closedCompleter.complete();
+ // Cancel any existing timer in case we were told to explicitly shut down
+ // to avoid keeping the process alive.
+ _keepAliveTimer?.cancel();
+ _sink.close();
+ if (!_outgoingController.isClosed) {
+ _outgoingStreamQueue.cancel(immediate: true);
+ _outgoingController.close();
+ }
+ if (!_incomingController.isClosed) _incomingController.close();
+ }
+ }
+
+ /// Immediately close the connection, ignoring any keepAlive period.
+ void shutdown() {
+ _close();
+ }
+}
+
+/// [SseHandler] handles requests on a user defined path to create
+/// two-way communications of JSON encodable data between server and clients.
+///
+/// A server sends messages to a client through an SSE channel, while
+/// a client sends message to a server through HTTP POST requests.
+class SseHandler {
+ final _logger = Logger('SseHandler');
+ final Uri _uri;
+ final Duration? _keepAlive;
+ final _connections = <String?, SseConnection>{};
+ final _connectionController = StreamController<SseConnection>();
+
+ StreamQueue<SseConnection>? _connectionsStream;
+
+ /// [_uri] is the URL under which the server is listening for
+ /// incoming bi-directional SSE connections.
+ ///
+ /// If [keepAlive] is supplied, connections will remain active for this
+ /// period after a disconnect and can be reconnected transparently. If there
+ /// is no reconnect within that period, the connection will be closed
+ /// normally.
+ ///
+ /// If [keepAlive] is not supplied, connections will be closed immediately
+ /// after a disconnect.
+ SseHandler(this._uri, {Duration? keepAlive}) : _keepAlive = keepAlive;
+
+ StreamQueue<SseConnection> get connections =>
+ _connectionsStream ??= StreamQueue(_connectionController.stream);
+
+ shelf.Handler get handler => _handle;
+
+ int get numberOfClients => _connections.length;
+
+ shelf.Response _createSseConnection(shelf.Request req, String path) {
+ req.hijack((channel) async {
+ var sink = utf8.encoder.startChunkedConversion(channel.sink);
+ sink.add(_sseHeaders(req.headers['origin']));
+ var clientId = req.url.queryParameters['sseClientId'];
+
+ // Check if we already have a connection for this ID that is in the
+ // process of timing out
+ // (in which case we can reconnect it transparently).
+ if (_connections[clientId] != null &&
+ _connections[clientId]!.isInKeepAlivePeriod) {
+ _connections[clientId]!._acceptReconnection(sink);
+ } else {
+ var connection = SseConnection(sink, keepAlive: _keepAlive);
+ _connections[clientId] = connection;
+ unawaited(connection._closedCompleter.future.then((_) {
+ _connections.remove(clientId);
+ }));
+ _connectionController.add(connection);
+ }
+ // Remove connection when it is remotely closed or the stream is
+ // cancelled.
+ channel.stream.listen((_) {
+ // SSE is unidirectional. Responses are handled through POST requests.
+ }, onDone: () {
+ _connections[clientId]?._handleDisconnect();
+ });
+ });
+ }
+
+ String _getOriginalPath(shelf.Request req) => req.requestedUri.path;
+
+ Future<shelf.Response> _handle(shelf.Request req) async {
+ var path = _getOriginalPath(req);
+ if (_uri.path != path) {
+ return shelf.Response.notFound('');
+ }
+
+ if (req.headers['accept'] == 'text/event-stream' && req.method == 'GET') {
+ return _createSseConnection(req, path);
+ }
+
+ if (req.headers['accept'] != 'text/event-stream' && req.method == 'POST') {
+ return _handleIncomingMessage(req, path);
+ }
+
+ return shelf.Response.notFound('');
+ }
+
+ Future<shelf.Response> _handleIncomingMessage(
+ shelf.Request req, String path) async {
+ String? clientId;
+ try {
+ clientId = req.url.queryParameters['sseClientId'];
+ var messageId = int.parse(req.url.queryParameters['messageId'] ?? '0');
+ var message = await req.readAsString();
+ var jsonObject = json.decode(message) as String;
+ _connections[clientId]?._addIncomingMessage(messageId, jsonObject);
+ } catch (e, st) {
+ _logger.fine('[$clientId] Failed to handle incoming message. $e $st');
+ }
+ return shelf.Response.ok('', headers: {
+ 'access-control-allow-credentials': 'true',
+ 'access-control-allow-origin': _originFor(req),
+ });
+ }
+
+ String _originFor(shelf.Request req) =>
+ // Firefox does not set header "origin".
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1508661
+ req.headers['origin'] ?? req.headers['host']!;
+
+ /// Immediately close all connections, ignoring any keepAlive periods.
+ void shutdown() {
+ for (final connection in _connections.values) {
+ connection.shutdown();
+ }
+ }
+}
+
+void closeSink(SseConnection connection) => connection._sink.close();
diff --git a/pkgs/sse/lib/src/util/uuid.dart b/pkgs/sse/lib/src/util/uuid.dart
new file mode 100644
index 0000000..a1aa398
--- /dev/null
+++ b/pkgs/sse/lib/src/util/uuid.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:math' show Random;
+
+/// Returns a unique ID in the format:
+///
+/// f47ac10b-58cc-4372-a567-0e02b2c3d479
+///
+/// The generated uuids are 128 bit numbers encoded in a specific string format.
+/// For more information, see
+/// [en.wikipedia.org/wiki/Universally_unique_identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier).
+String generateUuidV4() {
+ final random = Random();
+
+ int generateBits(int bitCount) => random.nextInt(1 << bitCount);
+
+ String printDigits(int value, int count) =>
+ value.toRadixString(16).padLeft(count, '0');
+ String bitsDigits(int bitCount, int digitCount) =>
+ printDigits(generateBits(bitCount), digitCount);
+
+ // Generate xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx / 8-4-4-4-12.
+ var special = 8 + random.nextInt(4);
+
+ return '${bitsDigits(16, 4)}${bitsDigits(16, 4)}-'
+ '${bitsDigits(16, 4)}-'
+ '4${bitsDigits(12, 3)}-'
+ '${printDigits(special, 1)}${bitsDigits(12, 3)}-'
+ '${bitsDigits(16, 4)}${bitsDigits(16, 4)}${bitsDigits(16, 4)}';
+}
diff --git a/pkgs/sse/pubspec.yaml b/pkgs/sse/pubspec.yaml
new file mode 100644
index 0000000..bd70f74
--- /dev/null
+++ b/pkgs/sse/pubspec.yaml
@@ -0,0 +1,25 @@
+name: sse
+version: 4.1.7
+description: >-
+ Provides client and server functionality for setting up bi-directional
+ communication through Server Sent Events (SSE) and corresponding POST
+ requests.
+repository: https://github.com/dart-lang/tools/tree/main/pkgs/sse
+
+environment:
+ sdk: ^3.3.0
+
+dependencies:
+ async: ^2.0.8
+ collection: ^1.0.0
+ logging: ^1.0.0
+ pool: ^1.5.0
+ shelf: ^1.1.0
+ stream_channel: ^2.0.0
+ web: '>=0.5.0 <2.0.0'
+
+dev_dependencies:
+ dart_flutter_team_lints: ^3.0.0
+ shelf_static: ^1.0.0
+ test: ^1.16.6
+ webdriver: ^3.0.0
diff --git a/pkgs/sse/test/sse_test.dart b/pkgs/sse/test/sse_test.dart
new file mode 100644
index 0000000..0455baa
--- /dev/null
+++ b/pkgs/sse/test/sse_test.dart
@@ -0,0 +1,270 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+@TestOn('vm')
+library;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:async/async.dart';
+import 'package:shelf/shelf.dart' as shelf;
+import 'package:shelf/shelf_io.dart' as io;
+import 'package:shelf_static/shelf_static.dart';
+import 'package:sse/server/sse_handler.dart';
+import 'package:sse/src/server/sse_handler.dart' show closeSink;
+import 'package:test/test.dart';
+import 'package:webdriver/async_io.dart';
+
+void main() {
+ late HttpServer server;
+ late WebDriver webdriver;
+ late SseHandler handler;
+ late Process chromeDriver;
+
+ setUpAll(() async {
+ try {
+ chromeDriver = await Process.start(
+ 'chromedriver', ['--port=4444', '--url-base=wd/hub']);
+ } catch (e) {
+ throw StateError(
+ 'Could not start ChromeDriver. Is it installed?\nError: $e');
+ }
+ });
+
+ tearDownAll(() {
+ chromeDriver.kill();
+ });
+
+ group('SSE', () {
+ setUp(() async {
+ handler = SseHandler(Uri.parse('/test'));
+
+ var cascade = shelf.Cascade()
+ .add(handler.handler)
+ .add(_faviconHandler)
+ .add(createStaticHandler('test/web',
+ listDirectories: true, defaultDocument: 'index.html'));
+
+ server = await io.serve(cascade.handler, 'localhost', 0);
+ var capabilities = Capabilities.chrome
+ ..addAll({
+ Capabilities.chromeOptions: {
+ 'args': ['--headless']
+ }
+ });
+ webdriver = await createDriver(desired: capabilities);
+ });
+
+ tearDown(() async {
+ await webdriver.quit();
+ await server.close();
+ });
+
+ test('can round trip messages', () async {
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ connection.sink.add('blah');
+ expect(await connection.stream.first, 'blah');
+ });
+
+ test('can send a significant number of requests', () async {
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ var limit = 7000;
+ for (var i = 0; i < limit; i++) {
+ connection.sink.add('$i');
+ }
+ await connection.stream.take(limit).drain<void>();
+ });
+
+ test('messages arrive in-order', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ var expected = <String>[];
+ var count = 100;
+ for (var i = 0; i < count; i++) {
+ expected.add(i.toString());
+ }
+ connection.sink.add('send $count');
+
+ expect(await connection.stream.take(count).toList(), equals(expected));
+ });
+
+ test('multiple clients can connect', () async {
+ var connections = handler.connections;
+ await webdriver.get('http://localhost:${server.port}');
+ await connections.next;
+ await webdriver.get('http://localhost:${server.port}');
+ await connections.next;
+ });
+
+ test('routes data correctly', () async {
+ var connections = handler.connections;
+ await webdriver.get('http://localhost:${server.port}');
+ var connectionA = await connections.next;
+ connectionA.sink.add('foo');
+ expect(await connectionA.stream.first, 'foo');
+
+ await webdriver.get('http://localhost:${server.port}');
+ var connectionB = await connections.next;
+ connectionB.sink.add('bar');
+ expect(await connectionB.stream.first, 'bar');
+ });
+
+ test('can close from the server', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+ await connection.sink.close();
+ await pumpEventQueue();
+ expect(handler.numberOfClients, 0);
+ });
+
+ test('client reconnects after being disconnected', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+ await connection.sink.close();
+ await pumpEventQueue();
+ expect(handler.numberOfClients, 0);
+
+ // Ensure the client reconnects
+ await handler.connections.next;
+ });
+
+ test('can close from the client-side', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ var closeButton = await webdriver.findElement(const By.tagName('button'));
+ await closeButton.click();
+
+ // Should complete since the connection is closed.
+ await connection.stream.drain<void>();
+ expect(handler.numberOfClients, 0);
+ });
+
+ test('cancelling the listener closes the connection', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ var sub = connection.stream.listen((_) {});
+ await sub.cancel();
+ await pumpEventQueue();
+ expect(handler.numberOfClients, 0);
+ });
+
+ test('disconnects when navigating away', () async {
+ await webdriver.get('http://localhost:${server.port}');
+ expect(handler.numberOfClients, 1);
+
+ await webdriver.get('chrome://version/');
+ expect(handler.numberOfClients, 0);
+ });
+ });
+
+ group('SSE with server keep-alive', () {
+ setUp(() async {
+ handler =
+ SseHandler(Uri.parse('/test'), keepAlive: const Duration(seconds: 5));
+
+ var cascade = shelf.Cascade()
+ .add(handler.handler)
+ .add(_faviconHandler)
+ .add(createStaticHandler('test/web',
+ listDirectories: true, defaultDocument: 'index.html'));
+
+ server = await io.serve(cascade.handler, 'localhost', 0);
+ var capabilities = Capabilities.chrome
+ ..addAll({
+ Capabilities.chromeOptions: {
+ 'args': ['--headless']
+ }
+ });
+ webdriver = await createDriver(desired: capabilities);
+ });
+
+ tearDown(() async {
+ await webdriver.quit();
+ await server.close();
+ });
+
+ test('client reconnect use the same connection', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ // Close the underlying connection.
+ closeSink(connection);
+ // Ensure we can still round-trip data on the original connection and that
+ // the connection is no longer marked keep-alive once it's reconnected.
+ connection.sink.add('bar');
+ var queue = StreamQueue(connection.stream);
+ expect(await queue.next, 'bar');
+
+ // Now check that we can reconnect multiple times.
+ closeSink(connection);
+ connection.sink.add('bar');
+ expect(await queue.next, 'bar');
+ expect(handler.numberOfClients, 1);
+ });
+
+ test('messages sent during disconnect arrive in-order', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ var connection = await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ // Close the underlying connection.
+ closeSink(connection);
+ connection.sink.add('one');
+ connection.sink.add('two');
+ await pumpEventQueue();
+
+ // Ensure there's still a connection.
+ expect(handler.numberOfClients, 1);
+
+ // Ensure messages arrive in the same order
+ expect(await connection.stream.take(2).toList(), equals(['one', 'two']));
+ });
+
+ test('explicit shutdown does not wait for keepAlive', () async {
+ expect(handler.numberOfClients, 0);
+ await webdriver.get('http://localhost:${server.port}');
+ await handler.connections.next;
+ expect(handler.numberOfClients, 1);
+
+ // Close the underlying connection.
+ handler.shutdown();
+
+ // Wait for a short period to allow the connection to close, but not
+ // long enough that the 30second keep-alive may have expired.
+ var maxPumps = 50;
+ while (handler.numberOfClients > 0 && maxPumps-- > 0) {
+ await pumpEventQueue(times: 1);
+ }
+
+ // Ensure there are not connected clients.
+ expect(handler.numberOfClients, 0);
+ });
+ }, timeout: const Timeout(Duration(seconds: 120)));
+}
+
+FutureOr<shelf.Response> _faviconHandler(shelf.Request request) {
+ if (request.url.path.endsWith('favicon.ico')) {
+ return shelf.Response.ok('');
+ }
+ return shelf.Response.notFound('');
+}
diff --git a/pkgs/sse/test/web/index.dart b/pkgs/sse/test/web/index.dart
new file mode 100644
index 0000000..c4d78cd
--- /dev/null
+++ b/pkgs/sse/test/web/index.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:sse/client/sse_client.dart';
+import 'package:web/web.dart';
+
+void main() {
+ var channel = SseClient('/test');
+
+ document.querySelector('button')!.onClick.listen((_) {
+ channel.sink.close();
+ });
+
+ channel.stream.listen((s) {
+ if (s.startsWith('send ')) {
+ var count = int.parse(s.split(' ').last);
+ for (var i = 0; i < count; i++) {
+ channel.sink.add('$i');
+ }
+ } else {
+ channel.sink.add(s);
+ }
+ });
+}
diff --git a/pkgs/sse/test/web/index.dart.js b/pkgs/sse/test/web/index.dart.js
new file mode 100644
index 0000000..e1b37b9
--- /dev/null
+++ b/pkgs/sse/test/web/index.dart.js
@@ -0,0 +1,8851 @@
+// Generated by dart2js (NullSafetyMode.sound, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.4.0-157.0.dev.
+// The code supports the following hooks:
+// dartPrint(message):
+// if this function is defined it is called instead of the Dart [print]
+// method.
+//
+// dartMainRunner(main, args):
+// if this function is defined, the Dart [main] method will not be invoked
+// directly. Instead, a closure that will invoke [main], and its arguments
+// [args] is passed to [dartMainRunner].
+//
+// dartDeferredLibraryLoader(uri, successCallback, errorCallback, loadId, loadPriority):
+// if this function is defined, it will be called when a deferred library
+// is loaded. It should load and eval the javascript of `uri`, and call
+// successCallback. If it fails to do so, it should call errorCallback with
+// an error. The loadId argument is the deferred import that resulted in
+// this uri being loaded. The loadPriority argument is the priority the
+// library should be loaded with as specified in the code via the
+// load-priority annotation (0: normal, 1: high).
+// dartDeferredLibraryMultiLoader(uris, successCallback, errorCallback, loadId, loadPriority):
+// if this function is defined, it will be called when a deferred library
+// is loaded. It should load and eval the javascript of every URI in `uris`,
+// and call successCallback. If it fails to do so, it should call
+// errorCallback with an error. The loadId argument is the deferred import
+// that resulted in this uri being loaded. The loadPriority argument is the
+// priority the library should be loaded with as specified in the code via
+// the load-priority annotation (0: normal, 1: high).
+//
+// dartCallInstrumentation(id, qualifiedName):
+// if this function is defined, it will be called at each entry of a
+// method or constructor. Used only when compiling programs with
+// --experiment-call-instrumentation.
+(function dartProgram() {
+ function copyProperties(from, to) {
+ var keys = Object.keys(from);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ to[key] = from[key];
+ }
+ }
+ function mixinPropertiesHard(from, to) {
+ var keys = Object.keys(from);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ if (!to.hasOwnProperty(key)) {
+ to[key] = from[key];
+ }
+ }
+ }
+ function mixinPropertiesEasy(from, to) {
+ Object.assign(to, from);
+ }
+ var supportsDirectProtoAccess = function() {
+ var cls = function() {
+ };
+ cls.prototype = {p: {}};
+ var object = new cls();
+ if (!(Object.getPrototypeOf(object) && Object.getPrototypeOf(object).p === cls.prototype.p))
+ return false;
+ try {
+ if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0)
+ return true;
+ if (typeof version == "function" && version.length == 0) {
+ var v = version();
+ if (/^\d+\.\d+\.\d+\.\d+$/.test(v))
+ return true;
+ }
+ } catch (_) {
+ }
+ return false;
+ }();
+ function inherit(cls, sup) {
+ cls.prototype.constructor = cls;
+ cls.prototype["$is" + cls.name] = cls;
+ if (sup != null) {
+ if (supportsDirectProtoAccess) {
+ Object.setPrototypeOf(cls.prototype, sup.prototype);
+ return;
+ }
+ var clsPrototype = Object.create(sup.prototype);
+ copyProperties(cls.prototype, clsPrototype);
+ cls.prototype = clsPrototype;
+ }
+ }
+ function inheritMany(sup, classes) {
+ for (var i = 0; i < classes.length; i++) {
+ inherit(classes[i], sup);
+ }
+ }
+ function mixinEasy(cls, mixin) {
+ mixinPropertiesEasy(mixin.prototype, cls.prototype);
+ cls.prototype.constructor = cls;
+ }
+ function mixinHard(cls, mixin) {
+ mixinPropertiesHard(mixin.prototype, cls.prototype);
+ cls.prototype.constructor = cls;
+ }
+ function lazy(holder, name, getterName, initializer) {
+ var uninitializedSentinel = holder;
+ holder[name] = uninitializedSentinel;
+ holder[getterName] = function() {
+ if (holder[name] === uninitializedSentinel) {
+ holder[name] = initializer();
+ }
+ holder[getterName] = function() {
+ return this[name];
+ };
+ return holder[name];
+ };
+ }
+ function lazyFinal(holder, name, getterName, initializer) {
+ var uninitializedSentinel = holder;
+ holder[name] = uninitializedSentinel;
+ holder[getterName] = function() {
+ if (holder[name] === uninitializedSentinel) {
+ var value = initializer();
+ if (holder[name] !== uninitializedSentinel) {
+ A.throwLateFieldADI(name);
+ }
+ holder[name] = value;
+ }
+ var finalValue = holder[name];
+ holder[getterName] = function() {
+ return finalValue;
+ };
+ return finalValue;
+ };
+ }
+ function makeConstList(list) {
+ list.immutable$list = Array;
+ list.fixed$length = Array;
+ return list;
+ }
+ function convertToFastObject(properties) {
+ function t() {
+ }
+ t.prototype = properties;
+ new t();
+ return properties;
+ }
+ function convertAllToFastObject(arrayOfObjects) {
+ for (var i = 0; i < arrayOfObjects.length; ++i) {
+ convertToFastObject(arrayOfObjects[i]);
+ }
+ }
+ var functionCounter = 0;
+ function instanceTearOffGetter(isIntercepted, parameters) {
+ var cache = null;
+ return isIntercepted ? function(receiver) {
+ if (cache === null)
+ cache = A.closureFromTearOff(parameters);
+ return new cache(receiver, this);
+ } : function() {
+ if (cache === null)
+ cache = A.closureFromTearOff(parameters);
+ return new cache(this, null);
+ };
+ }
+ function staticTearOffGetter(parameters) {
+ var cache = null;
+ return function() {
+ if (cache === null)
+ cache = A.closureFromTearOff(parameters).prototype;
+ return cache;
+ };
+ }
+ var typesOffset = 0;
+ function tearOffParameters(container, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
+ if (typeof funType == "number") {
+ funType += typesOffset;
+ }
+ return {co: container, iS: isStatic, iI: isIntercepted, rC: requiredParameterCount, dV: optionalParameterDefaultValues, cs: callNames, fs: funsOrNames, fT: funType, aI: applyIndex || 0, nDA: needsDirectAccess};
+ }
+ function installStaticTearOff(holder, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
+ var parameters = tearOffParameters(holder, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, false);
+ var getterFunction = staticTearOffGetter(parameters);
+ holder[getterName] = getterFunction;
+ }
+ function installInstanceTearOff(prototype, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
+ isIntercepted = !!isIntercepted;
+ var parameters = tearOffParameters(prototype, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, !!needsDirectAccess);
+ var getterFunction = instanceTearOffGetter(isIntercepted, parameters);
+ prototype[getterName] = getterFunction;
+ }
+ function setOrUpdateInterceptorsByTag(newTags) {
+ var tags = init.interceptorsByTag;
+ if (!tags) {
+ init.interceptorsByTag = newTags;
+ return;
+ }
+ copyProperties(newTags, tags);
+ }
+ function setOrUpdateLeafTags(newTags) {
+ var tags = init.leafTags;
+ if (!tags) {
+ init.leafTags = newTags;
+ return;
+ }
+ copyProperties(newTags, tags);
+ }
+ function updateTypes(newTypes) {
+ var types = init.types;
+ var length = types.length;
+ types.push.apply(types, newTypes);
+ return length;
+ }
+ function updateHolder(holder, newHolder) {
+ copyProperties(newHolder, holder);
+ return holder;
+ }
+ var hunkHelpers = function() {
+ var mkInstance = function(isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
+ return function(container, getterName, name, funType) {
+ return installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex, false);
+ };
+ },
+ mkStatic = function(requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
+ return function(container, getterName, name, funType) {
+ return installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex);
+ };
+ };
+ return {inherit: inherit, inheritMany: inheritMany, mixin: mixinEasy, mixinHard: mixinHard, installStaticTearOff: installStaticTearOff, installInstanceTearOff: installInstanceTearOff, _instance_0u: mkInstance(0, 0, null, ["call$0"], 0), _instance_1u: mkInstance(0, 1, null, ["call$1"], 0), _instance_2u: mkInstance(0, 2, null, ["call$2"], 0), _instance_0i: mkInstance(1, 0, null, ["call$0"], 0), _instance_1i: mkInstance(1, 1, null, ["call$1"], 0), _instance_2i: mkInstance(1, 2, null, ["call$2"], 0), _static_0: mkStatic(0, null, ["call$0"], 0), _static_1: mkStatic(1, null, ["call$1"], 0), _static_2: mkStatic(2, null, ["call$2"], 0), makeConstList: makeConstList, lazy: lazy, lazyFinal: lazyFinal, updateHolder: updateHolder, convertToFastObject: convertToFastObject, updateTypes: updateTypes, setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag, setOrUpdateLeafTags: setOrUpdateLeafTags};
+ }();
+ function initializeDeferredHunk(hunk) {
+ typesOffset = init.types.length;
+ hunk(hunkHelpers, init, holders, $);
+ }
+ var J = {
+ makeDispatchRecord(interceptor, proto, extension, indexability) {
+ return {i: interceptor, p: proto, e: extension, x: indexability};
+ },
+ getNativeInterceptor(object) {
+ var proto, objectProto, $constructor, interceptor, t1,
+ record = object[init.dispatchPropertyName];
+ if (record == null)
+ if ($.initNativeDispatchFlag == null) {
+ A.initNativeDispatch();
+ record = object[init.dispatchPropertyName];
+ }
+ if (record != null) {
+ proto = record.p;
+ if (false === proto)
+ return record.i;
+ if (true === proto)
+ return object;
+ objectProto = Object.getPrototypeOf(object);
+ if (proto === objectProto)
+ return record.i;
+ if (record.e === objectProto)
+ throw A.wrapException(A.UnimplementedError$("Return interceptor for " + A.S(proto(object, record))));
+ }
+ $constructor = object.constructor;
+ if ($constructor == null)
+ interceptor = null;
+ else {
+ t1 = $._JS_INTEROP_INTERCEPTOR_TAG;
+ if (t1 == null)
+ t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js");
+ interceptor = $constructor[t1];
+ }
+ if (interceptor != null)
+ return interceptor;
+ interceptor = A.lookupAndCacheInterceptor(object);
+ if (interceptor != null)
+ return interceptor;
+ if (typeof object == "function")
+ return B.JavaScriptFunction_methods;
+ proto = Object.getPrototypeOf(object);
+ if (proto == null)
+ return B.PlainJavaScriptObject_methods;
+ if (proto === Object.prototype)
+ return B.PlainJavaScriptObject_methods;
+ if (typeof $constructor == "function") {
+ t1 = $._JS_INTEROP_INTERCEPTOR_TAG;
+ if (t1 == null)
+ t1 = $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js");
+ Object.defineProperty($constructor, t1, {value: B.UnknownJavaScriptObject_methods, enumerable: false, writable: true, configurable: true});
+ return B.UnknownJavaScriptObject_methods;
+ }
+ return B.UnknownJavaScriptObject_methods;
+ },
+ JSArray_JSArray$fixed($length, $E) {
+ if ($length < 0 || $length > 4294967295)
+ throw A.wrapException(A.RangeError$range($length, 0, 4294967295, "length", null));
+ return J.JSArray_JSArray$markFixed(new Array($length), $E);
+ },
+ JSArray_JSArray$growable($length, $E) {
+ if ($length < 0)
+ throw A.wrapException(A.ArgumentError$("Length must be a non-negative integer: " + $length, null));
+ return A._setArrayType(new Array($length), $E._eval$1("JSArray<0>"));
+ },
+ JSArray_JSArray$markFixed(allocation, $E) {
+ return J.JSArray_markFixedList(A._setArrayType(allocation, $E._eval$1("JSArray<0>")), $E);
+ },
+ JSArray_markFixedList(list, $T) {
+ list.fixed$length = Array;
+ return list;
+ },
+ JSArray_markUnmodifiableList(list) {
+ list.fixed$length = Array;
+ list.immutable$list = Array;
+ return list;
+ },
+ getInterceptor$(receiver) {
+ if (typeof receiver == "number") {
+ if (Math.floor(receiver) == receiver)
+ return J.JSInt.prototype;
+ return J.JSNumNotInt.prototype;
+ }
+ if (typeof receiver == "string")
+ return J.JSString.prototype;
+ if (receiver == null)
+ return J.JSNull.prototype;
+ if (typeof receiver == "boolean")
+ return J.JSBool.prototype;
+ if (Array.isArray(receiver))
+ return J.JSArray.prototype;
+ if (typeof receiver != "object") {
+ if (typeof receiver == "function")
+ return J.JavaScriptFunction.prototype;
+ if (typeof receiver == "symbol")
+ return J.JavaScriptSymbol.prototype;
+ if (typeof receiver == "bigint")
+ return J.JavaScriptBigInt.prototype;
+ return receiver;
+ }
+ if (receiver instanceof A.Object)
+ return receiver;
+ return J.getNativeInterceptor(receiver);
+ },
+ getInterceptor$asx(receiver) {
+ if (typeof receiver == "string")
+ return J.JSString.prototype;
+ if (receiver == null)
+ return receiver;
+ if (Array.isArray(receiver))
+ return J.JSArray.prototype;
+ if (typeof receiver != "object") {
+ if (typeof receiver == "function")
+ return J.JavaScriptFunction.prototype;
+ if (typeof receiver == "symbol")
+ return J.JavaScriptSymbol.prototype;
+ if (typeof receiver == "bigint")
+ return J.JavaScriptBigInt.prototype;
+ return receiver;
+ }
+ if (receiver instanceof A.Object)
+ return receiver;
+ return J.getNativeInterceptor(receiver);
+ },
+ getInterceptor$ax(receiver) {
+ if (receiver == null)
+ return receiver;
+ if (Array.isArray(receiver))
+ return J.JSArray.prototype;
+ if (typeof receiver != "object") {
+ if (typeof receiver == "function")
+ return J.JavaScriptFunction.prototype;
+ if (typeof receiver == "symbol")
+ return J.JavaScriptSymbol.prototype;
+ if (typeof receiver == "bigint")
+ return J.JavaScriptBigInt.prototype;
+ return receiver;
+ }
+ if (receiver instanceof A.Object)
+ return receiver;
+ return J.getNativeInterceptor(receiver);
+ },
+ getInterceptor$s(receiver) {
+ if (typeof receiver == "string")
+ return J.JSString.prototype;
+ if (receiver == null)
+ return receiver;
+ if (!(receiver instanceof A.Object))
+ return J.UnknownJavaScriptObject.prototype;
+ return receiver;
+ },
+ get$hashCode$(receiver) {
+ return J.getInterceptor$(receiver).get$hashCode(receiver);
+ },
+ get$iterator$ax(receiver) {
+ return J.getInterceptor$ax(receiver).get$iterator(receiver);
+ },
+ get$length$asx(receiver) {
+ return J.getInterceptor$asx(receiver).get$length(receiver);
+ },
+ get$runtimeType$(receiver) {
+ return J.getInterceptor$(receiver).get$runtimeType(receiver);
+ },
+ $eq$(receiver, a0) {
+ if (receiver == null)
+ return a0 == null;
+ if (typeof receiver != "object")
+ return a0 != null && receiver === a0;
+ return J.getInterceptor$(receiver).$eq(receiver, a0);
+ },
+ matchAsPrefix$2$s(receiver, a0, a1) {
+ return J.getInterceptor$s(receiver).matchAsPrefix$2(receiver, a0, a1);
+ },
+ noSuchMethod$1$(receiver, a0) {
+ return J.getInterceptor$(receiver).noSuchMethod$1(receiver, a0);
+ },
+ toString$0$(receiver) {
+ return J.getInterceptor$(receiver).toString$0(receiver);
+ },
+ Interceptor: function Interceptor() {
+ },
+ JSBool: function JSBool() {
+ },
+ JSNull: function JSNull() {
+ },
+ JavaScriptObject: function JavaScriptObject() {
+ },
+ LegacyJavaScriptObject: function LegacyJavaScriptObject() {
+ },
+ PlainJavaScriptObject: function PlainJavaScriptObject() {
+ },
+ UnknownJavaScriptObject: function UnknownJavaScriptObject() {
+ },
+ JavaScriptFunction: function JavaScriptFunction() {
+ },
+ JavaScriptBigInt: function JavaScriptBigInt() {
+ },
+ JavaScriptSymbol: function JavaScriptSymbol() {
+ },
+ JSArray: function JSArray(t0) {
+ this.$ti = t0;
+ },
+ JSUnmodifiableArray: function JSUnmodifiableArray(t0) {
+ this.$ti = t0;
+ },
+ ArrayIterator: function ArrayIterator(t0, t1, t2) {
+ var _ = this;
+ _._iterable = t0;
+ _._length = t1;
+ _._index = 0;
+ _._current = null;
+ _.$ti = t2;
+ },
+ JSNumber: function JSNumber() {
+ },
+ JSInt: function JSInt() {
+ },
+ JSNumNotInt: function JSNumNotInt() {
+ },
+ JSString: function JSString() {
+ }
+ },
+ A = {JS_CONST: function JS_CONST() {
+ },
+ checkNotNullable(value, $name, $T) {
+ return value;
+ },
+ isToStringVisiting(object) {
+ var t1, i;
+ for (t1 = $.toStringVisiting.length, i = 0; i < t1; ++i)
+ if (object === $.toStringVisiting[i])
+ return true;
+ return false;
+ },
+ IterableElementError_noElement() {
+ return new A.StateError("No element");
+ },
+ IterableElementError_tooFew() {
+ return new A.StateError("Too few elements");
+ },
+ LateError: function LateError(t0) {
+ this._message = t0;
+ },
+ nullFuture_closure: function nullFuture_closure() {
+ },
+ EfficientLengthIterable: function EfficientLengthIterable() {
+ },
+ ListIterable: function ListIterable() {
+ },
+ ListIterator: function ListIterator(t0, t1, t2) {
+ var _ = this;
+ _.__internal$_iterable = t0;
+ _.__internal$_length = t1;
+ _.__internal$_index = 0;
+ _.__internal$_current = null;
+ _.$ti = t2;
+ },
+ FixedLengthListMixin: function FixedLengthListMixin() {
+ },
+ Symbol: function Symbol(t0) {
+ this._name = t0;
+ },
+ unminifyOrTag(rawClassName) {
+ var preserved = init.mangledGlobalNames[rawClassName];
+ if (preserved != null)
+ return preserved;
+ return rawClassName;
+ },
+ isJsIndexable(object, record) {
+ var result;
+ if (record != null) {
+ result = record.x;
+ if (result != null)
+ return result;
+ }
+ return type$.JavaScriptIndexingBehavior_dynamic._is(object);
+ },
+ S(value) {
+ var result;
+ if (typeof value == "string")
+ return value;
+ if (typeof value == "number") {
+ if (value !== 0)
+ return "" + value;
+ } else if (true === value)
+ return "true";
+ else if (false === value)
+ return "false";
+ else if (value == null)
+ return "null";
+ result = J.toString$0$(value);
+ return result;
+ },
+ Primitives_objectHashCode(object) {
+ var hash,
+ property = $.Primitives__identityHashCodeProperty;
+ if (property == null)
+ property = $.Primitives__identityHashCodeProperty = Symbol("identityHashCode");
+ hash = object[property];
+ if (hash == null) {
+ hash = Math.random() * 0x3fffffff | 0;
+ object[property] = hash;
+ }
+ return hash;
+ },
+ Primitives_parseInt(source, radix) {
+ var decimalMatch, maxCharCode, digitsPart, t1, i, _null = null,
+ match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
+ if (match == null)
+ return _null;
+ if (3 >= match.length)
+ return A.ioore(match, 3);
+ decimalMatch = match[3];
+ if (radix == null) {
+ if (decimalMatch != null)
+ return parseInt(source, 10);
+ if (match[2] != null)
+ return parseInt(source, 16);
+ return _null;
+ }
+ if (radix < 2 || radix > 36)
+ throw A.wrapException(A.RangeError$range(radix, 2, 36, "radix", _null));
+ if (radix === 10 && decimalMatch != null)
+ return parseInt(source, 10);
+ if (radix < 10 || decimalMatch == null) {
+ maxCharCode = radix <= 10 ? 47 + radix : 86 + radix;
+ digitsPart = match[1];
+ for (t1 = digitsPart.length, i = 0; i < t1; ++i)
+ if ((digitsPart.charCodeAt(i) | 32) > maxCharCode)
+ return _null;
+ }
+ return parseInt(source, radix);
+ },
+ Primitives_objectTypeName(object) {
+ return A.Primitives__objectTypeNameNewRti(object);
+ },
+ Primitives__objectTypeNameNewRti(object) {
+ var interceptor, dispatchName, $constructor, constructorName;
+ if (object instanceof A.Object)
+ return A._rtiToString(A.instanceType(object), null);
+ interceptor = J.getInterceptor$(object);
+ if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) {
+ dispatchName = B.C_JS_CONST(object);
+ if (dispatchName !== "Object" && dispatchName !== "")
+ return dispatchName;
+ $constructor = object.constructor;
+ if (typeof $constructor == "function") {
+ constructorName = $constructor.name;
+ if (typeof constructorName == "string" && constructorName !== "Object" && constructorName !== "")
+ return constructorName;
+ }
+ }
+ return A._rtiToString(A.instanceType(object), null);
+ },
+ Primitives_safeToString(object) {
+ if (typeof object == "number" || A._isBool(object))
+ return J.toString$0$(object);
+ if (typeof object == "string")
+ return JSON.stringify(object);
+ if (object instanceof A.Closure)
+ return object.toString$0(0);
+ return "Instance of '" + A.Primitives_objectTypeName(object) + "'";
+ },
+ Primitives_stringFromCharCode(charCode) {
+ var bits;
+ if (0 <= charCode) {
+ if (charCode <= 65535)
+ return String.fromCharCode(charCode);
+ if (charCode <= 1114111) {
+ bits = charCode - 65536;
+ return String.fromCharCode((B.JSInt_methods._shrOtherPositive$1(bits, 10) | 55296) >>> 0, bits & 1023 | 56320);
+ }
+ }
+ throw A.wrapException(A.RangeError$range(charCode, 0, 1114111, null, null));
+ },
+ Primitives_lazyAsJsDate(receiver) {
+ if (receiver.date === void 0)
+ receiver.date = new Date(receiver._value);
+ return receiver.date;
+ },
+ Primitives_getYear(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCFullYear() + 0 : A.Primitives_lazyAsJsDate(receiver).getFullYear() + 0;
+ },
+ Primitives_getMonth(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCMonth() + 1 : A.Primitives_lazyAsJsDate(receiver).getMonth() + 1;
+ },
+ Primitives_getDay(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCDate() + 0 : A.Primitives_lazyAsJsDate(receiver).getDate() + 0;
+ },
+ Primitives_getHours(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCHours() + 0 : A.Primitives_lazyAsJsDate(receiver).getHours() + 0;
+ },
+ Primitives_getMinutes(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCMinutes() + 0 : A.Primitives_lazyAsJsDate(receiver).getMinutes() + 0;
+ },
+ Primitives_getSeconds(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCSeconds() + 0 : A.Primitives_lazyAsJsDate(receiver).getSeconds() + 0;
+ },
+ Primitives_getMilliseconds(receiver) {
+ return receiver.isUtc ? A.Primitives_lazyAsJsDate(receiver).getUTCMilliseconds() + 0 : A.Primitives_lazyAsJsDate(receiver).getMilliseconds() + 0;
+ },
+ Primitives_functionNoSuchMethod($function, positionalArguments, namedArguments) {
+ var $arguments, namedArgumentList, t1 = {};
+ t1.argumentCount = 0;
+ $arguments = [];
+ namedArgumentList = [];
+ t1.argumentCount = positionalArguments.length;
+ B.JSArray_methods.addAll$1($arguments, positionalArguments);
+ t1.names = "";
+ if (namedArguments != null && namedArguments.__js_helper$_length !== 0)
+ namedArguments.forEach$1(0, new A.Primitives_functionNoSuchMethod_closure(t1, namedArgumentList, $arguments));
+ return J.noSuchMethod$1$($function, new A.JSInvocationMirror(B.Symbol_call, 0, $arguments, namedArgumentList, 0));
+ },
+ Primitives_applyFunction($function, positionalArguments, namedArguments) {
+ var t1, argumentCount, jsStub;
+ if (Array.isArray(positionalArguments))
+ t1 = namedArguments == null || namedArguments.__js_helper$_length === 0;
+ else
+ t1 = false;
+ if (t1) {
+ argumentCount = positionalArguments.length;
+ if (argumentCount === 0) {
+ if (!!$function.call$0)
+ return $function.call$0();
+ } else if (argumentCount === 1) {
+ if (!!$function.call$1)
+ return $function.call$1(positionalArguments[0]);
+ } else if (argumentCount === 2) {
+ if (!!$function.call$2)
+ return $function.call$2(positionalArguments[0], positionalArguments[1]);
+ } else if (argumentCount === 3) {
+ if (!!$function.call$3)
+ return $function.call$3(positionalArguments[0], positionalArguments[1], positionalArguments[2]);
+ } else if (argumentCount === 4) {
+ if (!!$function.call$4)
+ return $function.call$4(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3]);
+ } else if (argumentCount === 5)
+ if (!!$function.call$5)
+ return $function.call$5(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3], positionalArguments[4]);
+ jsStub = $function["call" + "$" + argumentCount];
+ if (jsStub != null)
+ return jsStub.apply($function, positionalArguments);
+ }
+ return A.Primitives__generalApplyFunction($function, positionalArguments, namedArguments);
+ },
+ Primitives__generalApplyFunction($function, positionalArguments, namedArguments) {
+ var defaultValuesClosure, t1, defaultValues, interceptor, jsFunction, maxArguments, missingDefaults, keys, _i, defaultValue, used, key,
+ $arguments = Array.isArray(positionalArguments) ? positionalArguments : A.List_List$of(positionalArguments, true, type$.dynamic),
+ argumentCount = $arguments.length,
+ requiredParameterCount = $function.$requiredArgCount;
+ if (argumentCount < requiredParameterCount)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ defaultValuesClosure = $function.$defaultValues;
+ t1 = defaultValuesClosure == null;
+ defaultValues = !t1 ? defaultValuesClosure() : null;
+ interceptor = J.getInterceptor$($function);
+ jsFunction = interceptor["call*"];
+ if (typeof jsFunction == "string")
+ jsFunction = interceptor[jsFunction];
+ if (t1) {
+ if (namedArguments != null && namedArguments.__js_helper$_length !== 0)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ if (argumentCount === requiredParameterCount)
+ return jsFunction.apply($function, $arguments);
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ }
+ if (Array.isArray(defaultValues)) {
+ if (namedArguments != null && namedArguments.__js_helper$_length !== 0)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ maxArguments = requiredParameterCount + defaultValues.length;
+ if (argumentCount > maxArguments)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, null);
+ if (argumentCount < maxArguments) {
+ missingDefaults = defaultValues.slice(argumentCount - requiredParameterCount);
+ if ($arguments === positionalArguments)
+ $arguments = A.List_List$of($arguments, true, type$.dynamic);
+ B.JSArray_methods.addAll$1($arguments, missingDefaults);
+ }
+ return jsFunction.apply($function, $arguments);
+ } else {
+ if (argumentCount > requiredParameterCount)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ if ($arguments === positionalArguments)
+ $arguments = A.List_List$of($arguments, true, type$.dynamic);
+ keys = Object.keys(defaultValues);
+ if (namedArguments == null)
+ for (t1 = keys.length, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) {
+ defaultValue = defaultValues[A._asString(keys[_i])];
+ if (B.C__Required === defaultValue)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ B.JSArray_methods.add$1($arguments, defaultValue);
+ }
+ else {
+ for (t1 = keys.length, used = 0, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) {
+ key = A._asString(keys[_i]);
+ if (namedArguments.containsKey$1(key)) {
+ ++used;
+ B.JSArray_methods.add$1($arguments, namedArguments.$index(0, key));
+ } else {
+ defaultValue = defaultValues[key];
+ if (B.C__Required === defaultValue)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ B.JSArray_methods.add$1($arguments, defaultValue);
+ }
+ }
+ if (used !== namedArguments.__js_helper$_length)
+ return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
+ }
+ return jsFunction.apply($function, $arguments);
+ }
+ },
+ ioore(receiver, index) {
+ if (receiver == null)
+ J.get$length$asx(receiver);
+ throw A.wrapException(A.diagnoseIndexError(receiver, index));
+ },
+ diagnoseIndexError(indexable, index) {
+ var $length, _s5_ = "index";
+ if (!A._isInt(index))
+ return new A.ArgumentError(true, index, _s5_, null);
+ $length = A._asInt(J.get$length$asx(indexable));
+ if (index < 0 || index >= $length)
+ return A.IndexError$withLength(index, $length, indexable, null, _s5_);
+ return A.RangeError$value(index, _s5_);
+ },
+ wrapException(ex) {
+ return A.initializeExceptionWrapper(new Error(), ex);
+ },
+ initializeExceptionWrapper(wrapper, ex) {
+ var t1;
+ if (ex == null)
+ ex = new A.TypeError();
+ wrapper.dartException = ex;
+ t1 = A.toStringWrapper;
+ if ("defineProperty" in Object) {
+ Object.defineProperty(wrapper, "message", {get: t1});
+ wrapper.name = "";
+ } else
+ wrapper.toString = t1;
+ return wrapper;
+ },
+ toStringWrapper() {
+ return J.toString$0$(this.dartException);
+ },
+ throwExpression(ex) {
+ throw A.wrapException(ex);
+ },
+ throwExpressionWithWrapper(ex, wrapper) {
+ throw A.initializeExceptionWrapper(wrapper, ex);
+ },
+ throwConcurrentModificationError(collection) {
+ throw A.wrapException(A.ConcurrentModificationError$(collection));
+ },
+ TypeErrorDecoder_extractPattern(message) {
+ var match, $arguments, argumentsExpr, expr, method, receiver;
+ message = A.quoteStringForRegExp(message.replace(String({}), "$receiver$"));
+ match = message.match(/\\\$[a-zA-Z]+\\\$/g);
+ if (match == null)
+ match = A._setArrayType([], type$.JSArray_String);
+ $arguments = match.indexOf("\\$arguments\\$");
+ argumentsExpr = match.indexOf("\\$argumentsExpr\\$");
+ expr = match.indexOf("\\$expr\\$");
+ method = match.indexOf("\\$method\\$");
+ receiver = match.indexOf("\\$receiver\\$");
+ return new A.TypeErrorDecoder(message.replace(new RegExp("\\\\\\$arguments\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$argumentsExpr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$expr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$method\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$receiver\\\\\\$", "g"), "((?:x|[^x])*)"), $arguments, argumentsExpr, expr, method, receiver);
+ },
+ TypeErrorDecoder_provokeCallErrorOn(expression) {
+ return function($expr$) {
+ var $argumentsExpr$ = "$arguments$";
+ try {
+ $expr$.$method$($argumentsExpr$);
+ } catch (e) {
+ return e.message;
+ }
+ }(expression);
+ },
+ TypeErrorDecoder_provokePropertyErrorOn(expression) {
+ return function($expr$) {
+ try {
+ $expr$.$method$;
+ } catch (e) {
+ return e.message;
+ }
+ }(expression);
+ },
+ JsNoSuchMethodError$(_message, match) {
+ var t1 = match == null,
+ t2 = t1 ? null : match.method;
+ return new A.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver);
+ },
+ unwrapException(ex) {
+ var t1;
+ if (ex == null)
+ return new A.NullThrownFromJavaScriptException(ex);
+ if (ex instanceof A.ExceptionAndStackTrace) {
+ t1 = ex.dartException;
+ return A.saveStackTrace(ex, t1 == null ? type$.Object._as(t1) : t1);
+ }
+ if (typeof ex !== "object")
+ return ex;
+ if ("dartException" in ex)
+ return A.saveStackTrace(ex, ex.dartException);
+ return A._unwrapNonDartException(ex);
+ },
+ saveStackTrace(ex, error) {
+ if (type$.Error._is(error))
+ if (error.$thrownJsError == null)
+ error.$thrownJsError = ex;
+ return error;
+ },
+ _unwrapNonDartException(ex) {
+ var message, number, ieErrorCode, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, match;
+ if (!("message" in ex))
+ return ex;
+ message = ex.message;
+ if ("number" in ex && typeof ex.number == "number") {
+ number = ex.number;
+ ieErrorCode = number & 65535;
+ if ((B.JSInt_methods._shrOtherPositive$1(number, 16) & 8191) === 10)
+ switch (ieErrorCode) {
+ case 438:
+ return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A.S(message) + " (Error " + ieErrorCode + ")", null));
+ case 445:
+ case 5007:
+ A.S(message);
+ return A.saveStackTrace(ex, new A.NullError());
+ }
+ }
+ if (ex instanceof TypeError) {
+ nsme = $.$get$TypeErrorDecoder_noSuchMethodPattern();
+ notClosure = $.$get$TypeErrorDecoder_notClosurePattern();
+ nullCall = $.$get$TypeErrorDecoder_nullCallPattern();
+ nullLiteralCall = $.$get$TypeErrorDecoder_nullLiteralCallPattern();
+ undefCall = $.$get$TypeErrorDecoder_undefinedCallPattern();
+ undefLiteralCall = $.$get$TypeErrorDecoder_undefinedLiteralCallPattern();
+ nullProperty = $.$get$TypeErrorDecoder_nullPropertyPattern();
+ $.$get$TypeErrorDecoder_nullLiteralPropertyPattern();
+ undefProperty = $.$get$TypeErrorDecoder_undefinedPropertyPattern();
+ undefLiteralProperty = $.$get$TypeErrorDecoder_undefinedLiteralPropertyPattern();
+ match = nsme.matchTypeError$1(message);
+ if (match != null)
+ return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
+ else {
+ match = notClosure.matchTypeError$1(message);
+ if (match != null) {
+ match.method = "call";
+ return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
+ } else if (nullCall.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefCall.matchTypeError$1(message) != null || undefLiteralCall.matchTypeError$1(message) != null || nullProperty.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefProperty.matchTypeError$1(message) != null || undefLiteralProperty.matchTypeError$1(message) != null) {
+ A._asString(message);
+ return A.saveStackTrace(ex, new A.NullError());
+ }
+ }
+ return A.saveStackTrace(ex, new A.UnknownJsTypeError(typeof message == "string" ? message : ""));
+ }
+ if (ex instanceof RangeError) {
+ if (typeof message == "string" && message.indexOf("call stack") !== -1)
+ return new A.StackOverflowError();
+ message = function(ex) {
+ try {
+ return String(ex);
+ } catch (e) {
+ }
+ return null;
+ }(ex);
+ return A.saveStackTrace(ex, new A.ArgumentError(false, null, null, typeof message == "string" ? message.replace(/^RangeError:\s*/, "") : message));
+ }
+ if (typeof InternalError == "function" && ex instanceof InternalError)
+ if (typeof message == "string" && message === "too much recursion")
+ return new A.StackOverflowError();
+ return ex;
+ },
+ getTraceFromException(exception) {
+ var trace;
+ if (exception instanceof A.ExceptionAndStackTrace)
+ return exception.stackTrace;
+ if (exception == null)
+ return new A._StackTrace(exception);
+ trace = exception.$cachedTrace;
+ if (trace != null)
+ return trace;
+ trace = new A._StackTrace(exception);
+ if (typeof exception === "object")
+ exception.$cachedTrace = trace;
+ return trace;
+ },
+ objectHashCode(object) {
+ if (object == null)
+ return J.get$hashCode$(object);
+ if (typeof object == "object")
+ return A.Primitives_objectHashCode(object);
+ return J.get$hashCode$(object);
+ },
+ _invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) {
+ type$.Function._as(closure);
+ switch (A._asInt(numberOfArguments)) {
+ case 0:
+ return closure.call$0();
+ case 1:
+ return closure.call$1(arg1);
+ case 2:
+ return closure.call$2(arg1, arg2);
+ case 3:
+ return closure.call$3(arg1, arg2, arg3);
+ case 4:
+ return closure.call$4(arg1, arg2, arg3, arg4);
+ }
+ throw A.wrapException(new A._Exception("Unsupported number of arguments for wrapped closure"));
+ },
+ convertDartClosureToJS(closure, arity) {
+ var $function = closure.$identity;
+ if (!!$function)
+ return $function;
+ $function = A.convertDartClosureToJSUncached(closure, arity);
+ closure.$identity = $function;
+ return $function;
+ },
+ convertDartClosureToJSUncached(closure, arity) {
+ var entry;
+ switch (arity) {
+ case 0:
+ entry = closure.call$0;
+ break;
+ case 1:
+ entry = closure.call$1;
+ break;
+ case 2:
+ entry = closure.call$2;
+ break;
+ case 3:
+ entry = closure.call$3;
+ break;
+ case 4:
+ entry = closure.call$4;
+ break;
+ default:
+ entry = null;
+ }
+ if (entry != null)
+ return entry.bind(closure);
+ return function(closure, arity, invoke) {
+ return function(a1, a2, a3, a4) {
+ return invoke(closure, arity, a1, a2, a3, a4);
+ };
+ }(closure, arity, A._invokeClosure);
+ },
+ Closure_fromTearOff(parameters) {
+ var $prototype, $constructor, t2, trampoline, applyTrampoline, i, stub, stub0, stubName, stubCallName,
+ container = parameters.co,
+ isStatic = parameters.iS,
+ isIntercepted = parameters.iI,
+ needsDirectAccess = parameters.nDA,
+ applyTrampolineIndex = parameters.aI,
+ funsOrNames = parameters.fs,
+ callNames = parameters.cs,
+ $name = funsOrNames[0],
+ callName = callNames[0],
+ $function = container[$name],
+ t1 = parameters.fT;
+ t1.toString;
+ $prototype = isStatic ? Object.create(new A.StaticClosure().constructor.prototype) : Object.create(new A.BoundClosure(null, null).constructor.prototype);
+ $prototype.$initialize = $prototype.constructor;
+ $constructor = isStatic ? function static_tear_off() {
+ this.$initialize();
+ } : function tear_off(a, b) {
+ this.$initialize(a, b);
+ };
+ $prototype.constructor = $constructor;
+ $constructor.prototype = $prototype;
+ $prototype.$_name = $name;
+ $prototype.$_target = $function;
+ t2 = !isStatic;
+ if (t2)
+ trampoline = A.Closure_forwardCallTo($name, $function, isIntercepted, needsDirectAccess);
+ else {
+ $prototype.$static_name = $name;
+ trampoline = $function;
+ }
+ $prototype.$signature = A.Closure__computeSignatureFunctionNewRti(t1, isStatic, isIntercepted);
+ $prototype[callName] = trampoline;
+ for (applyTrampoline = trampoline, i = 1; i < funsOrNames.length; ++i) {
+ stub = funsOrNames[i];
+ if (typeof stub == "string") {
+ stub0 = container[stub];
+ stubName = stub;
+ stub = stub0;
+ } else
+ stubName = "";
+ stubCallName = callNames[i];
+ if (stubCallName != null) {
+ if (t2)
+ stub = A.Closure_forwardCallTo(stubName, stub, isIntercepted, needsDirectAccess);
+ $prototype[stubCallName] = stub;
+ }
+ if (i === applyTrampolineIndex)
+ applyTrampoline = stub;
+ }
+ $prototype["call*"] = applyTrampoline;
+ $prototype.$requiredArgCount = parameters.rC;
+ $prototype.$defaultValues = parameters.dV;
+ return $constructor;
+ },
+ Closure__computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted) {
+ if (typeof functionType == "number")
+ return functionType;
+ if (typeof functionType == "string") {
+ if (isStatic)
+ throw A.wrapException("Cannot compute signature for static tearoff.");
+ return function(recipe, evalOnReceiver) {
+ return function() {
+ return evalOnReceiver(this, recipe);
+ };
+ }(functionType, A.BoundClosure_evalRecipe);
+ }
+ throw A.wrapException("Error in functionType of tearoff");
+ },
+ Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function) {
+ var getReceiver = A.BoundClosure_receiverOf;
+ switch (needsDirectAccess ? -1 : arity) {
+ case 0:
+ return function(entry, receiverOf) {
+ return function() {
+ return receiverOf(this)[entry]();
+ };
+ }(stubName, getReceiver);
+ case 1:
+ return function(entry, receiverOf) {
+ return function(a) {
+ return receiverOf(this)[entry](a);
+ };
+ }(stubName, getReceiver);
+ case 2:
+ return function(entry, receiverOf) {
+ return function(a, b) {
+ return receiverOf(this)[entry](a, b);
+ };
+ }(stubName, getReceiver);
+ case 3:
+ return function(entry, receiverOf) {
+ return function(a, b, c) {
+ return receiverOf(this)[entry](a, b, c);
+ };
+ }(stubName, getReceiver);
+ case 4:
+ return function(entry, receiverOf) {
+ return function(a, b, c, d) {
+ return receiverOf(this)[entry](a, b, c, d);
+ };
+ }(stubName, getReceiver);
+ case 5:
+ return function(entry, receiverOf) {
+ return function(a, b, c, d, e) {
+ return receiverOf(this)[entry](a, b, c, d, e);
+ };
+ }(stubName, getReceiver);
+ default:
+ return function(f, receiverOf) {
+ return function() {
+ return f.apply(receiverOf(this), arguments);
+ };
+ }($function, getReceiver);
+ }
+ },
+ Closure_forwardCallTo(stubName, $function, isIntercepted, needsDirectAccess) {
+ if (isIntercepted)
+ return A.Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess);
+ return A.Closure_cspForwardCall($function.length, needsDirectAccess, stubName, $function);
+ },
+ Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function) {
+ var getReceiver = A.BoundClosure_receiverOf,
+ getInterceptor = A.BoundClosure_interceptorOf;
+ switch (needsDirectAccess ? -1 : arity) {
+ case 0:
+ throw A.wrapException(new A.RuntimeError("Intercepted function with no arguments."));
+ case 1:
+ return function(entry, interceptorOf, receiverOf) {
+ return function() {
+ return interceptorOf(this)[entry](receiverOf(this));
+ };
+ }(stubName, getInterceptor, getReceiver);
+ case 2:
+ return function(entry, interceptorOf, receiverOf) {
+ return function(a) {
+ return interceptorOf(this)[entry](receiverOf(this), a);
+ };
+ }(stubName, getInterceptor, getReceiver);
+ case 3:
+ return function(entry, interceptorOf, receiverOf) {
+ return function(a, b) {
+ return interceptorOf(this)[entry](receiverOf(this), a, b);
+ };
+ }(stubName, getInterceptor, getReceiver);
+ case 4:
+ return function(entry, interceptorOf, receiverOf) {
+ return function(a, b, c) {
+ return interceptorOf(this)[entry](receiverOf(this), a, b, c);
+ };
+ }(stubName, getInterceptor, getReceiver);
+ case 5:
+ return function(entry, interceptorOf, receiverOf) {
+ return function(a, b, c, d) {
+ return interceptorOf(this)[entry](receiverOf(this), a, b, c, d);
+ };
+ }(stubName, getInterceptor, getReceiver);
+ case 6:
+ return function(entry, interceptorOf, receiverOf) {
+ return function(a, b, c, d, e) {
+ return interceptorOf(this)[entry](receiverOf(this), a, b, c, d, e);
+ };
+ }(stubName, getInterceptor, getReceiver);
+ default:
+ return function(f, interceptorOf, receiverOf) {
+ return function() {
+ var a = [receiverOf(this)];
+ Array.prototype.push.apply(a, arguments);
+ return f.apply(interceptorOf(this), a);
+ };
+ }($function, getInterceptor, getReceiver);
+ }
+ },
+ Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess) {
+ var arity, t1;
+ if ($.BoundClosure__interceptorFieldNameCache == null)
+ $.BoundClosure__interceptorFieldNameCache = A.BoundClosure__computeFieldNamed("interceptor");
+ if ($.BoundClosure__receiverFieldNameCache == null)
+ $.BoundClosure__receiverFieldNameCache = A.BoundClosure__computeFieldNamed("receiver");
+ arity = $function.length;
+ t1 = A.Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function);
+ return t1;
+ },
+ closureFromTearOff(parameters) {
+ return A.Closure_fromTearOff(parameters);
+ },
+ BoundClosure_evalRecipe(closure, recipe) {
+ return A._Universe_evalInEnvironment(init.typeUniverse, A.instanceType(closure._receiver), recipe);
+ },
+ BoundClosure_receiverOf(closure) {
+ return closure._receiver;
+ },
+ BoundClosure_interceptorOf(closure) {
+ return closure._interceptor;
+ },
+ BoundClosure__computeFieldNamed(fieldName) {
+ var t1, i, $name,
+ template = new A.BoundClosure("receiver", "interceptor"),
+ names = J.JSArray_markFixedList(Object.getOwnPropertyNames(template), type$.nullable_Object);
+ for (t1 = names.length, i = 0; i < t1; ++i) {
+ $name = names[i];
+ if (template[$name] === fieldName)
+ return $name;
+ }
+ throw A.wrapException(A.ArgumentError$("Field name " + fieldName + " not found.", null));
+ },
+ throwCyclicInit(staticName) {
+ throw A.wrapException(new A._CyclicInitializationError(staticName));
+ },
+ getIsolateAffinityTag($name) {
+ return init.getIsolateTag($name);
+ },
+ lookupAndCacheInterceptor(obj) {
+ var interceptor, interceptorClass, altTag, mark, t1,
+ tag = A._asString($.getTagFunction.call$1(obj)),
+ record = $.dispatchRecordsForInstanceTags[tag];
+ if (record != null) {
+ Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true});
+ return record.i;
+ }
+ interceptor = $.interceptorsForUncacheableTags[tag];
+ if (interceptor != null)
+ return interceptor;
+ interceptorClass = init.interceptorsByTag[tag];
+ if (interceptorClass == null) {
+ altTag = A._asStringQ($.alternateTagFunction.call$2(obj, tag));
+ if (altTag != null) {
+ record = $.dispatchRecordsForInstanceTags[altTag];
+ if (record != null) {
+ Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true});
+ return record.i;
+ }
+ interceptor = $.interceptorsForUncacheableTags[altTag];
+ if (interceptor != null)
+ return interceptor;
+ interceptorClass = init.interceptorsByTag[altTag];
+ tag = altTag;
+ }
+ }
+ if (interceptorClass == null)
+ return null;
+ interceptor = interceptorClass.prototype;
+ mark = tag[0];
+ if (mark === "!") {
+ record = A.makeLeafDispatchRecord(interceptor);
+ $.dispatchRecordsForInstanceTags[tag] = record;
+ Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true});
+ return record.i;
+ }
+ if (mark === "~") {
+ $.interceptorsForUncacheableTags[tag] = interceptor;
+ return interceptor;
+ }
+ if (mark === "-") {
+ t1 = A.makeLeafDispatchRecord(interceptor);
+ Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true});
+ return t1.i;
+ }
+ if (mark === "+")
+ return A.patchInteriorProto(obj, interceptor);
+ if (mark === "*")
+ throw A.wrapException(A.UnimplementedError$(tag));
+ if (init.leafTags[tag] === true) {
+ t1 = A.makeLeafDispatchRecord(interceptor);
+ Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true});
+ return t1.i;
+ } else
+ return A.patchInteriorProto(obj, interceptor);
+ },
+ patchInteriorProto(obj, interceptor) {
+ var proto = Object.getPrototypeOf(obj);
+ Object.defineProperty(proto, init.dispatchPropertyName, {value: J.makeDispatchRecord(interceptor, proto, null, null), enumerable: false, writable: true, configurable: true});
+ return interceptor;
+ },
+ makeLeafDispatchRecord(interceptor) {
+ return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior);
+ },
+ makeDefaultDispatchRecord(tag, interceptorClass, proto) {
+ var interceptor = interceptorClass.prototype;
+ if (init.leafTags[tag] === true)
+ return A.makeLeafDispatchRecord(interceptor);
+ else
+ return J.makeDispatchRecord(interceptor, proto, null, null);
+ },
+ initNativeDispatch() {
+ if (true === $.initNativeDispatchFlag)
+ return;
+ $.initNativeDispatchFlag = true;
+ A.initNativeDispatchContinue();
+ },
+ initNativeDispatchContinue() {
+ var map, tags, fun, i, tag, proto, record, interceptorClass;
+ $.dispatchRecordsForInstanceTags = Object.create(null);
+ $.interceptorsForUncacheableTags = Object.create(null);
+ A.initHooks();
+ map = init.interceptorsByTag;
+ tags = Object.getOwnPropertyNames(map);
+ if (typeof window != "undefined") {
+ window;
+ fun = function() {
+ };
+ for (i = 0; i < tags.length; ++i) {
+ tag = tags[i];
+ proto = $.prototypeForTagFunction.call$1(tag);
+ if (proto != null) {
+ record = A.makeDefaultDispatchRecord(tag, map[tag], proto);
+ if (record != null) {
+ Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true});
+ fun.prototype = proto;
+ }
+ }
+ }
+ }
+ for (i = 0; i < tags.length; ++i) {
+ tag = tags[i];
+ if (/^[A-Za-z_]/.test(tag)) {
+ interceptorClass = map[tag];
+ map["!" + tag] = interceptorClass;
+ map["~" + tag] = interceptorClass;
+ map["-" + tag] = interceptorClass;
+ map["+" + tag] = interceptorClass;
+ map["*" + tag] = interceptorClass;
+ }
+ }
+ },
+ initHooks() {
+ var transformers, i, transformer, getTag, getUnknownTag, prototypeForTag,
+ hooks = B.C_JS_CONST0();
+ hooks = A.applyHooksTransformer(B.C_JS_CONST1, A.applyHooksTransformer(B.C_JS_CONST2, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST4, A.applyHooksTransformer(B.C_JS_CONST5, A.applyHooksTransformer(B.C_JS_CONST6(B.C_JS_CONST), hooks)))))));
+ if (typeof dartNativeDispatchHooksTransformer != "undefined") {
+ transformers = dartNativeDispatchHooksTransformer;
+ if (typeof transformers == "function")
+ transformers = [transformers];
+ if (Array.isArray(transformers))
+ for (i = 0; i < transformers.length; ++i) {
+ transformer = transformers[i];
+ if (typeof transformer == "function")
+ hooks = transformer(hooks) || hooks;
+ }
+ }
+ getTag = hooks.getTag;
+ getUnknownTag = hooks.getUnknownTag;
+ prototypeForTag = hooks.prototypeForTag;
+ $.getTagFunction = new A.initHooks_closure(getTag);
+ $.alternateTagFunction = new A.initHooks_closure0(getUnknownTag);
+ $.prototypeForTagFunction = new A.initHooks_closure1(prototypeForTag);
+ },
+ applyHooksTransformer(transformer, hooks) {
+ return transformer(hooks) || hooks;
+ },
+ createRecordTypePredicate(shape, fieldRtis) {
+ var $length = fieldRtis.length,
+ $function = init.rttc["" + $length + ";" + shape];
+ if ($function == null)
+ return null;
+ if ($length === 0)
+ return $function;
+ if ($length === $function.length)
+ return $function.apply(null, fieldRtis);
+ return $function(fieldRtis);
+ },
+ quoteStringForRegExp(string) {
+ if (/[[\]{}()*+?.\\^$|]/.test(string))
+ return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
+ return string;
+ },
+ ConstantMapView: function ConstantMapView(t0, t1) {
+ this._collection$_map = t0;
+ this.$ti = t1;
+ },
+ ConstantMap: function ConstantMap() {
+ },
+ ConstantStringMap: function ConstantStringMap(t0, t1, t2) {
+ this._jsIndex = t0;
+ this._values = t1;
+ this.$ti = t2;
+ },
+ JSInvocationMirror: function JSInvocationMirror(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._memberName = t0;
+ _.__js_helper$_kind = t1;
+ _._arguments = t2;
+ _._namedArgumentNames = t3;
+ _._typeArgumentCount = t4;
+ },
+ Primitives_functionNoSuchMethod_closure: function Primitives_functionNoSuchMethod_closure(t0, t1, t2) {
+ this._box_0 = t0;
+ this.namedArgumentList = t1;
+ this.$arguments = t2;
+ },
+ TypeErrorDecoder: function TypeErrorDecoder(t0, t1, t2, t3, t4, t5) {
+ var _ = this;
+ _._pattern = t0;
+ _._arguments = t1;
+ _._argumentsExpr = t2;
+ _._expr = t3;
+ _._method = t4;
+ _._receiver = t5;
+ },
+ NullError: function NullError() {
+ },
+ JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) {
+ this.__js_helper$_message = t0;
+ this._method = t1;
+ this._receiver = t2;
+ },
+ UnknownJsTypeError: function UnknownJsTypeError(t0) {
+ this.__js_helper$_message = t0;
+ },
+ NullThrownFromJavaScriptException: function NullThrownFromJavaScriptException(t0) {
+ this._irritant = t0;
+ },
+ ExceptionAndStackTrace: function ExceptionAndStackTrace(t0, t1) {
+ this.dartException = t0;
+ this.stackTrace = t1;
+ },
+ _StackTrace: function _StackTrace(t0) {
+ this._exception = t0;
+ this._trace = null;
+ },
+ Closure: function Closure() {
+ },
+ Closure0Args: function Closure0Args() {
+ },
+ Closure2Args: function Closure2Args() {
+ },
+ TearOffClosure: function TearOffClosure() {
+ },
+ StaticClosure: function StaticClosure() {
+ },
+ BoundClosure: function BoundClosure(t0, t1) {
+ this._receiver = t0;
+ this._interceptor = t1;
+ },
+ _CyclicInitializationError: function _CyclicInitializationError(t0) {
+ this.variableName = t0;
+ },
+ RuntimeError: function RuntimeError(t0) {
+ this.message = t0;
+ },
+ _Required: function _Required() {
+ },
+ JsLinkedHashMap: function JsLinkedHashMap(t0) {
+ var _ = this;
+ _.__js_helper$_length = 0;
+ _._last = _._first = _.__js_helper$_rest = _._nums = _._strings = null;
+ _._modifications = 0;
+ _.$ti = t0;
+ },
+ LinkedHashMapCell: function LinkedHashMapCell(t0, t1) {
+ this.hashMapCellKey = t0;
+ this.hashMapCellValue = t1;
+ this._next = null;
+ },
+ LinkedHashMapKeyIterable: function LinkedHashMapKeyIterable(t0, t1) {
+ this._map = t0;
+ this.$ti = t1;
+ },
+ LinkedHashMapKeyIterator: function LinkedHashMapKeyIterator(t0, t1, t2) {
+ var _ = this;
+ _._map = t0;
+ _._modifications = t1;
+ _.__js_helper$_current = _._cell = null;
+ _.$ti = t2;
+ },
+ initHooks_closure: function initHooks_closure(t0) {
+ this.getTag = t0;
+ },
+ initHooks_closure0: function initHooks_closure0(t0) {
+ this.getUnknownTag = t0;
+ },
+ initHooks_closure1: function initHooks_closure1(t0) {
+ this.prototypeForTag = t0;
+ },
+ StringMatch: function StringMatch(t0, t1) {
+ this.start = t0;
+ this.pattern = t1;
+ },
+ _checkValidIndex(index, list, $length) {
+ if (index >>> 0 !== index || index >= $length)
+ throw A.wrapException(A.diagnoseIndexError(list, index));
+ },
+ NativeByteBuffer: function NativeByteBuffer() {
+ },
+ NativeTypedData: function NativeTypedData() {
+ },
+ NativeByteData: function NativeByteData() {
+ },
+ NativeTypedArray: function NativeTypedArray() {
+ },
+ NativeTypedArrayOfDouble: function NativeTypedArrayOfDouble() {
+ },
+ NativeTypedArrayOfInt: function NativeTypedArrayOfInt() {
+ },
+ NativeFloat32List: function NativeFloat32List() {
+ },
+ NativeFloat64List: function NativeFloat64List() {
+ },
+ NativeInt16List: function NativeInt16List() {
+ },
+ NativeInt32List: function NativeInt32List() {
+ },
+ NativeInt8List: function NativeInt8List() {
+ },
+ NativeUint16List: function NativeUint16List() {
+ },
+ NativeUint32List: function NativeUint32List() {
+ },
+ NativeUint8ClampedList: function NativeUint8ClampedList() {
+ },
+ NativeUint8List: function NativeUint8List() {
+ },
+ _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin() {
+ },
+ _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin() {
+ },
+ _NativeTypedArrayOfInt_NativeTypedArray_ListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin() {
+ },
+ _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin() {
+ },
+ Rti__getQuestionFromStar(universe, rti) {
+ var question = rti._precomputed1;
+ return question == null ? rti._precomputed1 = A._Universe__lookupQuestionRti(universe, rti._primary, true) : question;
+ },
+ Rti__getFutureFromFutureOr(universe, rti) {
+ var future = rti._precomputed1;
+ return future == null ? rti._precomputed1 = A._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future;
+ },
+ Rti__isUnionOfFunctionType(rti) {
+ var kind = rti._kind;
+ if (kind === 6 || kind === 7 || kind === 8)
+ return A.Rti__isUnionOfFunctionType(rti._primary);
+ return kind === 12 || kind === 13;
+ },
+ Rti__getCanonicalRecipe(rti) {
+ return rti._canonicalRecipe;
+ },
+ findType(recipe) {
+ return A._Universe_eval(init.typeUniverse, recipe, false);
+ },
+ _substitute(universe, rti, typeArguments, depth) {
+ var baseType, substitutedBaseType, interfaceTypeArguments, substitutedInterfaceTypeArguments, base, substitutedBase, $arguments, substitutedArguments, t1, fields, substitutedFields, returnType, substitutedReturnType, functionParameters, substitutedFunctionParameters, bounds, substitutedBounds, index, argument,
+ kind = rti._kind;
+ switch (kind) {
+ case 5:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ return rti;
+ case 6:
+ baseType = rti._primary;
+ substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
+ if (substitutedBaseType === baseType)
+ return rti;
+ return A._Universe__lookupStarRti(universe, substitutedBaseType, true);
+ case 7:
+ baseType = rti._primary;
+ substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
+ if (substitutedBaseType === baseType)
+ return rti;
+ return A._Universe__lookupQuestionRti(universe, substitutedBaseType, true);
+ case 8:
+ baseType = rti._primary;
+ substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
+ if (substitutedBaseType === baseType)
+ return rti;
+ return A._Universe__lookupFutureOrRti(universe, substitutedBaseType, true);
+ case 9:
+ interfaceTypeArguments = rti._rest;
+ substitutedInterfaceTypeArguments = A._substituteArray(universe, interfaceTypeArguments, typeArguments, depth);
+ if (substitutedInterfaceTypeArguments === interfaceTypeArguments)
+ return rti;
+ return A._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments);
+ case 10:
+ base = rti._primary;
+ substitutedBase = A._substitute(universe, base, typeArguments, depth);
+ $arguments = rti._rest;
+ substitutedArguments = A._substituteArray(universe, $arguments, typeArguments, depth);
+ if (substitutedBase === base && substitutedArguments === $arguments)
+ return rti;
+ return A._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments);
+ case 11:
+ t1 = rti._primary;
+ fields = rti._rest;
+ substitutedFields = A._substituteArray(universe, fields, typeArguments, depth);
+ if (substitutedFields === fields)
+ return rti;
+ return A._Universe__lookupRecordRti(universe, t1, substitutedFields);
+ case 12:
+ returnType = rti._primary;
+ substitutedReturnType = A._substitute(universe, returnType, typeArguments, depth);
+ functionParameters = rti._rest;
+ substitutedFunctionParameters = A._substituteFunctionParameters(universe, functionParameters, typeArguments, depth);
+ if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters)
+ return rti;
+ return A._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters);
+ case 13:
+ bounds = rti._rest;
+ depth += bounds.length;
+ substitutedBounds = A._substituteArray(universe, bounds, typeArguments, depth);
+ base = rti._primary;
+ substitutedBase = A._substitute(universe, base, typeArguments, depth);
+ if (substitutedBounds === bounds && substitutedBase === base)
+ return rti;
+ return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true);
+ case 14:
+ index = rti._primary;
+ if (index < depth)
+ return rti;
+ argument = typeArguments[index - depth];
+ if (argument == null)
+ return rti;
+ return argument;
+ default:
+ throw A.wrapException(A.AssertionError$("Attempted to substitute unexpected RTI kind " + kind));
+ }
+ },
+ _substituteArray(universe, rtiArray, typeArguments, depth) {
+ var changed, i, rti, substitutedRti,
+ $length = rtiArray.length,
+ result = A._Utils_newArrayOrEmpty($length);
+ for (changed = false, i = 0; i < $length; ++i) {
+ rti = rtiArray[i];
+ substitutedRti = A._substitute(universe, rti, typeArguments, depth);
+ if (substitutedRti !== rti)
+ changed = true;
+ result[i] = substitutedRti;
+ }
+ return changed ? result : rtiArray;
+ },
+ _substituteNamed(universe, namedArray, typeArguments, depth) {
+ var changed, i, t1, t2, rti, substitutedRti,
+ $length = namedArray.length,
+ result = A._Utils_newArrayOrEmpty($length);
+ for (changed = false, i = 0; i < $length; i += 3) {
+ t1 = namedArray[i];
+ t2 = namedArray[i + 1];
+ rti = namedArray[i + 2];
+ substitutedRti = A._substitute(universe, rti, typeArguments, depth);
+ if (substitutedRti !== rti)
+ changed = true;
+ result.splice(i, 3, t1, t2, substitutedRti);
+ }
+ return changed ? result : namedArray;
+ },
+ _substituteFunctionParameters(universe, functionParameters, typeArguments, depth) {
+ var result,
+ requiredPositional = functionParameters._requiredPositional,
+ substitutedRequiredPositional = A._substituteArray(universe, requiredPositional, typeArguments, depth),
+ optionalPositional = functionParameters._optionalPositional,
+ substitutedOptionalPositional = A._substituteArray(universe, optionalPositional, typeArguments, depth),
+ named = functionParameters._named,
+ substitutedNamed = A._substituteNamed(universe, named, typeArguments, depth);
+ if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named)
+ return functionParameters;
+ result = new A._FunctionParameters();
+ result._requiredPositional = substitutedRequiredPositional;
+ result._optionalPositional = substitutedOptionalPositional;
+ result._named = substitutedNamed;
+ return result;
+ },
+ _setArrayType(target, rti) {
+ target[init.arrayRti] = rti;
+ return target;
+ },
+ closureFunctionType(closure) {
+ var signature = closure.$signature;
+ if (signature != null) {
+ if (typeof signature == "number")
+ return A.getTypeFromTypesTable(signature);
+ return closure.$signature();
+ }
+ return null;
+ },
+ instanceOrFunctionType(object, testRti) {
+ var rti;
+ if (A.Rti__isUnionOfFunctionType(testRti))
+ if (object instanceof A.Closure) {
+ rti = A.closureFunctionType(object);
+ if (rti != null)
+ return rti;
+ }
+ return A.instanceType(object);
+ },
+ instanceType(object) {
+ if (object instanceof A.Object)
+ return A._instanceType(object);
+ if (Array.isArray(object))
+ return A._arrayInstanceType(object);
+ return A._instanceTypeFromConstructor(J.getInterceptor$(object));
+ },
+ _arrayInstanceType(object) {
+ var rti = object[init.arrayRti],
+ defaultRti = type$.JSArray_dynamic;
+ if (rti == null)
+ return defaultRti;
+ if (rti.constructor !== defaultRti.constructor)
+ return defaultRti;
+ return rti;
+ },
+ _instanceType(object) {
+ var rti = object.$ti;
+ return rti != null ? rti : A._instanceTypeFromConstructor(object);
+ },
+ _instanceTypeFromConstructor(instance) {
+ var $constructor = instance.constructor,
+ probe = $constructor.$ccache;
+ if (probe != null)
+ return probe;
+ return A._instanceTypeFromConstructorMiss(instance, $constructor);
+ },
+ _instanceTypeFromConstructorMiss(instance, $constructor) {
+ var effectiveConstructor = instance instanceof A.Closure ? Object.getPrototypeOf(Object.getPrototypeOf(instance)).constructor : $constructor,
+ rti = A._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name);
+ $constructor.$ccache = rti;
+ return rti;
+ },
+ getTypeFromTypesTable(index) {
+ var rti,
+ table = init.types,
+ type = table[index];
+ if (typeof type == "string") {
+ rti = A._Universe_eval(init.typeUniverse, type, false);
+ table[index] = rti;
+ return rti;
+ }
+ return type;
+ },
+ getRuntimeTypeOfDartObject(object) {
+ return A.createRuntimeType(A._instanceType(object));
+ },
+ _structuralTypeOf(object) {
+ var functionRti = object instanceof A.Closure ? A.closureFunctionType(object) : null;
+ if (functionRti != null)
+ return functionRti;
+ if (type$.TrustedGetRuntimeType._is(object))
+ return J.get$runtimeType$(object)._rti;
+ if (Array.isArray(object))
+ return A._arrayInstanceType(object);
+ return A.instanceType(object);
+ },
+ createRuntimeType(rti) {
+ var t1 = rti._cachedRuntimeType;
+ return t1 == null ? rti._cachedRuntimeType = A._createRuntimeType(rti) : t1;
+ },
+ _createRuntimeType(rti) {
+ var starErasedRti, t1,
+ s = rti._canonicalRecipe,
+ starErasedRecipe = s.replace(/\*/g, "");
+ if (starErasedRecipe === s)
+ return rti._cachedRuntimeType = new A._Type(rti);
+ starErasedRti = A._Universe_eval(init.typeUniverse, starErasedRecipe, true);
+ t1 = starErasedRti._cachedRuntimeType;
+ return t1 == null ? starErasedRti._cachedRuntimeType = A._createRuntimeType(starErasedRti) : t1;
+ },
+ typeLiteral(recipe) {
+ return A.createRuntimeType(A._Universe_eval(init.typeUniverse, recipe, false));
+ },
+ _installSpecializedIsTest(object) {
+ var t1, unstarred, unstarredKind, isFn, $name, predicate, testRti = this;
+ if (testRti === type$.Object)
+ return A._finishIsFn(testRti, object, A._isObject);
+ if (!A.isSoundTopType(testRti))
+ t1 = testRti === type$.legacy_Object;
+ else
+ t1 = true;
+ if (t1)
+ return A._finishIsFn(testRti, object, A._isTop);
+ t1 = testRti._kind;
+ if (t1 === 7)
+ return A._finishIsFn(testRti, object, A._generalNullableIsTestImplementation);
+ if (t1 === 1)
+ return A._finishIsFn(testRti, object, A._isNever);
+ unstarred = t1 === 6 ? testRti._primary : testRti;
+ unstarredKind = unstarred._kind;
+ if (unstarredKind === 8)
+ return A._finishIsFn(testRti, object, A._isFutureOr);
+ if (unstarred === type$.int)
+ isFn = A._isInt;
+ else if (unstarred === type$.double || unstarred === type$.num)
+ isFn = A._isNum;
+ else if (unstarred === type$.String)
+ isFn = A._isString;
+ else
+ isFn = unstarred === type$.bool ? A._isBool : null;
+ if (isFn != null)
+ return A._finishIsFn(testRti, object, isFn);
+ if (unstarredKind === 9) {
+ $name = unstarred._primary;
+ if (unstarred._rest.every(A.isDefinitelyTopType)) {
+ testRti._specializedTestResource = "$is" + $name;
+ if ($name === "List")
+ return A._finishIsFn(testRti, object, A._isListTestViaProperty);
+ return A._finishIsFn(testRti, object, A._isTestViaProperty);
+ }
+ } else if (unstarredKind === 11) {
+ predicate = A.createRecordTypePredicate(unstarred._primary, unstarred._rest);
+ return A._finishIsFn(testRti, object, predicate == null ? A._isNever : predicate);
+ }
+ return A._finishIsFn(testRti, object, A._generalIsTestImplementation);
+ },
+ _finishIsFn(testRti, object, isFn) {
+ testRti._is = isFn;
+ return testRti._is(object);
+ },
+ _installSpecializedAsCheck(object) {
+ var t1, testRti = this,
+ asFn = A._generalAsCheckImplementation;
+ if (!A.isSoundTopType(testRti))
+ t1 = testRti === type$.legacy_Object;
+ else
+ t1 = true;
+ if (t1)
+ asFn = A._asTop;
+ else if (testRti === type$.Object)
+ asFn = A._asObject;
+ else {
+ t1 = A.isNullable(testRti);
+ if (t1)
+ asFn = A._generalNullableAsCheckImplementation;
+ }
+ testRti._as = asFn;
+ return testRti._as(object);
+ },
+ _nullIs(testRti) {
+ var t1,
+ kind = testRti._kind;
+ if (!A.isSoundTopType(testRti))
+ if (!(testRti === type$.legacy_Object))
+ if (!(testRti === type$.legacy_Never))
+ if (kind !== 7)
+ if (!(kind === 6 && A._nullIs(testRti._primary)))
+ t1 = kind === 8 && A._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ return t1;
+ },
+ _generalIsTestImplementation(object) {
+ var testRti = this;
+ if (object == null)
+ return A._nullIs(testRti);
+ return A.isSubtype(init.typeUniverse, A.instanceOrFunctionType(object, testRti), testRti);
+ },
+ _generalNullableIsTestImplementation(object) {
+ if (object == null)
+ return true;
+ return this._primary._is(object);
+ },
+ _isTestViaProperty(object) {
+ var tag, testRti = this;
+ if (object == null)
+ return A._nullIs(testRti);
+ tag = testRti._specializedTestResource;
+ if (object instanceof A.Object)
+ return !!object[tag];
+ return !!J.getInterceptor$(object)[tag];
+ },
+ _isListTestViaProperty(object) {
+ var tag, testRti = this;
+ if (object == null)
+ return A._nullIs(testRti);
+ if (typeof object != "object")
+ return false;
+ if (Array.isArray(object))
+ return true;
+ tag = testRti._specializedTestResource;
+ if (object instanceof A.Object)
+ return !!object[tag];
+ return !!J.getInterceptor$(object)[tag];
+ },
+ _generalAsCheckImplementation(object) {
+ var testRti = this;
+ if (object == null) {
+ if (A.isNullable(testRti))
+ return object;
+ } else if (testRti._is(object))
+ return object;
+ A._failedAsCheck(object, testRti);
+ },
+ _generalNullableAsCheckImplementation(object) {
+ var testRti = this;
+ if (object == null)
+ return object;
+ else if (testRti._is(object))
+ return object;
+ A._failedAsCheck(object, testRti);
+ },
+ _failedAsCheck(object, testRti) {
+ throw A.wrapException(A._TypeError$fromMessage(A._Error_compose(object, A._rtiToString(testRti, null))));
+ },
+ _Error_compose(object, checkedTypeDescription) {
+ return A.Error_safeToString(object) + ": type '" + A._rtiToString(A._structuralTypeOf(object), null) + "' is not a subtype of type '" + checkedTypeDescription + "'";
+ },
+ _TypeError$fromMessage(message) {
+ return new A._TypeError("TypeError: " + message);
+ },
+ _TypeError__TypeError$forType(object, type) {
+ return new A._TypeError("TypeError: " + A._Error_compose(object, type));
+ },
+ _isFutureOr(object) {
+ var testRti = this,
+ unstarred = testRti._kind === 6 ? testRti._primary : testRti;
+ return unstarred._primary._is(object) || A.Rti__getFutureFromFutureOr(init.typeUniverse, unstarred)._is(object);
+ },
+ _isObject(object) {
+ return object != null;
+ },
+ _asObject(object) {
+ if (object != null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "Object"));
+ },
+ _isTop(object) {
+ return true;
+ },
+ _asTop(object) {
+ return object;
+ },
+ _isNever(object) {
+ return false;
+ },
+ _isBool(object) {
+ return true === object || false === object;
+ },
+ _asBool(object) {
+ if (true === object)
+ return true;
+ if (false === object)
+ return false;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
+ },
+ _asBoolS(object) {
+ if (true === object)
+ return true;
+ if (false === object)
+ return false;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
+ },
+ _asBoolQ(object) {
+ if (true === object)
+ return true;
+ if (false === object)
+ return false;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "bool?"));
+ },
+ _asDouble(object) {
+ if (typeof object == "number")
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
+ },
+ _asDoubleS(object) {
+ if (typeof object == "number")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
+ },
+ _asDoubleQ(object) {
+ if (typeof object == "number")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "double?"));
+ },
+ _isInt(object) {
+ return typeof object == "number" && Math.floor(object) === object;
+ },
+ _asInt(object) {
+ if (typeof object == "number" && Math.floor(object) === object)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
+ },
+ _asIntS(object) {
+ if (typeof object == "number" && Math.floor(object) === object)
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
+ },
+ _asIntQ(object) {
+ if (typeof object == "number" && Math.floor(object) === object)
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "int?"));
+ },
+ _isNum(object) {
+ return typeof object == "number";
+ },
+ _asNum(object) {
+ if (typeof object == "number")
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
+ },
+ _asNumS(object) {
+ if (typeof object == "number")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
+ },
+ _asNumQ(object) {
+ if (typeof object == "number")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "num?"));
+ },
+ _isString(object) {
+ return typeof object == "string";
+ },
+ _asString(object) {
+ if (typeof object == "string")
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
+ },
+ _asStringS(object) {
+ if (typeof object == "string")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
+ },
+ _asStringQ(object) {
+ if (typeof object == "string")
+ return object;
+ if (object == null)
+ return object;
+ throw A.wrapException(A._TypeError__TypeError$forType(object, "String?"));
+ },
+ _rtiArrayToString(array, genericContext) {
+ var s, sep, i;
+ for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ")
+ s += sep + A._rtiToString(array[i], genericContext);
+ return s;
+ },
+ _recordRtiToString(recordType, genericContext) {
+ var fieldCount, names, namesIndex, s, comma, i,
+ partialShape = recordType._primary,
+ fields = recordType._rest;
+ if ("" === partialShape)
+ return "(" + A._rtiArrayToString(fields, genericContext) + ")";
+ fieldCount = fields.length;
+ names = partialShape.split(",");
+ namesIndex = names.length - fieldCount;
+ for (s = "(", comma = "", i = 0; i < fieldCount; ++i, comma = ", ") {
+ s += comma;
+ if (namesIndex === 0)
+ s += "{";
+ s += A._rtiToString(fields[i], genericContext);
+ if (namesIndex >= 0)
+ s += " " + names[namesIndex];
+ ++namesIndex;
+ }
+ return s + "})";
+ },
+ _functionRtiToString(functionType, genericContext, bounds) {
+ var boundsLength, outerContextLength, offset, i, t1, t2, typeParametersText, typeSep, t3, t4, boundRti, kind, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ";
+ if (bounds != null) {
+ boundsLength = bounds.length;
+ if (genericContext == null) {
+ genericContext = A._setArrayType([], type$.JSArray_String);
+ outerContextLength = null;
+ } else
+ outerContextLength = genericContext.length;
+ offset = genericContext.length;
+ for (i = boundsLength; i > 0; --i)
+ B.JSArray_methods.add$1(genericContext, "T" + (offset + i));
+ for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) {
+ t3 = genericContext.length;
+ t4 = t3 - 1 - i;
+ if (!(t4 >= 0))
+ return A.ioore(genericContext, t4);
+ typeParametersText = B.JSString_methods.$add(typeParametersText + typeSep, genericContext[t4]);
+ boundRti = bounds[i];
+ kind = boundRti._kind;
+ if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1))
+ t3 = boundRti === t2;
+ else
+ t3 = true;
+ if (!t3)
+ typeParametersText += " extends " + A._rtiToString(boundRti, genericContext);
+ }
+ typeParametersText += ">";
+ } else {
+ typeParametersText = "";
+ outerContextLength = null;
+ }
+ t1 = functionType._primary;
+ parameters = functionType._rest;
+ requiredPositional = parameters._requiredPositional;
+ requiredPositionalLength = requiredPositional.length;
+ optionalPositional = parameters._optionalPositional;
+ optionalPositionalLength = optionalPositional.length;
+ named = parameters._named;
+ namedLength = named.length;
+ returnTypeText = A._rtiToString(t1, genericContext);
+ for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_)
+ argumentsText += sep + A._rtiToString(requiredPositional[i], genericContext);
+ if (optionalPositionalLength > 0) {
+ argumentsText += sep + "[";
+ for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_)
+ argumentsText += sep + A._rtiToString(optionalPositional[i], genericContext);
+ argumentsText += "]";
+ }
+ if (namedLength > 0) {
+ argumentsText += sep + "{";
+ for (sep = "", i = 0; i < namedLength; i += 3, sep = _s2_) {
+ argumentsText += sep;
+ if (named[i + 1])
+ argumentsText += "required ";
+ argumentsText += A._rtiToString(named[i + 2], genericContext) + " " + named[i];
+ }
+ argumentsText += "}";
+ }
+ if (outerContextLength != null) {
+ genericContext.toString;
+ genericContext.length = outerContextLength;
+ }
+ return typeParametersText + "(" + argumentsText + ") => " + returnTypeText;
+ },
+ _rtiToString(rti, genericContext) {
+ var questionArgument, s, argumentKind, $name, $arguments, t1, t2,
+ kind = rti._kind;
+ if (kind === 5)
+ return "erased";
+ if (kind === 2)
+ return "dynamic";
+ if (kind === 3)
+ return "void";
+ if (kind === 1)
+ return "Never";
+ if (kind === 4)
+ return "any";
+ if (kind === 6)
+ return A._rtiToString(rti._primary, genericContext);
+ if (kind === 7) {
+ questionArgument = rti._primary;
+ s = A._rtiToString(questionArgument, genericContext);
+ argumentKind = questionArgument._kind;
+ return (argumentKind === 12 || argumentKind === 13 ? "(" + s + ")" : s) + "?";
+ }
+ if (kind === 8)
+ return "FutureOr<" + A._rtiToString(rti._primary, genericContext) + ">";
+ if (kind === 9) {
+ $name = A._unminifyOrTag(rti._primary);
+ $arguments = rti._rest;
+ return $arguments.length > 0 ? $name + ("<" + A._rtiArrayToString($arguments, genericContext) + ">") : $name;
+ }
+ if (kind === 11)
+ return A._recordRtiToString(rti, genericContext);
+ if (kind === 12)
+ return A._functionRtiToString(rti, genericContext, null);
+ if (kind === 13)
+ return A._functionRtiToString(rti._primary, genericContext, rti._rest);
+ if (kind === 14) {
+ t1 = rti._primary;
+ t2 = genericContext.length;
+ t1 = t2 - 1 - t1;
+ if (!(t1 >= 0 && t1 < t2))
+ return A.ioore(genericContext, t1);
+ return genericContext[t1];
+ }
+ return "?";
+ },
+ _unminifyOrTag(rawClassName) {
+ var preserved = init.mangledGlobalNames[rawClassName];
+ if (preserved != null)
+ return preserved;
+ return rawClassName;
+ },
+ _Universe_findRule(universe, targetType) {
+ var rule = universe.tR[targetType];
+ for (; typeof rule == "string";)
+ rule = universe.tR[rule];
+ return rule;
+ },
+ _Universe_findErasedType(universe, cls) {
+ var $length, erased, $arguments, i, $interface,
+ t1 = universe.eT,
+ probe = t1[cls];
+ if (probe == null)
+ return A._Universe_eval(universe, cls, false);
+ else if (typeof probe == "number") {
+ $length = probe;
+ erased = A._Universe__lookupTerminalRti(universe, 5, "#");
+ $arguments = A._Utils_newArrayOrEmpty($length);
+ for (i = 0; i < $length; ++i)
+ $arguments[i] = erased;
+ $interface = A._Universe__lookupInterfaceRti(universe, cls, $arguments);
+ t1[cls] = $interface;
+ return $interface;
+ } else
+ return probe;
+ },
+ _Universe_addRules(universe, rules) {
+ return A._Utils_objectAssign(universe.tR, rules);
+ },
+ _Universe_addErasedTypes(universe, types) {
+ return A._Utils_objectAssign(universe.eT, types);
+ },
+ _Universe_eval(universe, recipe, normalize) {
+ var rti,
+ t1 = universe.eC,
+ probe = t1.get(recipe);
+ if (probe != null)
+ return probe;
+ rti = A._Parser_parse(A._Parser_create(universe, null, recipe, normalize));
+ t1.set(recipe, rti);
+ return rti;
+ },
+ _Universe_evalInEnvironment(universe, environment, recipe) {
+ var probe, rti,
+ cache = environment._evalCache;
+ if (cache == null)
+ cache = environment._evalCache = new Map();
+ probe = cache.get(recipe);
+ if (probe != null)
+ return probe;
+ rti = A._Parser_parse(A._Parser_create(universe, environment, recipe, true));
+ cache.set(recipe, rti);
+ return rti;
+ },
+ _Universe_bind(universe, environment, argumentsRti) {
+ var argumentsRecipe, probe, rti,
+ cache = environment._bindCache;
+ if (cache == null)
+ cache = environment._bindCache = new Map();
+ argumentsRecipe = argumentsRti._canonicalRecipe;
+ probe = cache.get(argumentsRecipe);
+ if (probe != null)
+ return probe;
+ rti = A._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]);
+ cache.set(argumentsRecipe, rti);
+ return rti;
+ },
+ _Universe__installTypeTests(universe, rti) {
+ rti._as = A._installSpecializedAsCheck;
+ rti._is = A._installSpecializedIsTest;
+ return rti;
+ },
+ _Universe__lookupTerminalRti(universe, kind, key) {
+ var rti, t1,
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = kind;
+ rti._canonicalRecipe = key;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__lookupStarRti(universe, baseType, normalize) {
+ var t1,
+ key = baseType._canonicalRecipe + "*",
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ t1 = A._Universe__createStarRti(universe, baseType, key, normalize);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__createStarRti(universe, baseType, key, normalize) {
+ var baseKind, t1, rti;
+ if (normalize) {
+ baseKind = baseType._kind;
+ if (!A.isSoundTopType(baseType))
+ t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6;
+ else
+ t1 = true;
+ if (t1)
+ return baseType;
+ }
+ rti = new A.Rti(null, null);
+ rti._kind = 6;
+ rti._primary = baseType;
+ rti._canonicalRecipe = key;
+ return A._Universe__installTypeTests(universe, rti);
+ },
+ _Universe__lookupQuestionRti(universe, baseType, normalize) {
+ var t1,
+ key = baseType._canonicalRecipe + "?",
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ t1 = A._Universe__createQuestionRti(universe, baseType, key, normalize);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__createQuestionRti(universe, baseType, key, normalize) {
+ var baseKind, t1, starArgument, rti;
+ if (normalize) {
+ baseKind = baseType._kind;
+ if (!A.isSoundTopType(baseType))
+ if (!(baseType === type$.Null || baseType === type$.JSNull))
+ if (baseKind !== 7)
+ t1 = baseKind === 8 && A.isNullable(baseType._primary);
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ if (t1)
+ return baseType;
+ else if (baseKind === 1 || baseType === type$.legacy_Never)
+ return type$.Null;
+ else if (baseKind === 6) {
+ starArgument = baseType._primary;
+ if (starArgument._kind === 8 && A.isNullable(starArgument._primary))
+ return starArgument;
+ else
+ return A.Rti__getQuestionFromStar(universe, baseType);
+ }
+ }
+ rti = new A.Rti(null, null);
+ rti._kind = 7;
+ rti._primary = baseType;
+ rti._canonicalRecipe = key;
+ return A._Universe__installTypeTests(universe, rti);
+ },
+ _Universe__lookupFutureOrRti(universe, baseType, normalize) {
+ var t1,
+ key = baseType._canonicalRecipe + "/",
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ t1 = A._Universe__createFutureOrRti(universe, baseType, key, normalize);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__createFutureOrRti(universe, baseType, key, normalize) {
+ var t1, rti;
+ if (normalize) {
+ t1 = baseType._kind;
+ if (A.isSoundTopType(baseType) || baseType === type$.Object || baseType === type$.legacy_Object)
+ return baseType;
+ else if (t1 === 1)
+ return A._Universe__lookupInterfaceRti(universe, "Future", [baseType]);
+ else if (baseType === type$.Null || baseType === type$.JSNull)
+ return type$.nullable_Future_Null;
+ }
+ rti = new A.Rti(null, null);
+ rti._kind = 8;
+ rti._primary = baseType;
+ rti._canonicalRecipe = key;
+ return A._Universe__installTypeTests(universe, rti);
+ },
+ _Universe__lookupGenericFunctionParameterRti(universe, index) {
+ var rti, t1,
+ key = "" + index + "^",
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = 14;
+ rti._primary = index;
+ rti._canonicalRecipe = key;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__canonicalRecipeJoin($arguments) {
+ var s, sep, i,
+ $length = $arguments.length;
+ for (s = "", sep = "", i = 0; i < $length; ++i, sep = ",")
+ s += sep + $arguments[i]._canonicalRecipe;
+ return s;
+ },
+ _Universe__canonicalRecipeJoinNamed($arguments) {
+ var s, sep, i, t1, nameSep,
+ $length = $arguments.length;
+ for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") {
+ t1 = $arguments[i];
+ nameSep = $arguments[i + 1] ? "!" : ":";
+ s += sep + t1 + nameSep + $arguments[i + 2]._canonicalRecipe;
+ }
+ return s;
+ },
+ _Universe__lookupInterfaceRti(universe, $name, $arguments) {
+ var probe, rti, t1,
+ s = $name;
+ if ($arguments.length > 0)
+ s += "<" + A._Universe__canonicalRecipeJoin($arguments) + ">";
+ probe = universe.eC.get(s);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = 9;
+ rti._primary = $name;
+ rti._rest = $arguments;
+ if ($arguments.length > 0)
+ rti._precomputed1 = $arguments[0];
+ rti._canonicalRecipe = s;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(s, t1);
+ return t1;
+ },
+ _Universe__lookupBindingRti(universe, base, $arguments) {
+ var newBase, newArguments, key, probe, rti, t1;
+ if (base._kind === 10) {
+ newBase = base._primary;
+ newArguments = base._rest.concat($arguments);
+ } else {
+ newArguments = $arguments;
+ newBase = base;
+ }
+ key = newBase._canonicalRecipe + (";<" + A._Universe__canonicalRecipeJoin(newArguments) + ">");
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = 10;
+ rti._primary = newBase;
+ rti._rest = newArguments;
+ rti._canonicalRecipe = key;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__lookupRecordRti(universe, partialShapeTag, fields) {
+ var rti, t1,
+ key = "+" + (partialShapeTag + "(" + A._Universe__canonicalRecipeJoin(fields) + ")"),
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = 11;
+ rti._primary = partialShapeTag;
+ rti._rest = fields;
+ rti._canonicalRecipe = key;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__lookupFunctionRti(universe, returnType, parameters) {
+ var sep, key, probe, rti, t1,
+ s = returnType._canonicalRecipe,
+ requiredPositional = parameters._requiredPositional,
+ requiredPositionalLength = requiredPositional.length,
+ optionalPositional = parameters._optionalPositional,
+ optionalPositionalLength = optionalPositional.length,
+ named = parameters._named,
+ namedLength = named.length,
+ recipe = "(" + A._Universe__canonicalRecipeJoin(requiredPositional);
+ if (optionalPositionalLength > 0) {
+ sep = requiredPositionalLength > 0 ? "," : "";
+ recipe += sep + "[" + A._Universe__canonicalRecipeJoin(optionalPositional) + "]";
+ }
+ if (namedLength > 0) {
+ sep = requiredPositionalLength > 0 ? "," : "";
+ recipe += sep + "{" + A._Universe__canonicalRecipeJoinNamed(named) + "}";
+ }
+ key = s + (recipe + ")");
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ rti = new A.Rti(null, null);
+ rti._kind = 12;
+ rti._primary = returnType;
+ rti._rest = parameters;
+ rti._canonicalRecipe = key;
+ t1 = A._Universe__installTypeTests(universe, rti);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__lookupGenericFunctionRti(universe, baseFunctionType, bounds, normalize) {
+ var t1,
+ key = baseFunctionType._canonicalRecipe + ("<" + A._Universe__canonicalRecipeJoin(bounds) + ">"),
+ probe = universe.eC.get(key);
+ if (probe != null)
+ return probe;
+ t1 = A._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize);
+ universe.eC.set(key, t1);
+ return t1;
+ },
+ _Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize) {
+ var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti;
+ if (normalize) {
+ $length = bounds.length;
+ typeArguments = A._Utils_newArrayOrEmpty($length);
+ for (count = 0, i = 0; i < $length; ++i) {
+ bound = bounds[i];
+ if (bound._kind === 1) {
+ typeArguments[i] = bound;
+ ++count;
+ }
+ }
+ if (count > 0) {
+ substitutedBase = A._substitute(universe, baseFunctionType, typeArguments, 0);
+ substitutedBounds = A._substituteArray(universe, bounds, typeArguments, 0);
+ return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds);
+ }
+ }
+ rti = new A.Rti(null, null);
+ rti._kind = 13;
+ rti._primary = baseFunctionType;
+ rti._rest = bounds;
+ rti._canonicalRecipe = key;
+ return A._Universe__installTypeTests(universe, rti);
+ },
+ _Parser_create(universe, environment, recipe, normalize) {
+ return {u: universe, e: environment, r: recipe, s: [], p: 0, n: normalize};
+ },
+ _Parser_parse(parser) {
+ var t2, i, ch, t3, array, end, item,
+ source = parser.r,
+ t1 = parser.s;
+ for (t2 = source.length, i = 0; i < t2;) {
+ ch = source.charCodeAt(i);
+ if (ch >= 48 && ch <= 57)
+ i = A._Parser_handleDigit(i + 1, ch, source, t1);
+ else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124)
+ i = A._Parser_handleIdentifier(parser, i, source, t1, false);
+ else if (ch === 46)
+ i = A._Parser_handleIdentifier(parser, i, source, t1, true);
+ else {
+ ++i;
+ switch (ch) {
+ case 44:
+ break;
+ case 58:
+ t1.push(false);
+ break;
+ case 33:
+ t1.push(true);
+ break;
+ case 59:
+ t1.push(A._Parser_toType(parser.u, parser.e, t1.pop()));
+ break;
+ case 94:
+ t1.push(A._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop()));
+ break;
+ case 35:
+ t1.push(A._Universe__lookupTerminalRti(parser.u, 5, "#"));
+ break;
+ case 64:
+ t1.push(A._Universe__lookupTerminalRti(parser.u, 2, "@"));
+ break;
+ case 126:
+ t1.push(A._Universe__lookupTerminalRti(parser.u, 3, "~"));
+ break;
+ case 60:
+ t1.push(parser.p);
+ parser.p = t1.length;
+ break;
+ case 62:
+ A._Parser_handleTypeArguments(parser, t1);
+ break;
+ case 38:
+ A._Parser_handleExtendedOperations(parser, t1);
+ break;
+ case 42:
+ t3 = parser.u;
+ t1.push(A._Universe__lookupStarRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
+ break;
+ case 63:
+ t3 = parser.u;
+ t1.push(A._Universe__lookupQuestionRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
+ break;
+ case 47:
+ t3 = parser.u;
+ t1.push(A._Universe__lookupFutureOrRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
+ break;
+ case 40:
+ t1.push(-3);
+ t1.push(parser.p);
+ parser.p = t1.length;
+ break;
+ case 41:
+ A._Parser_handleArguments(parser, t1);
+ break;
+ case 91:
+ t1.push(parser.p);
+ parser.p = t1.length;
+ break;
+ case 93:
+ array = t1.splice(parser.p);
+ A._Parser_toTypes(parser.u, parser.e, array);
+ parser.p = t1.pop();
+ t1.push(array);
+ t1.push(-1);
+ break;
+ case 123:
+ t1.push(parser.p);
+ parser.p = t1.length;
+ break;
+ case 125:
+ array = t1.splice(parser.p);
+ A._Parser_toTypesNamed(parser.u, parser.e, array);
+ parser.p = t1.pop();
+ t1.push(array);
+ t1.push(-2);
+ break;
+ case 43:
+ end = source.indexOf("(", i);
+ t1.push(source.substring(i, end));
+ t1.push(-4);
+ t1.push(parser.p);
+ parser.p = t1.length;
+ i = end + 1;
+ break;
+ default:
+ throw "Bad character " + ch;
+ }
+ }
+ }
+ item = t1.pop();
+ return A._Parser_toType(parser.u, parser.e, item);
+ },
+ _Parser_handleDigit(i, digit, source, stack) {
+ var t1, ch,
+ value = digit - 48;
+ for (t1 = source.length; i < t1; ++i) {
+ ch = source.charCodeAt(i);
+ if (!(ch >= 48 && ch <= 57))
+ break;
+ value = value * 10 + (ch - 48);
+ }
+ stack.push(value);
+ return i;
+ },
+ _Parser_handleIdentifier(parser, start, source, stack, hasPeriod) {
+ var t1, ch, t2, string, environment, recipe,
+ i = start + 1;
+ for (t1 = source.length; i < t1; ++i) {
+ ch = source.charCodeAt(i);
+ if (ch === 46) {
+ if (hasPeriod)
+ break;
+ hasPeriod = true;
+ } else {
+ if (!((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124))
+ t2 = ch >= 48 && ch <= 57;
+ else
+ t2 = true;
+ if (!t2)
+ break;
+ }
+ }
+ string = source.substring(start, i);
+ if (hasPeriod) {
+ t1 = parser.u;
+ environment = parser.e;
+ if (environment._kind === 10)
+ environment = environment._primary;
+ recipe = A._Universe_findRule(t1, environment._primary)[string];
+ if (recipe == null)
+ A.throwExpression('No "' + string + '" in "' + A.Rti__getCanonicalRecipe(environment) + '"');
+ stack.push(A._Universe_evalInEnvironment(t1, environment, recipe));
+ } else
+ stack.push(string);
+ return i;
+ },
+ _Parser_handleTypeArguments(parser, stack) {
+ var base,
+ t1 = parser.u,
+ $arguments = A._Parser_collectArray(parser, stack),
+ head = stack.pop();
+ if (typeof head == "string")
+ stack.push(A._Universe__lookupInterfaceRti(t1, head, $arguments));
+ else {
+ base = A._Parser_toType(t1, parser.e, head);
+ switch (base._kind) {
+ case 12:
+ stack.push(A._Universe__lookupGenericFunctionRti(t1, base, $arguments, parser.n));
+ break;
+ default:
+ stack.push(A._Universe__lookupBindingRti(t1, base, $arguments));
+ break;
+ }
+ }
+ },
+ _Parser_handleArguments(parser, stack) {
+ var optionalPositional, named, requiredPositional, returnType, parameters, _null = null,
+ t1 = parser.u,
+ head = stack.pop();
+ if (typeof head == "number")
+ switch (head) {
+ case -1:
+ optionalPositional = stack.pop();
+ named = _null;
+ break;
+ case -2:
+ named = stack.pop();
+ optionalPositional = _null;
+ break;
+ default:
+ stack.push(head);
+ named = _null;
+ optionalPositional = named;
+ break;
+ }
+ else {
+ stack.push(head);
+ named = _null;
+ optionalPositional = named;
+ }
+ requiredPositional = A._Parser_collectArray(parser, stack);
+ head = stack.pop();
+ switch (head) {
+ case -3:
+ head = stack.pop();
+ if (optionalPositional == null)
+ optionalPositional = t1.sEA;
+ if (named == null)
+ named = t1.sEA;
+ returnType = A._Parser_toType(t1, parser.e, head);
+ parameters = new A._FunctionParameters();
+ parameters._requiredPositional = requiredPositional;
+ parameters._optionalPositional = optionalPositional;
+ parameters._named = named;
+ stack.push(A._Universe__lookupFunctionRti(t1, returnType, parameters));
+ return;
+ case -4:
+ stack.push(A._Universe__lookupRecordRti(t1, stack.pop(), requiredPositional));
+ return;
+ default:
+ throw A.wrapException(A.AssertionError$("Unexpected state under `()`: " + A.S(head)));
+ }
+ },
+ _Parser_handleExtendedOperations(parser, stack) {
+ var $top = stack.pop();
+ if (0 === $top) {
+ stack.push(A._Universe__lookupTerminalRti(parser.u, 1, "0&"));
+ return;
+ }
+ if (1 === $top) {
+ stack.push(A._Universe__lookupTerminalRti(parser.u, 4, "1&"));
+ return;
+ }
+ throw A.wrapException(A.AssertionError$("Unexpected extended operation " + A.S($top)));
+ },
+ _Parser_collectArray(parser, stack) {
+ var array = stack.splice(parser.p);
+ A._Parser_toTypes(parser.u, parser.e, array);
+ parser.p = stack.pop();
+ return array;
+ },
+ _Parser_toType(universe, environment, item) {
+ if (typeof item == "string")
+ return A._Universe__lookupInterfaceRti(universe, item, universe.sEA);
+ else if (typeof item == "number") {
+ environment.toString;
+ return A._Parser_indexToType(universe, environment, item);
+ } else
+ return item;
+ },
+ _Parser_toTypes(universe, environment, items) {
+ var i,
+ $length = items.length;
+ for (i = 0; i < $length; ++i)
+ items[i] = A._Parser_toType(universe, environment, items[i]);
+ },
+ _Parser_toTypesNamed(universe, environment, items) {
+ var i,
+ $length = items.length;
+ for (i = 2; i < $length; i += 3)
+ items[i] = A._Parser_toType(universe, environment, items[i]);
+ },
+ _Parser_indexToType(universe, environment, index) {
+ var typeArguments, len,
+ kind = environment._kind;
+ if (kind === 10) {
+ if (index === 0)
+ return environment._primary;
+ typeArguments = environment._rest;
+ len = typeArguments.length;
+ if (index <= len)
+ return typeArguments[index - 1];
+ index -= len;
+ environment = environment._primary;
+ kind = environment._kind;
+ } else if (index === 0)
+ return environment;
+ if (kind !== 9)
+ throw A.wrapException(A.AssertionError$("Indexed base must be an interface type"));
+ typeArguments = environment._rest;
+ if (index <= typeArguments.length)
+ return typeArguments[index - 1];
+ throw A.wrapException(A.AssertionError$("Bad index " + index + " for " + environment.toString$0(0)));
+ },
+ isSubtype(universe, s, t) {
+ var result,
+ sCache = s._isSubtypeCache;
+ if (sCache == null)
+ sCache = s._isSubtypeCache = new Map();
+ result = sCache.get(t);
+ if (result == null) {
+ result = A._isSubtype(universe, s, null, t, null, false) ? 1 : 0;
+ sCache.set(t, result);
+ }
+ if (0 === result)
+ return false;
+ if (1 === result)
+ return true;
+ return true;
+ },
+ _isSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
+ var t1, sKind, leftTypeVariable, tKind, t2, sBounds, tBounds, sLength, i, sBound, tBound;
+ if (s === t)
+ return true;
+ if (!A.isSoundTopType(t))
+ t1 = t === type$.legacy_Object;
+ else
+ t1 = true;
+ if (t1)
+ return true;
+ sKind = s._kind;
+ if (sKind === 4)
+ return true;
+ if (A.isSoundTopType(s))
+ return false;
+ t1 = s._kind;
+ if (t1 === 1)
+ return true;
+ leftTypeVariable = sKind === 14;
+ if (leftTypeVariable)
+ if (A._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv, false))
+ return true;
+ tKind = t._kind;
+ t1 = s === type$.Null || s === type$.JSNull;
+ if (t1) {
+ if (tKind === 8)
+ return A._isSubtype(universe, s, sEnv, t._primary, tEnv, false);
+ return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6;
+ }
+ if (t === type$.Object) {
+ if (sKind === 8)
+ return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
+ if (sKind === 6)
+ return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
+ return sKind !== 7;
+ }
+ if (sKind === 6)
+ return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
+ if (tKind === 6) {
+ t1 = A.Rti__getQuestionFromStar(universe, t);
+ return A._isSubtype(universe, s, sEnv, t1, tEnv, false);
+ }
+ if (sKind === 8) {
+ if (!A._isSubtype(universe, s._primary, sEnv, t, tEnv, false))
+ return false;
+ return A._isSubtype(universe, A.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv, false);
+ }
+ if (sKind === 7) {
+ t1 = A._isSubtype(universe, type$.Null, sEnv, t, tEnv, false);
+ return t1 && A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
+ }
+ if (tKind === 8) {
+ if (A._isSubtype(universe, s, sEnv, t._primary, tEnv, false))
+ return true;
+ return A._isSubtype(universe, s, sEnv, A.Rti__getFutureFromFutureOr(universe, t), tEnv, false);
+ }
+ if (tKind === 7) {
+ t1 = A._isSubtype(universe, s, sEnv, type$.Null, tEnv, false);
+ return t1 || A._isSubtype(universe, s, sEnv, t._primary, tEnv, false);
+ }
+ if (leftTypeVariable)
+ return false;
+ t1 = sKind !== 12;
+ if ((!t1 || sKind === 13) && t === type$.Function)
+ return true;
+ t2 = sKind === 11;
+ if (t2 && t === type$.Record)
+ return true;
+ if (tKind === 13) {
+ if (s === type$.JavaScriptFunction)
+ return true;
+ if (sKind !== 13)
+ return false;
+ sBounds = s._rest;
+ tBounds = t._rest;
+ sLength = sBounds.length;
+ if (sLength !== tBounds.length)
+ return false;
+ sEnv = sEnv == null ? sBounds : sBounds.concat(sEnv);
+ tEnv = tEnv == null ? tBounds : tBounds.concat(tEnv);
+ for (i = 0; i < sLength; ++i) {
+ sBound = sBounds[i];
+ tBound = tBounds[i];
+ if (!A._isSubtype(universe, sBound, sEnv, tBound, tEnv, false) || !A._isSubtype(universe, tBound, tEnv, sBound, sEnv, false))
+ return false;
+ }
+ return A._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv, false);
+ }
+ if (tKind === 12) {
+ if (s === type$.JavaScriptFunction)
+ return true;
+ if (t1)
+ return false;
+ return A._isFunctionSubtype(universe, s, sEnv, t, tEnv, false);
+ }
+ if (sKind === 9) {
+ if (tKind !== 9)
+ return false;
+ return A._isInterfaceSubtype(universe, s, sEnv, t, tEnv, false);
+ }
+ if (t2 && tKind === 11)
+ return A._isRecordSubtype(universe, s, sEnv, t, tEnv, false);
+ return false;
+ },
+ _isFunctionSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
+ var sParameters, tParameters, sRequiredPositional, tRequiredPositional, sRequiredPositionalLength, tRequiredPositionalLength, requiredPositionalDelta, sOptionalPositional, tOptionalPositional, sOptionalPositionalLength, tOptionalPositionalLength, i, t1, sNamed, tNamed, sNamedLength, tNamedLength, sIndex, tIndex, tName, sName, sIsRequired;
+ if (!A._isSubtype(universe, s._primary, sEnv, t._primary, tEnv, false))
+ return false;
+ sParameters = s._rest;
+ tParameters = t._rest;
+ sRequiredPositional = sParameters._requiredPositional;
+ tRequiredPositional = tParameters._requiredPositional;
+ sRequiredPositionalLength = sRequiredPositional.length;
+ tRequiredPositionalLength = tRequiredPositional.length;
+ if (sRequiredPositionalLength > tRequiredPositionalLength)
+ return false;
+ requiredPositionalDelta = tRequiredPositionalLength - sRequiredPositionalLength;
+ sOptionalPositional = sParameters._optionalPositional;
+ tOptionalPositional = tParameters._optionalPositional;
+ sOptionalPositionalLength = sOptionalPositional.length;
+ tOptionalPositionalLength = tOptionalPositional.length;
+ if (sRequiredPositionalLength + sOptionalPositionalLength < tRequiredPositionalLength + tOptionalPositionalLength)
+ return false;
+ for (i = 0; i < sRequiredPositionalLength; ++i) {
+ t1 = sRequiredPositional[i];
+ if (!A._isSubtype(universe, tRequiredPositional[i], tEnv, t1, sEnv, false))
+ return false;
+ }
+ for (i = 0; i < requiredPositionalDelta; ++i) {
+ t1 = sOptionalPositional[i];
+ if (!A._isSubtype(universe, tRequiredPositional[sRequiredPositionalLength + i], tEnv, t1, sEnv, false))
+ return false;
+ }
+ for (i = 0; i < tOptionalPositionalLength; ++i) {
+ t1 = sOptionalPositional[requiredPositionalDelta + i];
+ if (!A._isSubtype(universe, tOptionalPositional[i], tEnv, t1, sEnv, false))
+ return false;
+ }
+ sNamed = sParameters._named;
+ tNamed = tParameters._named;
+ sNamedLength = sNamed.length;
+ tNamedLength = tNamed.length;
+ for (sIndex = 0, tIndex = 0; tIndex < tNamedLength; tIndex += 3) {
+ tName = tNamed[tIndex];
+ for (; true;) {
+ if (sIndex >= sNamedLength)
+ return false;
+ sName = sNamed[sIndex];
+ sIndex += 3;
+ if (tName < sName)
+ return false;
+ sIsRequired = sNamed[sIndex - 2];
+ if (sName < tName) {
+ if (sIsRequired)
+ return false;
+ continue;
+ }
+ t1 = tNamed[tIndex + 1];
+ if (sIsRequired && !t1)
+ return false;
+ t1 = sNamed[sIndex - 1];
+ if (!A._isSubtype(universe, tNamed[tIndex + 2], tEnv, t1, sEnv, false))
+ return false;
+ break;
+ }
+ }
+ for (; sIndex < sNamedLength;) {
+ if (sNamed[sIndex + 1])
+ return false;
+ sIndex += 3;
+ }
+ return true;
+ },
+ _isInterfaceSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
+ var rule, recipes, $length, supertypeArgs, i,
+ sName = s._primary,
+ tName = t._primary;
+ for (; sName !== tName;) {
+ rule = universe.tR[sName];
+ if (rule == null)
+ return false;
+ if (typeof rule == "string") {
+ sName = rule;
+ continue;
+ }
+ recipes = rule[tName];
+ if (recipes == null)
+ return false;
+ $length = recipes.length;
+ supertypeArgs = $length > 0 ? new Array($length) : init.typeUniverse.sEA;
+ for (i = 0; i < $length; ++i)
+ supertypeArgs[i] = A._Universe_evalInEnvironment(universe, s, recipes[i]);
+ return A._areArgumentsSubtypes(universe, supertypeArgs, null, sEnv, t._rest, tEnv, false);
+ }
+ return A._areArgumentsSubtypes(universe, s._rest, null, sEnv, t._rest, tEnv, false);
+ },
+ _areArgumentsSubtypes(universe, sArgs, sVariances, sEnv, tArgs, tEnv, isLegacy) {
+ var i,
+ $length = sArgs.length;
+ for (i = 0; i < $length; ++i)
+ if (!A._isSubtype(universe, sArgs[i], sEnv, tArgs[i], tEnv, false))
+ return false;
+ return true;
+ },
+ _isRecordSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
+ var i,
+ sFields = s._rest,
+ tFields = t._rest,
+ sCount = sFields.length;
+ if (sCount !== tFields.length)
+ return false;
+ if (s._primary !== t._primary)
+ return false;
+ for (i = 0; i < sCount; ++i)
+ if (!A._isSubtype(universe, sFields[i], sEnv, tFields[i], tEnv, false))
+ return false;
+ return true;
+ },
+ isNullable(t) {
+ var t1,
+ kind = t._kind;
+ if (!(t === type$.Null || t === type$.JSNull))
+ if (!A.isSoundTopType(t))
+ if (kind !== 7)
+ if (!(kind === 6 && A.isNullable(t._primary)))
+ t1 = kind === 8 && A.isNullable(t._primary);
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ else
+ t1 = true;
+ return t1;
+ },
+ isDefinitelyTopType(t) {
+ var t1;
+ if (!A.isSoundTopType(t))
+ t1 = t === type$.legacy_Object;
+ else
+ t1 = true;
+ return t1;
+ },
+ isSoundTopType(t) {
+ var kind = t._kind;
+ return kind === 2 || kind === 3 || kind === 4 || kind === 5 || t === type$.nullable_Object;
+ },
+ _Utils_objectAssign(o, other) {
+ var i, key,
+ keys = Object.keys(other),
+ $length = keys.length;
+ for (i = 0; i < $length; ++i) {
+ key = keys[i];
+ o[key] = other[key];
+ }
+ },
+ _Utils_newArrayOrEmpty($length) {
+ return $length > 0 ? new Array($length) : init.typeUniverse.sEA;
+ },
+ Rti: function Rti(t0, t1) {
+ var _ = this;
+ _._as = t0;
+ _._is = t1;
+ _._cachedRuntimeType = _._specializedTestResource = _._isSubtypeCache = _._precomputed1 = null;
+ _._kind = 0;
+ _._canonicalRecipe = _._bindCache = _._evalCache = _._rest = _._primary = null;
+ },
+ _FunctionParameters: function _FunctionParameters() {
+ this._named = this._optionalPositional = this._requiredPositional = null;
+ },
+ _Type: function _Type(t0) {
+ this._rti = t0;
+ },
+ _Error: function _Error() {
+ },
+ _TypeError: function _TypeError(t0) {
+ this.__rti$_message = t0;
+ },
+ _AsyncRun__initializeScheduleImmediate() {
+ var div, span, t1 = {};
+ if (self.scheduleImmediate != null)
+ return A.async__AsyncRun__scheduleImmediateJsOverride$closure();
+ if (self.MutationObserver != null && self.document != null) {
+ div = self.document.createElement("div");
+ span = self.document.createElement("span");
+ t1.storedCallback = null;
+ new self.MutationObserver(A.convertDartClosureToJS(new A._AsyncRun__initializeScheduleImmediate_internalCallback(t1), 1)).observe(div, {childList: true});
+ return new A._AsyncRun__initializeScheduleImmediate_closure(t1, div, span);
+ } else if (self.setImmediate != null)
+ return A.async__AsyncRun__scheduleImmediateWithSetImmediate$closure();
+ return A.async__AsyncRun__scheduleImmediateWithTimer$closure();
+ },
+ _AsyncRun__scheduleImmediateJsOverride(callback) {
+ self.scheduleImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateJsOverride_internalCallback(type$.void_Function._as(callback)), 0));
+ },
+ _AsyncRun__scheduleImmediateWithSetImmediate(callback) {
+ self.setImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(type$.void_Function._as(callback)), 0));
+ },
+ _AsyncRun__scheduleImmediateWithTimer(callback) {
+ A.Timer__createTimer(B.Duration_0, type$.void_Function._as(callback));
+ },
+ Timer__createTimer(duration, callback) {
+ return A._TimerImpl$(duration._duration / 1000 | 0, callback);
+ },
+ _TimerImpl$(milliseconds, callback) {
+ var t1 = new A._TimerImpl();
+ t1._TimerImpl$2(milliseconds, callback);
+ return t1;
+ },
+ _makeAsyncAwaitCompleter($T) {
+ return new A._AsyncAwaitCompleter(new A._Future($.Zone__current, $T._eval$1("_Future<0>")), $T._eval$1("_AsyncAwaitCompleter<0>"));
+ },
+ _asyncStartSync(bodyFunction, completer) {
+ bodyFunction.call$2(0, null);
+ completer.isSync = true;
+ return completer._future;
+ },
+ _asyncAwait(object, bodyFunction) {
+ A._awaitOnObject(object, bodyFunction);
+ },
+ _asyncReturn(object, completer) {
+ completer.complete$1(object);
+ },
+ _asyncRethrow(object, completer) {
+ completer.completeError$2(A.unwrapException(object), A.getTraceFromException(object));
+ },
+ _awaitOnObject(object, bodyFunction) {
+ var t1, future,
+ thenCallback = new A._awaitOnObject_closure(bodyFunction),
+ errorCallback = new A._awaitOnObject_closure0(bodyFunction);
+ if (object instanceof A._Future)
+ object._thenAwait$1$2(thenCallback, errorCallback, type$.dynamic);
+ else {
+ t1 = type$.dynamic;
+ if (object instanceof A._Future)
+ object.then$1$2$onError(thenCallback, errorCallback, t1);
+ else {
+ future = new A._Future($.Zone__current, type$._Future_dynamic);
+ future._state = 8;
+ future._resultOrListeners = object;
+ future._thenAwait$1$2(thenCallback, errorCallback, t1);
+ }
+ }
+ },
+ _wrapJsFunctionForAsync($function) {
+ var $protected = function(fn, ERROR) {
+ return function(errorCode, result) {
+ while (true) {
+ try {
+ fn(errorCode, result);
+ break;
+ } catch (error) {
+ result = error;
+ errorCode = ERROR;
+ }
+ }
+ };
+ }($function, 1);
+ return $.Zone__current.registerBinaryCallback$3$1(new A._wrapJsFunctionForAsync_closure($protected), type$.void, type$.int, type$.dynamic);
+ },
+ AsyncError$(error, stackTrace) {
+ var t1 = A.checkNotNullable(error, "error", type$.Object);
+ return new A.AsyncError(t1, stackTrace == null ? A.AsyncError_defaultStackTrace(error) : stackTrace);
+ },
+ AsyncError_defaultStackTrace(error) {
+ var stackTrace;
+ if (type$.Error._is(error)) {
+ stackTrace = error.get$stackTrace();
+ if (stackTrace != null)
+ return stackTrace;
+ }
+ return B._StringStackTrace_3uE;
+ },
+ Future_Future$sync(computation, $T) {
+ var result, error, stackTrace, future, replacement, t1, exception;
+ try {
+ result = computation.call$0();
+ t1 = $T._eval$1("Future<0>")._is(result) ? result : A._Future$value(result, $T);
+ return t1;
+ } catch (exception) {
+ error = A.unwrapException(exception);
+ stackTrace = A.getTraceFromException(exception);
+ future = new A._Future($.Zone__current, $T._eval$1("_Future<0>"));
+ type$.Object._as(error);
+ type$.nullable_StackTrace._as(stackTrace);
+ replacement = null;
+ if (replacement != null)
+ future._asyncCompleteError$2(replacement.get$error(), replacement.get$stackTrace());
+ else
+ future._asyncCompleteError$2(error, stackTrace);
+ return future;
+ }
+ },
+ Future_Future$value(value, $T) {
+ var t1 = value == null ? $T._as(value) : value,
+ t2 = new A._Future($.Zone__current, $T._eval$1("_Future<0>"));
+ t2._asyncComplete$1(t1);
+ return t2;
+ },
+ Completer_Completer($T) {
+ return new A._AsyncCompleter(new A._Future($.Zone__current, $T._eval$1("_Future<0>")), $T._eval$1("_AsyncCompleter<0>"));
+ },
+ _Future$value(value, $T) {
+ var t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>"));
+ $T._as(value);
+ t1._state = 8;
+ t1._resultOrListeners = value;
+ return t1;
+ },
+ _Future__chainCoreFutureSync(source, target) {
+ var t1, t2, listeners;
+ for (t1 = type$._Future_dynamic; t2 = source._state, (t2 & 4) !== 0;)
+ source = t1._as(source._resultOrListeners);
+ if ((t2 & 24) !== 0) {
+ listeners = target._removeListeners$0();
+ target._cloneResult$1(source);
+ A._Future__propagateToListeners(target, listeners);
+ } else {
+ listeners = type$.nullable__FutureListener_dynamic_dynamic._as(target._resultOrListeners);
+ target._setChained$1(source);
+ source._prependListeners$1(listeners);
+ }
+ },
+ _Future__chainCoreFutureAsync(source, target) {
+ var t2, t3, listeners, _box_0 = {},
+ t1 = _box_0.source = source;
+ for (t2 = type$._Future_dynamic; t3 = t1._state, (t3 & 4) !== 0; t1 = source) {
+ source = t2._as(t1._resultOrListeners);
+ _box_0.source = source;
+ }
+ if ((t3 & 24) === 0) {
+ listeners = type$.nullable__FutureListener_dynamic_dynamic._as(target._resultOrListeners);
+ target._setChained$1(t1);
+ _box_0.source._prependListeners$1(listeners);
+ return;
+ }
+ if ((t3 & 16) === 0 && target._resultOrListeners == null) {
+ target._cloneResult$1(t1);
+ return;
+ }
+ target._state ^= 2;
+ A._rootScheduleMicrotask(null, null, target._zone, type$.void_Function._as(new A._Future__chainCoreFutureAsync_closure(_box_0, target)));
+ },
+ _Future__propagateToListeners(source, listeners) {
+ var t2, t3, t4, _box_0, t5, t6, hasError, asyncError, nextListener, nextListener0, sourceResult, t7, zone, oldZone, result, current, _box_1 = {},
+ t1 = _box_1.source = source;
+ for (t2 = type$.AsyncError, t3 = type$.nullable__FutureListener_dynamic_dynamic, t4 = type$.Future_dynamic; true;) {
+ _box_0 = {};
+ t5 = t1._state;
+ t6 = (t5 & 16) === 0;
+ hasError = !t6;
+ if (listeners == null) {
+ if (hasError && (t5 & 1) === 0) {
+ asyncError = t2._as(t1._resultOrListeners);
+ A._rootHandleError(asyncError.error, asyncError.stackTrace);
+ }
+ return;
+ }
+ _box_0.listener = listeners;
+ nextListener = listeners._nextListener;
+ for (t1 = listeners; nextListener != null; t1 = nextListener, nextListener = nextListener0) {
+ t1._nextListener = null;
+ A._Future__propagateToListeners(_box_1.source, t1);
+ _box_0.listener = nextListener;
+ nextListener0 = nextListener._nextListener;
+ }
+ t5 = _box_1.source;
+ sourceResult = t5._resultOrListeners;
+ _box_0.listenerHasError = hasError;
+ _box_0.listenerValueOrError = sourceResult;
+ if (t6) {
+ t7 = t1.state;
+ t7 = (t7 & 1) !== 0 || (t7 & 15) === 8;
+ } else
+ t7 = true;
+ if (t7) {
+ zone = t1.result._zone;
+ if (hasError) {
+ t5 = t5._zone === zone;
+ t5 = !(t5 || t5);
+ } else
+ t5 = false;
+ if (t5) {
+ t2._as(sourceResult);
+ A._rootHandleError(sourceResult.error, sourceResult.stackTrace);
+ return;
+ }
+ oldZone = $.Zone__current;
+ if (oldZone !== zone)
+ $.Zone__current = zone;
+ else
+ oldZone = null;
+ t1 = t1.state;
+ if ((t1 & 15) === 8)
+ new A._Future__propagateToListeners_handleWhenCompleteCallback(_box_0, _box_1, hasError).call$0();
+ else if (t6) {
+ if ((t1 & 1) !== 0)
+ new A._Future__propagateToListeners_handleValueCallback(_box_0, sourceResult).call$0();
+ } else if ((t1 & 2) !== 0)
+ new A._Future__propagateToListeners_handleError(_box_1, _box_0).call$0();
+ if (oldZone != null)
+ $.Zone__current = oldZone;
+ t1 = _box_0.listenerValueOrError;
+ if (t1 instanceof A._Future) {
+ t5 = _box_0.listener.$ti;
+ t5 = t5._eval$1("Future<2>")._is(t1) || !t5._rest[1]._is(t1);
+ } else
+ t5 = false;
+ if (t5) {
+ t4._as(t1);
+ result = _box_0.listener.result;
+ if ((t1._state & 24) !== 0) {
+ current = t3._as(result._resultOrListeners);
+ result._resultOrListeners = null;
+ listeners = result._reverseListeners$1(current);
+ result._state = t1._state & 30 | result._state & 1;
+ result._resultOrListeners = t1._resultOrListeners;
+ _box_1.source = t1;
+ continue;
+ } else
+ A._Future__chainCoreFutureSync(t1, result);
+ return;
+ }
+ }
+ result = _box_0.listener.result;
+ current = t3._as(result._resultOrListeners);
+ result._resultOrListeners = null;
+ listeners = result._reverseListeners$1(current);
+ t1 = _box_0.listenerHasError;
+ t5 = _box_0.listenerValueOrError;
+ if (!t1) {
+ result.$ti._precomputed1._as(t5);
+ result._state = 8;
+ result._resultOrListeners = t5;
+ } else {
+ t2._as(t5);
+ result._state = result._state & 1 | 16;
+ result._resultOrListeners = t5;
+ }
+ _box_1.source = result;
+ t1 = result;
+ }
+ },
+ _registerErrorHandler(errorHandler, zone) {
+ var t1;
+ if (type$.dynamic_Function_Object_StackTrace._is(errorHandler))
+ return zone.registerBinaryCallback$3$1(errorHandler, type$.dynamic, type$.Object, type$.StackTrace);
+ t1 = type$.dynamic_Function_Object;
+ if (t1._is(errorHandler))
+ return t1._as(errorHandler);
+ throw A.wrapException(A.ArgumentError$value(errorHandler, "onError", string$.Error_));
+ },
+ _microtaskLoop() {
+ var entry, next;
+ for (entry = $._nextCallback; entry != null; entry = $._nextCallback) {
+ $._lastPriorityCallback = null;
+ next = entry.next;
+ $._nextCallback = next;
+ if (next == null)
+ $._lastCallback = null;
+ entry.callback.call$0();
+ }
+ },
+ _startMicrotaskLoop() {
+ $._isInCallbackLoop = true;
+ try {
+ A._microtaskLoop();
+ } finally {
+ $._lastPriorityCallback = null;
+ $._isInCallbackLoop = false;
+ if ($._nextCallback != null)
+ $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure());
+ }
+ },
+ _scheduleAsyncCallback(callback) {
+ var newEntry = new A._AsyncCallbackEntry(callback),
+ lastCallback = $._lastCallback;
+ if (lastCallback == null) {
+ $._nextCallback = $._lastCallback = newEntry;
+ if (!$._isInCallbackLoop)
+ $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure());
+ } else
+ $._lastCallback = lastCallback.next = newEntry;
+ },
+ _schedulePriorityAsyncCallback(callback) {
+ var entry, lastPriorityCallback, next,
+ t1 = $._nextCallback;
+ if (t1 == null) {
+ A._scheduleAsyncCallback(callback);
+ $._lastPriorityCallback = $._lastCallback;
+ return;
+ }
+ entry = new A._AsyncCallbackEntry(callback);
+ lastPriorityCallback = $._lastPriorityCallback;
+ if (lastPriorityCallback == null) {
+ entry.next = t1;
+ $._nextCallback = $._lastPriorityCallback = entry;
+ } else {
+ next = lastPriorityCallback.next;
+ entry.next = next;
+ $._lastPriorityCallback = lastPriorityCallback.next = entry;
+ if (next == null)
+ $._lastCallback = entry;
+ }
+ },
+ scheduleMicrotask(callback) {
+ var _null = null,
+ currentZone = $.Zone__current;
+ if (B.C__RootZone === currentZone) {
+ A._rootScheduleMicrotask(_null, _null, B.C__RootZone, callback);
+ return;
+ }
+ A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(currentZone.bindCallbackGuarded$1(callback)));
+ },
+ StreamIterator_StreamIterator(stream, $T) {
+ A.checkNotNullable(stream, "stream", type$.Object);
+ return new A._StreamIterator($T._eval$1("_StreamIterator<0>"));
+ },
+ StreamController_StreamController($T) {
+ var _null = null;
+ return new A._AsyncStreamController(_null, _null, _null, _null, $T._eval$1("_AsyncStreamController<0>"));
+ },
+ _runGuarded(notificationHandler) {
+ return;
+ },
+ _BufferingStreamSubscription__registerDataHandler(zone, handleData, $T) {
+ var t1 = handleData == null ? A.async___nullDataHandler$closure() : handleData;
+ return type$.$env_1_1_void._bind$1($T)._eval$1("1(2)")._as(t1);
+ },
+ _BufferingStreamSubscription__registerErrorHandler(zone, handleError) {
+ if (handleError == null)
+ handleError = A.async___nullErrorHandler$closure();
+ if (type$.void_Function_Object_StackTrace._is(handleError))
+ return zone.registerBinaryCallback$3$1(handleError, type$.dynamic, type$.Object, type$.StackTrace);
+ if (type$.void_Function_Object._is(handleError))
+ return type$.dynamic_Function_Object._as(handleError);
+ throw A.wrapException(A.ArgumentError$("handleError callback must take either an Object (the error), or both an Object (the error) and a StackTrace.", null));
+ },
+ _nullDataHandler(value) {
+ },
+ _nullErrorHandler(error, stackTrace) {
+ A._rootHandleError(type$.Object._as(error), type$.StackTrace._as(stackTrace));
+ },
+ _nullDoneHandler() {
+ },
+ _cancelAndValue(subscription, future, value) {
+ var cancelFuture = subscription.cancel$0(),
+ t1 = $.$get$Future__nullFuture();
+ if (cancelFuture !== t1)
+ cancelFuture.whenComplete$1(new A._cancelAndValue_closure(future, value));
+ else
+ future._complete$1(value);
+ },
+ Timer_Timer(duration, callback) {
+ var t1 = $.Zone__current;
+ if (t1 === B.C__RootZone)
+ return A.Timer__createTimer(duration, type$.void_Function._as(callback));
+ return A.Timer__createTimer(duration, type$.void_Function._as(t1.bindCallbackGuarded$1(callback)));
+ },
+ _rootHandleError(error, stackTrace) {
+ A._schedulePriorityAsyncCallback(new A._rootHandleError_closure(error, stackTrace));
+ },
+ _rootRun($self, $parent, zone, f, $R) {
+ var old,
+ t1 = $.Zone__current;
+ if (t1 === zone)
+ return f.call$0();
+ $.Zone__current = zone;
+ old = t1;
+ try {
+ t1 = f.call$0();
+ return t1;
+ } finally {
+ $.Zone__current = old;
+ }
+ },
+ _rootRunUnary($self, $parent, zone, f, arg, $R, $T) {
+ var old,
+ t1 = $.Zone__current;
+ if (t1 === zone)
+ return f.call$1(arg);
+ $.Zone__current = zone;
+ old = t1;
+ try {
+ t1 = f.call$1(arg);
+ return t1;
+ } finally {
+ $.Zone__current = old;
+ }
+ },
+ _rootRunBinary($self, $parent, zone, f, arg1, arg2, $R, T1, T2) {
+ var old,
+ t1 = $.Zone__current;
+ if (t1 === zone)
+ return f.call$2(arg1, arg2);
+ $.Zone__current = zone;
+ old = t1;
+ try {
+ t1 = f.call$2(arg1, arg2);
+ return t1;
+ } finally {
+ $.Zone__current = old;
+ }
+ },
+ _rootScheduleMicrotask($self, $parent, zone, f) {
+ type$.void_Function._as(f);
+ if (B.C__RootZone !== zone)
+ f = zone.bindCallbackGuarded$1(f);
+ A._scheduleAsyncCallback(f);
+ },
+ _AsyncRun__initializeScheduleImmediate_internalCallback: function _AsyncRun__initializeScheduleImmediate_internalCallback(t0) {
+ this._box_0 = t0;
+ },
+ _AsyncRun__initializeScheduleImmediate_closure: function _AsyncRun__initializeScheduleImmediate_closure(t0, t1, t2) {
+ this._box_0 = t0;
+ this.div = t1;
+ this.span = t2;
+ },
+ _AsyncRun__scheduleImmediateJsOverride_internalCallback: function _AsyncRun__scheduleImmediateJsOverride_internalCallback(t0) {
+ this.callback = t0;
+ },
+ _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: function _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(t0) {
+ this.callback = t0;
+ },
+ _TimerImpl: function _TimerImpl() {
+ this._handle = null;
+ },
+ _TimerImpl_internalCallback: function _TimerImpl_internalCallback(t0, t1) {
+ this.$this = t0;
+ this.callback = t1;
+ },
+ _AsyncAwaitCompleter: function _AsyncAwaitCompleter(t0, t1) {
+ this._future = t0;
+ this.isSync = false;
+ this.$ti = t1;
+ },
+ _awaitOnObject_closure: function _awaitOnObject_closure(t0) {
+ this.bodyFunction = t0;
+ },
+ _awaitOnObject_closure0: function _awaitOnObject_closure0(t0) {
+ this.bodyFunction = t0;
+ },
+ _wrapJsFunctionForAsync_closure: function _wrapJsFunctionForAsync_closure(t0) {
+ this.$protected = t0;
+ },
+ AsyncError: function AsyncError(t0, t1) {
+ this.error = t0;
+ this.stackTrace = t1;
+ },
+ _Completer: function _Completer() {
+ },
+ _AsyncCompleter: function _AsyncCompleter(t0, t1) {
+ this.future = t0;
+ this.$ti = t1;
+ },
+ _SyncCompleter: function _SyncCompleter(t0, t1) {
+ this.future = t0;
+ this.$ti = t1;
+ },
+ _FutureListener: function _FutureListener(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._nextListener = null;
+ _.result = t0;
+ _.state = t1;
+ _.callback = t2;
+ _.errorCallback = t3;
+ _.$ti = t4;
+ },
+ _Future: function _Future(t0, t1) {
+ var _ = this;
+ _._state = 0;
+ _._zone = t0;
+ _._resultOrListeners = null;
+ _.$ti = t1;
+ },
+ _Future__addListener_closure: function _Future__addListener_closure(t0, t1) {
+ this.$this = t0;
+ this.listener = t1;
+ },
+ _Future__prependListeners_closure: function _Future__prependListeners_closure(t0, t1) {
+ this._box_0 = t0;
+ this.$this = t1;
+ },
+ _Future__chainForeignFuture_closure: function _Future__chainForeignFuture_closure(t0) {
+ this.$this = t0;
+ },
+ _Future__chainForeignFuture_closure0: function _Future__chainForeignFuture_closure0(t0) {
+ this.$this = t0;
+ },
+ _Future__chainForeignFuture_closure1: function _Future__chainForeignFuture_closure1(t0, t1, t2) {
+ this.$this = t0;
+ this.e = t1;
+ this.s = t2;
+ },
+ _Future__chainCoreFutureAsync_closure: function _Future__chainCoreFutureAsync_closure(t0, t1) {
+ this._box_0 = t0;
+ this.target = t1;
+ },
+ _Future__asyncCompleteWithValue_closure: function _Future__asyncCompleteWithValue_closure(t0, t1) {
+ this.$this = t0;
+ this.value = t1;
+ },
+ _Future__asyncCompleteError_closure: function _Future__asyncCompleteError_closure(t0, t1, t2) {
+ this.$this = t0;
+ this.error = t1;
+ this.stackTrace = t2;
+ },
+ _Future__propagateToListeners_handleWhenCompleteCallback: function _Future__propagateToListeners_handleWhenCompleteCallback(t0, t1, t2) {
+ this._box_0 = t0;
+ this._box_1 = t1;
+ this.hasError = t2;
+ },
+ _Future__propagateToListeners_handleWhenCompleteCallback_closure: function _Future__propagateToListeners_handleWhenCompleteCallback_closure(t0) {
+ this.originalSource = t0;
+ },
+ _Future__propagateToListeners_handleValueCallback: function _Future__propagateToListeners_handleValueCallback(t0, t1) {
+ this._box_0 = t0;
+ this.sourceResult = t1;
+ },
+ _Future__propagateToListeners_handleError: function _Future__propagateToListeners_handleError(t0, t1) {
+ this._box_1 = t0;
+ this._box_0 = t1;
+ },
+ _AsyncCallbackEntry: function _AsyncCallbackEntry(t0) {
+ this.callback = t0;
+ this.next = null;
+ },
+ Stream: function Stream() {
+ },
+ Stream_length_closure: function Stream_length_closure(t0, t1) {
+ this._box_0 = t0;
+ this.$this = t1;
+ },
+ Stream_length_closure0: function Stream_length_closure0(t0, t1) {
+ this._box_0 = t0;
+ this.future = t1;
+ },
+ Stream_first_closure: function Stream_first_closure(t0) {
+ this.future = t0;
+ },
+ Stream_first_closure0: function Stream_first_closure0(t0, t1, t2) {
+ this.$this = t0;
+ this.subscription = t1;
+ this.future = t2;
+ },
+ _StreamController: function _StreamController() {
+ },
+ _StreamController__subscribe_closure: function _StreamController__subscribe_closure(t0) {
+ this.$this = t0;
+ },
+ _StreamController__recordCancel_complete: function _StreamController__recordCancel_complete(t0) {
+ this.$this = t0;
+ },
+ _AsyncStreamControllerDispatch: function _AsyncStreamControllerDispatch() {
+ },
+ _AsyncStreamController: function _AsyncStreamController(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._varData = null;
+ _._state = 0;
+ _._doneFuture = null;
+ _.onListen = t0;
+ _.onPause = t1;
+ _.onResume = t2;
+ _.onCancel = t3;
+ _.$ti = t4;
+ },
+ _ControllerStream: function _ControllerStream(t0, t1) {
+ this._controller = t0;
+ this.$ti = t1;
+ },
+ _ControllerSubscription: function _ControllerSubscription(t0, t1, t2, t3, t4, t5, t6) {
+ var _ = this;
+ _._controller = t0;
+ _._onData = t1;
+ _._onError = t2;
+ _._onDone = t3;
+ _._zone = t4;
+ _._state = t5;
+ _._pending = _._cancelFuture = null;
+ _.$ti = t6;
+ },
+ _StreamSinkWrapper: function _StreamSinkWrapper(t0, t1) {
+ this._async$_target = t0;
+ this.$ti = t1;
+ },
+ _BufferingStreamSubscription: function _BufferingStreamSubscription() {
+ },
+ _BufferingStreamSubscription_asFuture_closure: function _BufferingStreamSubscription_asFuture_closure(t0, t1) {
+ this._box_0 = t0;
+ this.result = t1;
+ },
+ _BufferingStreamSubscription_asFuture_closure0: function _BufferingStreamSubscription_asFuture_closure0(t0, t1) {
+ this.$this = t0;
+ this.result = t1;
+ },
+ _BufferingStreamSubscription_asFuture__closure: function _BufferingStreamSubscription_asFuture__closure(t0, t1, t2) {
+ this.result = t0;
+ this.error = t1;
+ this.stackTrace = t2;
+ },
+ _BufferingStreamSubscription__sendError_sendError: function _BufferingStreamSubscription__sendError_sendError(t0, t1, t2) {
+ this.$this = t0;
+ this.error = t1;
+ this.stackTrace = t2;
+ },
+ _BufferingStreamSubscription__sendDone_sendDone: function _BufferingStreamSubscription__sendDone_sendDone(t0) {
+ this.$this = t0;
+ },
+ _StreamImpl: function _StreamImpl() {
+ },
+ _DelayedEvent: function _DelayedEvent() {
+ },
+ _DelayedData: function _DelayedData(t0, t1) {
+ this.value = t0;
+ this.next = null;
+ this.$ti = t1;
+ },
+ _DelayedError: function _DelayedError(t0, t1) {
+ this.error = t0;
+ this.stackTrace = t1;
+ this.next = null;
+ },
+ _DelayedDone: function _DelayedDone() {
+ },
+ _PendingEvents: function _PendingEvents(t0) {
+ var _ = this;
+ _._state = 0;
+ _.lastPendingEvent = _.firstPendingEvent = null;
+ _.$ti = t0;
+ },
+ _PendingEvents_schedule_closure: function _PendingEvents_schedule_closure(t0, t1) {
+ this.$this = t0;
+ this.dispatch = t1;
+ },
+ _StreamIterator: function _StreamIterator(t0) {
+ this.$ti = t0;
+ },
+ _cancelAndValue_closure: function _cancelAndValue_closure(t0, t1) {
+ this.future = t0;
+ this.value = t1;
+ },
+ _Zone: function _Zone() {
+ },
+ _rootHandleError_closure: function _rootHandleError_closure(t0, t1) {
+ this.error = t0;
+ this.stackTrace = t1;
+ },
+ _RootZone: function _RootZone() {
+ },
+ _RootZone_bindCallbackGuarded_closure: function _RootZone_bindCallbackGuarded_closure(t0, t1) {
+ this.$this = t0;
+ this.f = t1;
+ },
+ _RootZone_bindUnaryCallbackGuarded_closure: function _RootZone_bindUnaryCallbackGuarded_closure(t0, t1, t2) {
+ this.$this = t0;
+ this.f = t1;
+ this.T = t2;
+ },
+ _HashMap__getTableEntry(table, key) {
+ var entry = table[key];
+ return entry === table ? null : entry;
+ },
+ _HashMap__setTableEntry(table, key, value) {
+ if (value == null)
+ table[key] = table;
+ else
+ table[key] = value;
+ },
+ _HashMap__newHashTable() {
+ var table = Object.create(null);
+ A._HashMap__setTableEntry(table, "<non-identifier-key>", table);
+ delete table["<non-identifier-key>"];
+ return table;
+ },
+ LinkedHashMap_LinkedHashMap$_empty($K, $V) {
+ return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>"));
+ },
+ MapBase_mapToString(m) {
+ var result, t1 = {};
+ if (A.isToStringVisiting(m))
+ return "{...}";
+ result = new A.StringBuffer("");
+ try {
+ B.JSArray_methods.add$1($.toStringVisiting, m);
+ result._contents += "{";
+ t1.first = true;
+ m.forEach$1(0, new A.MapBase_mapToString_closure(t1, result));
+ result._contents += "}";
+ } finally {
+ if (0 >= $.toStringVisiting.length)
+ return A.ioore($.toStringVisiting, -1);
+ $.toStringVisiting.pop();
+ }
+ t1 = result._contents;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ ListQueue$($E) {
+ return new A.ListQueue(A.List_List$filled(A.ListQueue__calculateCapacity(null), null, false, $E._eval$1("0?")), $E._eval$1("ListQueue<0>"));
+ },
+ ListQueue__calculateCapacity(initialCapacity) {
+ return 8;
+ },
+ _HashMap: function _HashMap() {
+ },
+ _IdentityHashMap: function _IdentityHashMap(t0) {
+ var _ = this;
+ _._collection$_length = 0;
+ _._collection$_keys = _._collection$_rest = _._collection$_nums = _._collection$_strings = null;
+ _.$ti = t0;
+ },
+ _HashMapKeyIterable: function _HashMapKeyIterable(t0, t1) {
+ this._collection$_map = t0;
+ this.$ti = t1;
+ },
+ _HashMapKeyIterator: function _HashMapKeyIterator(t0, t1, t2) {
+ var _ = this;
+ _._collection$_map = t0;
+ _._collection$_keys = t1;
+ _._offset = 0;
+ _._collection$_current = null;
+ _.$ti = t2;
+ },
+ ListBase: function ListBase() {
+ },
+ MapBase: function MapBase() {
+ },
+ MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) {
+ this._box_0 = t0;
+ this.result = t1;
+ },
+ _UnmodifiableMapMixin: function _UnmodifiableMapMixin() {
+ },
+ MapView: function MapView() {
+ },
+ UnmodifiableMapView: function UnmodifiableMapView() {
+ },
+ ListQueue: function ListQueue(t0, t1) {
+ var _ = this;
+ _._table = t0;
+ _._modificationCount = _._tail = _._head = 0;
+ _.$ti = t1;
+ },
+ _ListQueueIterator: function _ListQueueIterator(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._queue = t0;
+ _._end = t1;
+ _._modificationCount = t2;
+ _._position = t3;
+ _._collection$_current = null;
+ _.$ti = t4;
+ },
+ _UnmodifiableMapView_MapView__UnmodifiableMapMixin: function _UnmodifiableMapView_MapView__UnmodifiableMapMixin() {
+ },
+ _parseJson(source, reviver) {
+ var e, exception, t1, parsed = null;
+ try {
+ parsed = JSON.parse(source);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ t1 = A.FormatException$(String(e), null, null);
+ throw A.wrapException(t1);
+ }
+ t1 = A._convertJsonToDartLazy(parsed);
+ return t1;
+ },
+ _convertJsonToDartLazy(object) {
+ var i;
+ if (object == null)
+ return null;
+ if (typeof object != "object")
+ return object;
+ if (Object.getPrototypeOf(object) !== Array.prototype)
+ return new A._JsonMap(object, Object.create(null));
+ for (i = 0; i < object.length; ++i)
+ object[i] = A._convertJsonToDartLazy(object[i]);
+ return object;
+ },
+ JsonUnsupportedObjectError$(unsupportedObject, cause, partialResult) {
+ return new A.JsonUnsupportedObjectError(unsupportedObject, cause);
+ },
+ _defaultToEncodable(object) {
+ return object.toJson$0();
+ },
+ _JsonStringStringifier$(_sink, _toEncodable) {
+ return new A._JsonStringStringifier(_sink, [], A.convert___defaultToEncodable$closure());
+ },
+ _JsonStringStringifier_stringify(object, toEncodable, indent) {
+ var t1,
+ output = new A.StringBuffer(""),
+ stringifier = A._JsonStringStringifier$(output, toEncodable);
+ stringifier.writeObject$1(object);
+ t1 = output._contents;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ _JsonMap: function _JsonMap(t0, t1) {
+ this._original = t0;
+ this._processed = t1;
+ this._data = null;
+ },
+ _JsonMapKeyIterable: function _JsonMapKeyIterable(t0) {
+ this._parent = t0;
+ },
+ Codec: function Codec() {
+ },
+ Converter: function Converter() {
+ },
+ JsonUnsupportedObjectError: function JsonUnsupportedObjectError(t0, t1) {
+ this.unsupportedObject = t0;
+ this.cause = t1;
+ },
+ JsonCyclicError: function JsonCyclicError(t0, t1) {
+ this.unsupportedObject = t0;
+ this.cause = t1;
+ },
+ JsonCodec: function JsonCodec() {
+ },
+ JsonEncoder: function JsonEncoder(t0) {
+ this._toEncodable = t0;
+ },
+ JsonDecoder: function JsonDecoder(t0) {
+ this._reviver = t0;
+ },
+ _JsonStringifier: function _JsonStringifier() {
+ },
+ _JsonStringifier_writeMap_closure: function _JsonStringifier_writeMap_closure(t0, t1) {
+ this._box_0 = t0;
+ this.keyValueList = t1;
+ },
+ _JsonStringStringifier: function _JsonStringStringifier(t0, t1, t2) {
+ this._sink = t0;
+ this._seen = t1;
+ this._toEncodable = t2;
+ },
+ int_parse(source, radix) {
+ var value = A.Primitives_parseInt(source, radix);
+ if (value != null)
+ return value;
+ throw A.wrapException(A.FormatException$(source, null, null));
+ },
+ Error__throw(error, stackTrace) {
+ error = A.wrapException(error);
+ if (error == null)
+ error = type$.Object._as(error);
+ error.stack = stackTrace.toString$0(0);
+ throw error;
+ throw A.wrapException("unreachable");
+ },
+ List_List$filled($length, fill, growable, $E) {
+ var i,
+ result = growable ? J.JSArray_JSArray$growable($length, $E) : J.JSArray_JSArray$fixed($length, $E);
+ if ($length !== 0 && fill != null)
+ for (i = 0; i < result.length; ++i)
+ result[i] = fill;
+ return result;
+ },
+ List_List$of(elements, growable, $E) {
+ var t1 = A.List_List$_of(elements, $E);
+ return t1;
+ },
+ List_List$_of(elements, $E) {
+ var list, t1;
+ if (Array.isArray(elements))
+ return A._setArrayType(elements.slice(0), $E._eval$1("JSArray<0>"));
+ list = A._setArrayType([], $E._eval$1("JSArray<0>"));
+ for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();)
+ B.JSArray_methods.add$1(list, t1.get$current());
+ return list;
+ },
+ StringBuffer__writeAll(string, objects, separator) {
+ var iterator = J.get$iterator$ax(objects);
+ if (!iterator.moveNext$0())
+ return string;
+ if (separator.length === 0) {
+ do
+ string += A.S(iterator.get$current());
+ while (iterator.moveNext$0());
+ } else {
+ string += A.S(iterator.get$current());
+ for (; iterator.moveNext$0();)
+ string = string + separator + A.S(iterator.get$current());
+ }
+ return string;
+ },
+ NoSuchMethodError_NoSuchMethodError$withInvocation(receiver, invocation) {
+ return new A.NoSuchMethodError(receiver, invocation.get$memberName(), invocation.get$positionalArguments(), invocation.get$namedArguments());
+ },
+ StackTrace_current() {
+ return A.getTraceFromException(new Error());
+ },
+ DateTime__fourDigits(n) {
+ var absN = Math.abs(n),
+ sign = n < 0 ? "-" : "";
+ if (absN >= 1000)
+ return "" + n;
+ if (absN >= 100)
+ return sign + "0" + absN;
+ if (absN >= 10)
+ return sign + "00" + absN;
+ return sign + "000" + absN;
+ },
+ DateTime__threeDigits(n) {
+ if (n >= 100)
+ return "" + n;
+ if (n >= 10)
+ return "0" + n;
+ return "00" + n;
+ },
+ DateTime__twoDigits(n) {
+ if (n >= 10)
+ return "" + n;
+ return "0" + n;
+ },
+ Error_safeToString(object) {
+ if (typeof object == "number" || A._isBool(object) || object == null)
+ return J.toString$0$(object);
+ if (typeof object == "string")
+ return JSON.stringify(object);
+ return A.Primitives_safeToString(object);
+ },
+ Error_throwWithStackTrace(error, stackTrace) {
+ A.checkNotNullable(error, "error", type$.Object);
+ A.checkNotNullable(stackTrace, "stackTrace", type$.StackTrace);
+ A.Error__throw(error, stackTrace);
+ },
+ AssertionError$(message) {
+ return new A.AssertionError(message);
+ },
+ ArgumentError$(message, $name) {
+ return new A.ArgumentError(false, null, $name, message);
+ },
+ ArgumentError$value(value, $name, message) {
+ return new A.ArgumentError(true, value, $name, message);
+ },
+ ArgumentError$notNull($name) {
+ return new A.ArgumentError(false, null, $name, "Must not be null");
+ },
+ RangeError$(message) {
+ var _null = null;
+ return new A.RangeError(_null, _null, false, _null, _null, message);
+ },
+ RangeError$value(value, $name) {
+ return new A.RangeError(null, null, true, value, $name, "Value not in range");
+ },
+ RangeError$range(invalidValue, minValue, maxValue, $name, message) {
+ return new A.RangeError(minValue, maxValue, true, invalidValue, $name, "Invalid value");
+ },
+ RangeError_checkValidRange(start, end, $length) {
+ if (0 > start || start > $length)
+ throw A.wrapException(A.RangeError$range(start, 0, $length, "start", null));
+ if (end != null) {
+ if (start > end || end > $length)
+ throw A.wrapException(A.RangeError$range(end, start, $length, "end", null));
+ return end;
+ }
+ return $length;
+ },
+ RangeError_checkNotNegative(value, $name) {
+ if (value < 0)
+ throw A.wrapException(A.RangeError$range(value, 0, null, $name, null));
+ return value;
+ },
+ IndexError$withLength(invalidValue, $length, indexable, message, $name) {
+ return new A.IndexError($length, true, invalidValue, $name, "Index out of range");
+ },
+ UnsupportedError$(message) {
+ return new A.UnsupportedError(message);
+ },
+ UnimplementedError$(message) {
+ return new A.UnimplementedError(message);
+ },
+ StateError$(message) {
+ return new A.StateError(message);
+ },
+ ConcurrentModificationError$(modifiedObject) {
+ return new A.ConcurrentModificationError(modifiedObject);
+ },
+ FormatException$(message, source, offset) {
+ return new A.FormatException(message, source, offset);
+ },
+ Iterable_iterableToShortString(iterable, leftDelimiter, rightDelimiter) {
+ var parts, t1;
+ if (A.isToStringVisiting(iterable)) {
+ if (leftDelimiter === "(" && rightDelimiter === ")")
+ return "(...)";
+ return leftDelimiter + "..." + rightDelimiter;
+ }
+ parts = A._setArrayType([], type$.JSArray_String);
+ B.JSArray_methods.add$1($.toStringVisiting, iterable);
+ try {
+ A._iterablePartsToStrings(iterable, parts);
+ } finally {
+ if (0 >= $.toStringVisiting.length)
+ return A.ioore($.toStringVisiting, -1);
+ $.toStringVisiting.pop();
+ }
+ t1 = A.StringBuffer__writeAll(leftDelimiter, type$.Iterable_dynamic._as(parts), ", ") + rightDelimiter;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ Iterable_iterableToFullString(iterable, leftDelimiter, rightDelimiter) {
+ var buffer, t1;
+ if (A.isToStringVisiting(iterable))
+ return leftDelimiter + "..." + rightDelimiter;
+ buffer = new A.StringBuffer(leftDelimiter);
+ B.JSArray_methods.add$1($.toStringVisiting, iterable);
+ try {
+ t1 = buffer;
+ t1._contents = A.StringBuffer__writeAll(t1._contents, iterable, ", ");
+ } finally {
+ if (0 >= $.toStringVisiting.length)
+ return A.ioore($.toStringVisiting, -1);
+ $.toStringVisiting.pop();
+ }
+ buffer._contents += rightDelimiter;
+ t1 = buffer._contents;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ _iterablePartsToStrings(iterable, parts) {
+ var next, ultimateString, penultimateString, penultimate, ultimate, ultimate0, elision,
+ it = iterable.get$iterator(iterable),
+ $length = 0, count = 0;
+ while (true) {
+ if (!($length < 80 || count < 3))
+ break;
+ if (!it.moveNext$0())
+ return;
+ next = A.S(it.get$current());
+ B.JSArray_methods.add$1(parts, next);
+ $length += next.length + 2;
+ ++count;
+ }
+ if (!it.moveNext$0()) {
+ if (count <= 5)
+ return;
+ if (0 >= parts.length)
+ return A.ioore(parts, -1);
+ ultimateString = parts.pop();
+ if (0 >= parts.length)
+ return A.ioore(parts, -1);
+ penultimateString = parts.pop();
+ } else {
+ penultimate = it.get$current();
+ ++count;
+ if (!it.moveNext$0()) {
+ if (count <= 4) {
+ B.JSArray_methods.add$1(parts, A.S(penultimate));
+ return;
+ }
+ ultimateString = A.S(penultimate);
+ if (0 >= parts.length)
+ return A.ioore(parts, -1);
+ penultimateString = parts.pop();
+ $length += ultimateString.length + 2;
+ } else {
+ ultimate = it.get$current();
+ ++count;
+ for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) {
+ ultimate0 = it.get$current();
+ ++count;
+ if (count > 100) {
+ while (true) {
+ if (!($length > 75 && count > 3))
+ break;
+ if (0 >= parts.length)
+ return A.ioore(parts, -1);
+ $length -= parts.pop().length + 2;
+ --count;
+ }
+ B.JSArray_methods.add$1(parts, "...");
+ return;
+ }
+ }
+ penultimateString = A.S(penultimate);
+ ultimateString = A.S(ultimate);
+ $length += ultimateString.length + penultimateString.length + 4;
+ }
+ }
+ if (count > parts.length + 2) {
+ $length += 5;
+ elision = "...";
+ } else
+ elision = null;
+ while (true) {
+ if (!($length > 80 && parts.length > 3))
+ break;
+ if (0 >= parts.length)
+ return A.ioore(parts, -1);
+ $length -= parts.pop().length + 2;
+ if (elision == null) {
+ $length += 5;
+ elision = "...";
+ }
+ }
+ if (elision != null)
+ B.JSArray_methods.add$1(parts, elision);
+ B.JSArray_methods.add$1(parts, penultimateString);
+ B.JSArray_methods.add$1(parts, ultimateString);
+ },
+ NoSuchMethodError_toString_closure: function NoSuchMethodError_toString_closure(t0, t1) {
+ this._box_0 = t0;
+ this.sb = t1;
+ },
+ DateTime: function DateTime(t0, t1) {
+ this._value = t0;
+ this.isUtc = t1;
+ },
+ Duration: function Duration(t0) {
+ this._duration = t0;
+ },
+ Error: function Error() {
+ },
+ AssertionError: function AssertionError(t0) {
+ this.message = t0;
+ },
+ TypeError: function TypeError() {
+ },
+ ArgumentError: function ArgumentError(t0, t1, t2, t3) {
+ var _ = this;
+ _._hasValue = t0;
+ _.invalidValue = t1;
+ _.name = t2;
+ _.message = t3;
+ },
+ RangeError: function RangeError(t0, t1, t2, t3, t4, t5) {
+ var _ = this;
+ _.start = t0;
+ _.end = t1;
+ _._hasValue = t2;
+ _.invalidValue = t3;
+ _.name = t4;
+ _.message = t5;
+ },
+ IndexError: function IndexError(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _.length = t0;
+ _._hasValue = t1;
+ _.invalidValue = t2;
+ _.name = t3;
+ _.message = t4;
+ },
+ NoSuchMethodError: function NoSuchMethodError(t0, t1, t2, t3) {
+ var _ = this;
+ _._core$_receiver = t0;
+ _._core$_memberName = t1;
+ _._core$_arguments = t2;
+ _._namedArguments = t3;
+ },
+ UnsupportedError: function UnsupportedError(t0) {
+ this.message = t0;
+ },
+ UnimplementedError: function UnimplementedError(t0) {
+ this.message = t0;
+ },
+ StateError: function StateError(t0) {
+ this.message = t0;
+ },
+ ConcurrentModificationError: function ConcurrentModificationError(t0) {
+ this.modifiedObject = t0;
+ },
+ OutOfMemoryError: function OutOfMemoryError() {
+ },
+ StackOverflowError: function StackOverflowError() {
+ },
+ _Exception: function _Exception(t0) {
+ this.message = t0;
+ },
+ FormatException: function FormatException(t0, t1, t2) {
+ this.message = t0;
+ this.source = t1;
+ this.offset = t2;
+ },
+ Iterable: function Iterable() {
+ },
+ Null: function Null() {
+ },
+ Object: function Object() {
+ },
+ _StringStackTrace: function _StringStackTrace(t0) {
+ this._stackTrace = t0;
+ },
+ StringBuffer: function StringBuffer(t0) {
+ this._contents = t0;
+ },
+ _convertDartFunctionFast(f) {
+ var ret,
+ existing = f.$dart_jsFunction;
+ if (existing != null)
+ return existing;
+ ret = function(_call, f) {
+ return function() {
+ return _call(f, Array.prototype.slice.apply(arguments));
+ };
+ }(A._callDartFunctionFast, f);
+ ret[$.$get$DART_CLOSURE_PROPERTY_NAME()] = f;
+ f.$dart_jsFunction = ret;
+ return ret;
+ },
+ _callDartFunctionFast(callback, $arguments) {
+ type$.List_dynamic._as($arguments);
+ type$.Function._as(callback);
+ return A.Primitives_applyFunction(callback, $arguments, null);
+ },
+ allowInterop(f, $F) {
+ if (typeof f == "function")
+ return f;
+ else
+ return $F._as(A._convertDartFunctionFast(f));
+ },
+ promiseToFuture(jsPromise, $T) {
+ var t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")),
+ completer = new A._AsyncCompleter(t1, $T._eval$1("_AsyncCompleter<0>"));
+ jsPromise.then(A.convertDartClosureToJS(new A.promiseToFuture_closure(completer, $T), 1), A.convertDartClosureToJS(new A.promiseToFuture_closure0(completer), 1));
+ return t1;
+ },
+ _noDartifyRequired(o) {
+ return o == null || typeof o === "boolean" || typeof o === "number" || typeof o === "string" || o instanceof Int8Array || o instanceof Uint8Array || o instanceof Uint8ClampedArray || o instanceof Int16Array || o instanceof Uint16Array || o instanceof Int32Array || o instanceof Uint32Array || o instanceof Float32Array || o instanceof Float64Array || o instanceof ArrayBuffer || o instanceof DataView;
+ },
+ dartify(o) {
+ if (A._noDartifyRequired(o))
+ return o;
+ return new A.dartify_convert(new A._IdentityHashMap(type$._IdentityHashMap_of_nullable_Object_and_nullable_Object)).call$1(o);
+ },
+ promiseToFuture_closure: function promiseToFuture_closure(t0, t1) {
+ this.completer = t0;
+ this.T = t1;
+ },
+ promiseToFuture_closure0: function promiseToFuture_closure0(t0) {
+ this.completer = t0;
+ },
+ dartify_convert: function dartify_convert(t0) {
+ this._convertedObjects = t0;
+ },
+ NullRejectionException: function NullRejectionException(t0) {
+ this.isUndefined = t0;
+ },
+ _JSRandom: function _JSRandom() {
+ },
+ AsyncMemoizer: function AsyncMemoizer(t0, t1) {
+ this._completer = t0;
+ this.$ti = t1;
+ },
+ Level: function Level(t0, t1) {
+ this.name = t0;
+ this.value = t1;
+ },
+ LogRecord: function LogRecord(t0, t1, t2) {
+ this.level = t0;
+ this.message = t1;
+ this.loggerName = t2;
+ },
+ Logger_Logger($name) {
+ return $.Logger__loggers.putIfAbsent$2($name, new A.Logger_Logger_closure($name));
+ },
+ Logger: function Logger(t0, t1, t2) {
+ var _ = this;
+ _.name = t0;
+ _.parent = t1;
+ _._level = null;
+ _._children = t2;
+ },
+ Logger_Logger_closure: function Logger_Logger_closure(t0) {
+ this.name = t0;
+ },
+ Pool: function Pool(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._requestedResources = t0;
+ _._onReleaseCallbacks = t1;
+ _._onReleaseCompleters = t2;
+ _._maxAllocatedResources = t3;
+ _._allocatedResources = 0;
+ _._timer = null;
+ _._closeMemo = t4;
+ },
+ Pool__runOnRelease_closure: function Pool__runOnRelease_closure(t0) {
+ this.$this = t0;
+ },
+ Pool__runOnRelease_closure0: function Pool__runOnRelease_closure0(t0) {
+ this.$this = t0;
+ },
+ PoolResource: function PoolResource(t0) {
+ this._pool = t0;
+ this._released = false;
+ },
+ SseClient$(serverUrl) {
+ var t3, t4, t5,
+ t1 = type$.String,
+ t2 = A.StreamController_StreamController(t1);
+ t1 = A.StreamController_StreamController(t1);
+ t3 = A.Logger_Logger("SseClient");
+ t4 = $.Zone__current;
+ t5 = A.generateUuidV4();
+ t1 = new A.SseClient(t5, t2, t1, t3, new A._AsyncCompleter(new A._Future(t4, type$._Future_void), type$._AsyncCompleter_void));
+ t1.SseClient$2$debugKey(serverUrl, null);
+ return t1;
+ },
+ SseClient: function SseClient(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._clientId = t0;
+ _._incomingController = t1;
+ _._outgoingController = t2;
+ _._logger = t3;
+ _._onConnected = t4;
+ _._lastMessageId = -1;
+ _.__SseClient__serverUrl_A = _.__SseClient__eventSource_A = $;
+ _._errorTimer = null;
+ },
+ SseClient_closure: function SseClient_closure(t0) {
+ this.$this = t0;
+ },
+ SseClient_closure0: function SseClient_closure0(t0) {
+ this.$this = t0;
+ },
+ SseClient_closure1: function SseClient_closure1(t0) {
+ this.$this = t0;
+ },
+ SseClient__closure: function SseClient__closure(t0, t1) {
+ this.$this = t0;
+ this.error = t1;
+ },
+ SseClient__onOutgoingMessage_closure: function SseClient__onOutgoingMessage_closure(t0, t1, t2) {
+ this._box_0 = t0;
+ this.$this = t1;
+ this.message = t2;
+ },
+ generateUuidV4() {
+ var t1 = new A.generateUuidV4_printDigits(),
+ t2 = new A.generateUuidV4_bitsDigits(t1, new A.generateUuidV4_generateBits(B.C__JSRandom)),
+ t3 = B.C__JSRandom.nextInt$1(4);
+ return A.S(t2.call$2(16, 4)) + A.S(t2.call$2(16, 4)) + "-" + A.S(t2.call$2(16, 4)) + "-4" + A.S(t2.call$2(12, 3)) + "-" + A.S(t1.call$2(8 + t3, 1)) + A.S(t2.call$2(12, 3)) + "-" + A.S(t2.call$2(16, 4)) + A.S(t2.call$2(16, 4)) + A.S(t2.call$2(16, 4));
+ },
+ generateUuidV4_generateBits: function generateUuidV4_generateBits(t0) {
+ this.random = t0;
+ },
+ generateUuidV4_printDigits: function generateUuidV4_printDigits() {
+ },
+ generateUuidV4_bitsDigits: function generateUuidV4_bitsDigits(t0, t1) {
+ this.printDigits = t0;
+ this.generateBits = t1;
+ },
+ StreamChannelMixin: function StreamChannelMixin() {
+ },
+ _EventStreamSubscription$(_target, _eventType, onData, _useCapture, $T) {
+ var t1;
+ if (onData == null)
+ t1 = null;
+ else {
+ t1 = A._wrapZone(new A._EventStreamSubscription_closure(onData), type$.JSObject);
+ t1 = t1 == null ? null : type$.JavaScriptFunction._as(A.allowInterop(t1, type$.Function));
+ }
+ t1 = new A._EventStreamSubscription(_target, _eventType, t1, false, $T._eval$1("_EventStreamSubscription<0>"));
+ t1._tryResume$0();
+ return t1;
+ },
+ _wrapZone(callback, $T) {
+ var t1 = $.Zone__current;
+ if (t1 === B.C__RootZone)
+ return callback;
+ return t1.bindUnaryCallbackGuarded$1$1(callback, $T);
+ },
+ EventStreamProvider: function EventStreamProvider(t0, t1) {
+ this._eventType = t0;
+ this.$ti = t1;
+ },
+ _EventStream: function _EventStream(t0, t1, t2, t3) {
+ var _ = this;
+ _._target = t0;
+ _._eventType = t1;
+ _._useCapture = t2;
+ _.$ti = t3;
+ },
+ _ElementEventStreamImpl: function _ElementEventStreamImpl(t0, t1, t2, t3) {
+ var _ = this;
+ _._target = t0;
+ _._eventType = t1;
+ _._useCapture = t2;
+ _.$ti = t3;
+ },
+ _EventStreamSubscription: function _EventStreamSubscription(t0, t1, t2, t3, t4) {
+ var _ = this;
+ _._target = t0;
+ _._eventType = t1;
+ _._streams$_onData = t2;
+ _._useCapture = t3;
+ _.$ti = t4;
+ },
+ _EventStreamSubscription_closure: function _EventStreamSubscription_closure(t0) {
+ this.onData = t0;
+ },
+ _EventStreamSubscription_onData_closure: function _EventStreamSubscription_onData_closure(t0) {
+ this.handleData = t0;
+ },
+ main() {
+ var t2,
+ channel = A.SseClient$("/test"),
+ t1 = type$.nullable_JSObject._as(type$.JSObject._as(self.document).querySelector("button"));
+ t1.toString;
+ t2 = type$._ElementEventStreamImpl_JSObject;
+ A._EventStreamSubscription$(t1, "click", t2._eval$1("~(1)?")._as(new A.main_closure(channel)), false, t2._precomputed1);
+ t2 = channel._incomingController;
+ new A._ControllerStream(t2, A._instanceType(t2)._eval$1("_ControllerStream<1>")).listen$1(new A.main_closure0(channel));
+ },
+ main_closure: function main_closure(t0) {
+ this.channel = t0;
+ },
+ main_closure0: function main_closure0(t0) {
+ this.channel = t0;
+ },
+ throwLateFieldNI(fieldName) {
+ A.throwExpressionWithWrapper(new A.LateError("Field '" + fieldName + "' has not been initialized."), new Error());
+ },
+ throwLateFieldADI(fieldName) {
+ A.throwExpressionWithWrapper(new A.LateError("Field '" + fieldName + "' has been assigned during initialization."), new Error());
+ }
+ },
+ B = {};
+ var holders = [A, J, B];
+ var $ = {};
+ A.JS_CONST.prototype = {};
+ J.Interceptor.prototype = {
+ $eq(receiver, other) {
+ return receiver === other;
+ },
+ get$hashCode(receiver) {
+ return A.Primitives_objectHashCode(receiver);
+ },
+ toString$0(receiver) {
+ return "Instance of '" + A.Primitives_objectTypeName(receiver) + "'";
+ },
+ noSuchMethod$1(receiver, invocation) {
+ throw A.wrapException(A.NoSuchMethodError_NoSuchMethodError$withInvocation(receiver, type$.Invocation._as(invocation)));
+ },
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(A._instanceTypeFromConstructor(this));
+ }
+ };
+ J.JSBool.prototype = {
+ toString$0(receiver) {
+ return String(receiver);
+ },
+ get$hashCode(receiver) {
+ return receiver ? 519018 : 218159;
+ },
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(type$.bool);
+ },
+ $isTrustedGetRuntimeType: 1,
+ $isbool: 1
+ };
+ J.JSNull.prototype = {
+ $eq(receiver, other) {
+ return null == other;
+ },
+ toString$0(receiver) {
+ return "null";
+ },
+ get$hashCode(receiver) {
+ return 0;
+ },
+ $isTrustedGetRuntimeType: 1,
+ $isNull: 1
+ };
+ J.JavaScriptObject.prototype = {$isJSObject: 1};
+ J.LegacyJavaScriptObject.prototype = {
+ get$hashCode(receiver) {
+ return 0;
+ },
+ toString$0(receiver) {
+ return String(receiver);
+ }
+ };
+ J.PlainJavaScriptObject.prototype = {};
+ J.UnknownJavaScriptObject.prototype = {};
+ J.JavaScriptFunction.prototype = {
+ toString$0(receiver) {
+ var dartClosure = receiver[$.$get$DART_CLOSURE_PROPERTY_NAME()];
+ if (dartClosure == null)
+ return this.super$LegacyJavaScriptObject$toString(receiver);
+ return "JavaScript function for " + J.toString$0$(dartClosure);
+ },
+ $isFunction: 1
+ };
+ J.JavaScriptBigInt.prototype = {
+ get$hashCode(receiver) {
+ return 0;
+ },
+ toString$0(receiver) {
+ return String(receiver);
+ }
+ };
+ J.JavaScriptSymbol.prototype = {
+ get$hashCode(receiver) {
+ return 0;
+ },
+ toString$0(receiver) {
+ return String(receiver);
+ }
+ };
+ J.JSArray.prototype = {
+ add$1(receiver, value) {
+ A._arrayInstanceType(receiver)._precomputed1._as(value);
+ if (!!receiver.fixed$length)
+ A.throwExpression(A.UnsupportedError$("add"));
+ receiver.push(value);
+ },
+ addAll$1(receiver, collection) {
+ var t1;
+ A._arrayInstanceType(receiver)._eval$1("Iterable<1>")._as(collection);
+ if (!!receiver.fixed$length)
+ A.throwExpression(A.UnsupportedError$("addAll"));
+ if (Array.isArray(collection)) {
+ this._addAllFromArray$1(receiver, collection);
+ return;
+ }
+ for (t1 = J.get$iterator$ax(collection); t1.moveNext$0();)
+ receiver.push(t1.get$current());
+ },
+ _addAllFromArray$1(receiver, array) {
+ var len, i;
+ type$.JSArray_dynamic._as(array);
+ len = array.length;
+ if (len === 0)
+ return;
+ if (receiver === array)
+ throw A.wrapException(A.ConcurrentModificationError$(receiver));
+ for (i = 0; i < len; ++i)
+ receiver.push(array[i]);
+ },
+ get$last(receiver) {
+ var t1 = receiver.length;
+ if (t1 > 0)
+ return receiver[t1 - 1];
+ throw A.wrapException(A.IterableElementError_noElement());
+ },
+ setRange$4(receiver, start, end, iterable, skipCount) {
+ var $length, otherList, t1, i;
+ A._arrayInstanceType(receiver)._eval$1("Iterable<1>")._as(iterable);
+ if (!!receiver.immutable$list)
+ A.throwExpression(A.UnsupportedError$("setRange"));
+ A.RangeError_checkValidRange(start, end, receiver.length);
+ $length = end - start;
+ if ($length === 0)
+ return;
+ A.RangeError_checkNotNegative(skipCount, "skipCount");
+ otherList = iterable;
+ t1 = J.getInterceptor$asx(otherList);
+ if (skipCount + $length > t1.get$length(otherList))
+ throw A.wrapException(A.IterableElementError_tooFew());
+ if (skipCount < start)
+ for (i = $length - 1; i >= 0; --i)
+ receiver[start + i] = t1.$index(otherList, skipCount + i);
+ else
+ for (i = 0; i < $length; ++i)
+ receiver[start + i] = t1.$index(otherList, skipCount + i);
+ },
+ get$isNotEmpty(receiver) {
+ return receiver.length !== 0;
+ },
+ toString$0(receiver) {
+ return A.Iterable_iterableToFullString(receiver, "[", "]");
+ },
+ get$iterator(receiver) {
+ return new J.ArrayIterator(receiver, receiver.length, A._arrayInstanceType(receiver)._eval$1("ArrayIterator<1>"));
+ },
+ get$hashCode(receiver) {
+ return A.Primitives_objectHashCode(receiver);
+ },
+ get$length(receiver) {
+ return receiver.length;
+ },
+ $index(receiver, index) {
+ if (!(index >= 0 && index < receiver.length))
+ throw A.wrapException(A.diagnoseIndexError(receiver, index));
+ return receiver[index];
+ },
+ $indexSet(receiver, index, value) {
+ A._arrayInstanceType(receiver)._precomputed1._as(value);
+ if (!!receiver.immutable$list)
+ A.throwExpression(A.UnsupportedError$("indexed set"));
+ if (!(index >= 0 && index < receiver.length))
+ throw A.wrapException(A.diagnoseIndexError(receiver, index));
+ receiver[index] = value;
+ },
+ $isIterable: 1,
+ $isList: 1
+ };
+ J.JSUnmodifiableArray.prototype = {};
+ J.ArrayIterator.prototype = {
+ get$current() {
+ var t1 = this._current;
+ return t1 == null ? this.$ti._precomputed1._as(t1) : t1;
+ },
+ moveNext$0() {
+ var t2, _this = this,
+ t1 = _this._iterable,
+ $length = t1.length;
+ if (_this._length !== $length) {
+ t1 = A.throwConcurrentModificationError(t1);
+ throw A.wrapException(t1);
+ }
+ t2 = _this._index;
+ if (t2 >= $length) {
+ _this.set$_current(null);
+ return false;
+ }
+ _this.set$_current(t1[t2]);
+ ++_this._index;
+ return true;
+ },
+ set$_current(_current) {
+ this._current = this.$ti._eval$1("1?")._as(_current);
+ }
+ };
+ J.JSNumber.prototype = {
+ toRadixString$1(receiver, radix) {
+ var result, t1, t2, match, exponent;
+ if (radix < 2 || radix > 36)
+ throw A.wrapException(A.RangeError$range(radix, 2, 36, "radix", null));
+ result = receiver.toString(radix);
+ t1 = result.length;
+ t2 = t1 - 1;
+ if (!(t2 >= 0))
+ return A.ioore(result, t2);
+ if (result.charCodeAt(t2) !== 41)
+ return result;
+ match = /^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(result);
+ if (match == null)
+ A.throwExpression(A.UnsupportedError$("Unexpected toString result: " + result));
+ t1 = match.length;
+ if (1 >= t1)
+ return A.ioore(match, 1);
+ result = match[1];
+ if (3 >= t1)
+ return A.ioore(match, 3);
+ exponent = +match[3];
+ t1 = match[2];
+ if (t1 != null) {
+ result += t1;
+ exponent -= t1.length;
+ }
+ return result + B.JSString_methods.$mul("0", exponent);
+ },
+ toString$0(receiver) {
+ if (receiver === 0 && 1 / receiver < 0)
+ return "-0.0";
+ else
+ return "" + receiver;
+ },
+ get$hashCode(receiver) {
+ var absolute, floorLog2, factor, scaled,
+ intValue = receiver | 0;
+ if (receiver === intValue)
+ return intValue & 536870911;
+ absolute = Math.abs(receiver);
+ floorLog2 = Math.log(absolute) / 0.6931471805599453 | 0;
+ factor = Math.pow(2, floorLog2);
+ scaled = absolute < 1 ? absolute / factor : factor / absolute;
+ return ((scaled * 9007199254740992 | 0) + (scaled * 3542243181176521 | 0)) * 599197 + floorLog2 * 1259 & 536870911;
+ },
+ _tdivFast$1(receiver, other) {
+ return (receiver | 0) === receiver ? receiver / other | 0 : this._tdivSlow$1(receiver, other);
+ },
+ _tdivSlow$1(receiver, other) {
+ var quotient = receiver / other;
+ if (quotient >= -2147483648 && quotient <= 2147483647)
+ return quotient | 0;
+ if (quotient > 0) {
+ if (quotient !== 1 / 0)
+ return Math.floor(quotient);
+ } else if (quotient > -1 / 0)
+ return Math.ceil(quotient);
+ throw A.wrapException(A.UnsupportedError$("Result of truncating division is " + A.S(quotient) + ": " + A.S(receiver) + " ~/ " + other));
+ },
+ _shlPositive$1(receiver, other) {
+ return other > 31 ? 0 : receiver << other >>> 0;
+ },
+ _shrOtherPositive$1(receiver, other) {
+ var t1;
+ if (receiver > 0)
+ t1 = this._shrBothPositive$1(receiver, other);
+ else {
+ t1 = other > 31 ? 31 : other;
+ t1 = receiver >> t1 >>> 0;
+ }
+ return t1;
+ },
+ _shrBothPositive$1(receiver, other) {
+ return other > 31 ? 0 : receiver >>> other;
+ },
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(type$.num);
+ },
+ $isdouble: 1,
+ $isnum: 1
+ };
+ J.JSInt.prototype = {
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(type$.int);
+ },
+ $isTrustedGetRuntimeType: 1,
+ $isint: 1
+ };
+ J.JSNumNotInt.prototype = {
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(type$.double);
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ J.JSString.prototype = {
+ matchAsPrefix$2(receiver, string, start) {
+ var t1, t2, i, t3, _null = null;
+ if (start < 0 || start > string.length)
+ throw A.wrapException(A.RangeError$range(start, 0, string.length, _null, _null));
+ t1 = receiver.length;
+ t2 = string.length;
+ if (start + t1 > t2)
+ return _null;
+ for (i = 0; i < t1; ++i) {
+ t3 = start + i;
+ if (!(t3 >= 0 && t3 < t2))
+ return A.ioore(string, t3);
+ if (string.charCodeAt(t3) !== receiver.charCodeAt(i))
+ return _null;
+ }
+ return new A.StringMatch(start, receiver);
+ },
+ $add(receiver, other) {
+ return receiver + other;
+ },
+ endsWith$1(receiver, other) {
+ var otherLength = other.length,
+ t1 = receiver.length;
+ if (otherLength > t1)
+ return false;
+ return other === this.substring$1(receiver, t1 - otherLength);
+ },
+ startsWith$2(receiver, pattern, index) {
+ var endIndex;
+ if (index < 0 || index > receiver.length)
+ throw A.wrapException(A.RangeError$range(index, 0, receiver.length, null, null));
+ if (typeof pattern == "string") {
+ endIndex = index + pattern.length;
+ if (endIndex > receiver.length)
+ return false;
+ return pattern === receiver.substring(index, endIndex);
+ }
+ return J.matchAsPrefix$2$s(pattern, receiver, index) != null;
+ },
+ startsWith$1(receiver, pattern) {
+ return this.startsWith$2(receiver, pattern, 0);
+ },
+ substring$2(receiver, start, end) {
+ return receiver.substring(start, A.RangeError_checkValidRange(start, end, receiver.length));
+ },
+ substring$1(receiver, start) {
+ return this.substring$2(receiver, start, null);
+ },
+ $mul(receiver, times) {
+ var s, result;
+ if (0 >= times)
+ return "";
+ if (times === 1 || receiver.length === 0)
+ return receiver;
+ if (times !== times >>> 0)
+ throw A.wrapException(B.C_OutOfMemoryError);
+ for (s = receiver, result = ""; true;) {
+ if ((times & 1) === 1)
+ result = s + result;
+ times = times >>> 1;
+ if (times === 0)
+ break;
+ s += s;
+ }
+ return result;
+ },
+ padLeft$2(receiver, width, padding) {
+ var delta = width - receiver.length;
+ if (delta <= 0)
+ return receiver;
+ return this.$mul(padding, delta) + receiver;
+ },
+ lastIndexOf$2(receiver, pattern, start) {
+ var t1, t2;
+ if (start == null)
+ start = receiver.length;
+ else if (start < 0 || start > receiver.length)
+ throw A.wrapException(A.RangeError$range(start, 0, receiver.length, null, null));
+ t1 = pattern.length;
+ t2 = receiver.length;
+ if (start + t1 > t2)
+ start = t2 - t1;
+ return receiver.lastIndexOf(pattern, start);
+ },
+ lastIndexOf$1(receiver, pattern) {
+ return this.lastIndexOf$2(receiver, pattern, null);
+ },
+ toString$0(receiver) {
+ return receiver;
+ },
+ get$hashCode(receiver) {
+ var t1, hash, i;
+ for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) {
+ hash = hash + receiver.charCodeAt(i) & 536870911;
+ hash = hash + ((hash & 524287) << 10) & 536870911;
+ hash ^= hash >> 6;
+ }
+ hash = hash + ((hash & 67108863) << 3) & 536870911;
+ hash ^= hash >> 11;
+ return hash + ((hash & 16383) << 15) & 536870911;
+ },
+ get$runtimeType(receiver) {
+ return A.createRuntimeType(type$.String);
+ },
+ get$length(receiver) {
+ return receiver.length;
+ },
+ $isTrustedGetRuntimeType: 1,
+ $isPattern: 1,
+ $isString: 1
+ };
+ A.LateError.prototype = {
+ toString$0(_) {
+ return "LateInitializationError: " + this._message;
+ }
+ };
+ A.nullFuture_closure.prototype = {
+ call$0() {
+ return A.Future_Future$value(null, type$.Null);
+ },
+ $signature: 7
+ };
+ A.EfficientLengthIterable.prototype = {};
+ A.ListIterable.prototype = {
+ get$iterator(_) {
+ var _this = this;
+ return new A.ListIterator(_this, _this.get$length(_this), A._instanceType(_this)._eval$1("ListIterator<ListIterable.E>"));
+ },
+ get$isEmpty(_) {
+ return this.get$length(this) === 0;
+ }
+ };
+ A.ListIterator.prototype = {
+ get$current() {
+ var t1 = this.__internal$_current;
+ return t1 == null ? this.$ti._precomputed1._as(t1) : t1;
+ },
+ moveNext$0() {
+ var t3, _this = this,
+ t1 = _this.__internal$_iterable,
+ t2 = J.getInterceptor$asx(t1),
+ $length = t2.get$length(t1);
+ if (_this.__internal$_length !== $length)
+ throw A.wrapException(A.ConcurrentModificationError$(t1));
+ t3 = _this.__internal$_index;
+ if (t3 >= $length) {
+ _this.set$__internal$_current(null);
+ return false;
+ }
+ _this.set$__internal$_current(t2.elementAt$1(t1, t3));
+ ++_this.__internal$_index;
+ return true;
+ },
+ set$__internal$_current(_current) {
+ this.__internal$_current = this.$ti._eval$1("1?")._as(_current);
+ }
+ };
+ A.FixedLengthListMixin.prototype = {};
+ A.Symbol.prototype = {
+ get$hashCode(_) {
+ var hash = this._hashCode;
+ if (hash != null)
+ return hash;
+ hash = 664597 * B.JSString_methods.get$hashCode(this._name) & 536870911;
+ this._hashCode = hash;
+ return hash;
+ },
+ toString$0(_) {
+ return 'Symbol("' + this._name + '")';
+ },
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ return other instanceof A.Symbol && this._name === other._name;
+ },
+ $isSymbol0: 1
+ };
+ A.ConstantMapView.prototype = {};
+ A.ConstantMap.prototype = {
+ get$isEmpty(_) {
+ return this.get$length(this) === 0;
+ },
+ toString$0(_) {
+ return A.MapBase_mapToString(this);
+ },
+ $isMap: 1
+ };
+ A.ConstantStringMap.prototype = {
+ get$length(_) {
+ return this._values.length;
+ },
+ get$_keys() {
+ var keys = this.$keys;
+ if (keys == null) {
+ keys = Object.keys(this._jsIndex);
+ this.$keys = keys;
+ }
+ return keys;
+ },
+ forEach$1(_, f) {
+ var keys, values, t1, i;
+ this.$ti._eval$1("~(1,2)")._as(f);
+ keys = this.get$_keys();
+ values = this._values;
+ for (t1 = keys.length, i = 0; i < t1; ++i)
+ f.call$2(keys[i], values[i]);
+ }
+ };
+ A.JSInvocationMirror.prototype = {
+ get$memberName() {
+ var t1 = this._memberName;
+ if (t1 instanceof A.Symbol)
+ return t1;
+ return this._memberName = new A.Symbol(A._asString(t1));
+ },
+ get$positionalArguments() {
+ var t1, t2, argumentCount, list, index, _this = this;
+ if (_this.__js_helper$_kind === 1)
+ return B.List_empty;
+ t1 = _this._arguments;
+ t2 = J.getInterceptor$asx(t1);
+ argumentCount = t2.get$length(t1) - J.get$length$asx(_this._namedArgumentNames) - _this._typeArgumentCount;
+ if (argumentCount === 0)
+ return B.List_empty;
+ list = [];
+ for (index = 0; index < argumentCount; ++index)
+ list.push(t2.$index(t1, index));
+ return J.JSArray_markUnmodifiableList(list);
+ },
+ get$namedArguments() {
+ var t1, t2, namedArgumentCount, t3, t4, namedArgumentsStartIndex, map, i, _this = this;
+ if (_this.__js_helper$_kind !== 0)
+ return B.Map_empty;
+ t1 = _this._namedArgumentNames;
+ t2 = J.getInterceptor$asx(t1);
+ namedArgumentCount = t2.get$length(t1);
+ t3 = _this._arguments;
+ t4 = J.getInterceptor$asx(t3);
+ namedArgumentsStartIndex = t4.get$length(t3) - namedArgumentCount - _this._typeArgumentCount;
+ if (namedArgumentCount === 0)
+ return B.Map_empty;
+ map = new A.JsLinkedHashMap(type$.JsLinkedHashMap_Symbol_dynamic);
+ for (i = 0; i < namedArgumentCount; ++i)
+ map.$indexSet(0, new A.Symbol(A._asString(t2.$index(t1, i))), t4.$index(t3, namedArgumentsStartIndex + i));
+ return new A.ConstantMapView(map, type$.ConstantMapView_Symbol_dynamic);
+ },
+ $isInvocation: 1
+ };
+ A.Primitives_functionNoSuchMethod_closure.prototype = {
+ call$2($name, argument) {
+ var t1;
+ A._asString($name);
+ t1 = this._box_0;
+ t1.names = t1.names + "$" + $name;
+ B.JSArray_methods.add$1(this.namedArgumentList, $name);
+ B.JSArray_methods.add$1(this.$arguments, argument);
+ ++t1.argumentCount;
+ },
+ $signature: 12
+ };
+ A.TypeErrorDecoder.prototype = {
+ matchTypeError$1(message) {
+ var result, t1, _this = this,
+ match = new RegExp(_this._pattern).exec(message);
+ if (match == null)
+ return null;
+ result = Object.create(null);
+ t1 = _this._arguments;
+ if (t1 !== -1)
+ result.arguments = match[t1 + 1];
+ t1 = _this._argumentsExpr;
+ if (t1 !== -1)
+ result.argumentsExpr = match[t1 + 1];
+ t1 = _this._expr;
+ if (t1 !== -1)
+ result.expr = match[t1 + 1];
+ t1 = _this._method;
+ if (t1 !== -1)
+ result.method = match[t1 + 1];
+ t1 = _this._receiver;
+ if (t1 !== -1)
+ result.receiver = match[t1 + 1];
+ return result;
+ }
+ };
+ A.NullError.prototype = {
+ toString$0(_) {
+ return "Null check operator used on a null value";
+ }
+ };
+ A.JsNoSuchMethodError.prototype = {
+ toString$0(_) {
+ var t2, _this = this,
+ _s38_ = "NoSuchMethodError: method not found: '",
+ t1 = _this._method;
+ if (t1 == null)
+ return "NoSuchMethodError: " + _this.__js_helper$_message;
+ t2 = _this._receiver;
+ if (t2 == null)
+ return _s38_ + t1 + "' (" + _this.__js_helper$_message + ")";
+ return _s38_ + t1 + "' on '" + t2 + "' (" + _this.__js_helper$_message + ")";
+ }
+ };
+ A.UnknownJsTypeError.prototype = {
+ toString$0(_) {
+ var t1 = this.__js_helper$_message;
+ return t1.length === 0 ? "Error" : "Error: " + t1;
+ }
+ };
+ A.NullThrownFromJavaScriptException.prototype = {
+ toString$0(_) {
+ return "Throw of null ('" + (this._irritant === null ? "null" : "undefined") + "' from JavaScript)";
+ }
+ };
+ A.ExceptionAndStackTrace.prototype = {};
+ A._StackTrace.prototype = {
+ toString$0(_) {
+ var trace,
+ t1 = this._trace;
+ if (t1 != null)
+ return t1;
+ t1 = this._exception;
+ trace = t1 !== null && typeof t1 === "object" ? t1.stack : null;
+ return this._trace = trace == null ? "" : trace;
+ },
+ $isStackTrace: 1
+ };
+ A.Closure.prototype = {
+ toString$0(_) {
+ var $constructor = this.constructor,
+ $name = $constructor == null ? null : $constructor.name;
+ return "Closure '" + A.unminifyOrTag($name == null ? "unknown" : $name) + "'";
+ },
+ $isFunction: 1,
+ get$$call() {
+ return this;
+ },
+ "call*": "call$1",
+ $requiredArgCount: 1,
+ $defaultValues: null
+ };
+ A.Closure0Args.prototype = {"call*": "call$0", $requiredArgCount: 0};
+ A.Closure2Args.prototype = {"call*": "call$2", $requiredArgCount: 2};
+ A.TearOffClosure.prototype = {};
+ A.StaticClosure.prototype = {
+ toString$0(_) {
+ var $name = this.$static_name;
+ if ($name == null)
+ return "Closure of unknown static method";
+ return "Closure '" + A.unminifyOrTag($name) + "'";
+ }
+ };
+ A.BoundClosure.prototype = {
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ if (this === other)
+ return true;
+ if (!(other instanceof A.BoundClosure))
+ return false;
+ return this.$_target === other.$_target && this._receiver === other._receiver;
+ },
+ get$hashCode(_) {
+ return (A.objectHashCode(this._receiver) ^ A.Primitives_objectHashCode(this.$_target)) >>> 0;
+ },
+ toString$0(_) {
+ return "Closure '" + this.$_name + "' of " + ("Instance of '" + A.Primitives_objectTypeName(this._receiver) + "'");
+ }
+ };
+ A._CyclicInitializationError.prototype = {
+ toString$0(_) {
+ return "Reading static variable '" + this.variableName + "' during its initialization";
+ }
+ };
+ A.RuntimeError.prototype = {
+ toString$0(_) {
+ return "RuntimeError: " + this.message;
+ }
+ };
+ A._Required.prototype = {};
+ A.JsLinkedHashMap.prototype = {
+ get$length(_) {
+ return this.__js_helper$_length;
+ },
+ get$isEmpty(_) {
+ return this.__js_helper$_length === 0;
+ },
+ get$keys() {
+ return new A.LinkedHashMapKeyIterable(this, A._instanceType(this)._eval$1("LinkedHashMapKeyIterable<1>"));
+ },
+ containsKey$1(key) {
+ var strings = this._strings;
+ if (strings == null)
+ return false;
+ return strings[key] != null;
+ },
+ $index(_, key) {
+ var strings, cell, t1, nums, _null = null;
+ if (typeof key == "string") {
+ strings = this._strings;
+ if (strings == null)
+ return _null;
+ cell = strings[key];
+ t1 = cell == null ? _null : cell.hashMapCellValue;
+ return t1;
+ } else if (typeof key == "number" && (key & 0x3fffffff) === key) {
+ nums = this._nums;
+ if (nums == null)
+ return _null;
+ cell = nums[key];
+ t1 = cell == null ? _null : cell.hashMapCellValue;
+ return t1;
+ } else
+ return this.internalGet$1(key);
+ },
+ internalGet$1(key) {
+ var bucket, index,
+ rest = this.__js_helper$_rest;
+ if (rest == null)
+ return null;
+ bucket = rest[this.internalComputeHashCode$1(key)];
+ index = this.internalFindBucketIndex$2(bucket, key);
+ if (index < 0)
+ return null;
+ return bucket[index].hashMapCellValue;
+ },
+ $indexSet(_, key, value) {
+ var strings, nums, rest, hash, bucket, index, _this = this,
+ t1 = A._instanceType(_this);
+ t1._precomputed1._as(key);
+ t1._rest[1]._as(value);
+ if (typeof key == "string") {
+ strings = _this._strings;
+ _this._addHashTableEntry$3(strings == null ? _this._strings = _this._newHashTable$0() : strings, key, value);
+ } else if (typeof key == "number" && (key & 0x3fffffff) === key) {
+ nums = _this._nums;
+ _this._addHashTableEntry$3(nums == null ? _this._nums = _this._newHashTable$0() : nums, key, value);
+ } else {
+ rest = _this.__js_helper$_rest;
+ if (rest == null)
+ rest = _this.__js_helper$_rest = _this._newHashTable$0();
+ hash = _this.internalComputeHashCode$1(key);
+ bucket = rest[hash];
+ if (bucket == null)
+ rest[hash] = [_this._newLinkedCell$2(key, value)];
+ else {
+ index = _this.internalFindBucketIndex$2(bucket, key);
+ if (index >= 0)
+ bucket[index].hashMapCellValue = value;
+ else
+ bucket.push(_this._newLinkedCell$2(key, value));
+ }
+ }
+ },
+ putIfAbsent$2(key, ifAbsent) {
+ var t2, value, _this = this,
+ t1 = A._instanceType(_this);
+ t1._precomputed1._as(key);
+ t1._eval$1("2()")._as(ifAbsent);
+ if (_this.containsKey$1(key)) {
+ t2 = _this.$index(0, key);
+ return t2 == null ? t1._rest[1]._as(t2) : t2;
+ }
+ value = ifAbsent.call$0();
+ _this.$indexSet(0, key, value);
+ return value;
+ },
+ forEach$1(_, action) {
+ var cell, modifications, _this = this;
+ A._instanceType(_this)._eval$1("~(1,2)")._as(action);
+ cell = _this._first;
+ modifications = _this._modifications;
+ for (; cell != null;) {
+ action.call$2(cell.hashMapCellKey, cell.hashMapCellValue);
+ if (modifications !== _this._modifications)
+ throw A.wrapException(A.ConcurrentModificationError$(_this));
+ cell = cell._next;
+ }
+ },
+ _addHashTableEntry$3(table, key, value) {
+ var cell,
+ t1 = A._instanceType(this);
+ t1._precomputed1._as(key);
+ t1._rest[1]._as(value);
+ cell = table[key];
+ if (cell == null)
+ table[key] = this._newLinkedCell$2(key, value);
+ else
+ cell.hashMapCellValue = value;
+ },
+ _newLinkedCell$2(key, value) {
+ var _this = this,
+ t1 = A._instanceType(_this),
+ cell = new A.LinkedHashMapCell(t1._precomputed1._as(key), t1._rest[1]._as(value));
+ if (_this._first == null)
+ _this._first = _this._last = cell;
+ else
+ _this._last = _this._last._next = cell;
+ ++_this.__js_helper$_length;
+ _this._modifications = _this._modifications + 1 & 1073741823;
+ return cell;
+ },
+ internalComputeHashCode$1(key) {
+ return J.get$hashCode$(key) & 1073741823;
+ },
+ internalFindBucketIndex$2(bucket, key) {
+ var $length, i;
+ if (bucket == null)
+ return -1;
+ $length = bucket.length;
+ for (i = 0; i < $length; ++i)
+ if (J.$eq$(bucket[i].hashMapCellKey, key))
+ return i;
+ return -1;
+ },
+ toString$0(_) {
+ return A.MapBase_mapToString(this);
+ },
+ _newHashTable$0() {
+ var table = Object.create(null);
+ table["<non-identifier-key>"] = table;
+ delete table["<non-identifier-key>"];
+ return table;
+ }
+ };
+ A.LinkedHashMapCell.prototype = {};
+ A.LinkedHashMapKeyIterable.prototype = {
+ get$length(_) {
+ return this._map.__js_helper$_length;
+ },
+ get$isEmpty(_) {
+ return this._map.__js_helper$_length === 0;
+ },
+ get$iterator(_) {
+ var t1 = this._map,
+ t2 = new A.LinkedHashMapKeyIterator(t1, t1._modifications, this.$ti._eval$1("LinkedHashMapKeyIterator<1>"));
+ t2._cell = t1._first;
+ return t2;
+ }
+ };
+ A.LinkedHashMapKeyIterator.prototype = {
+ get$current() {
+ return this.__js_helper$_current;
+ },
+ moveNext$0() {
+ var cell, _this = this,
+ t1 = _this._map;
+ if (_this._modifications !== t1._modifications)
+ throw A.wrapException(A.ConcurrentModificationError$(t1));
+ cell = _this._cell;
+ if (cell == null) {
+ _this.set$__js_helper$_current(null);
+ return false;
+ } else {
+ _this.set$__js_helper$_current(cell.hashMapCellKey);
+ _this._cell = cell._next;
+ return true;
+ }
+ },
+ set$__js_helper$_current(_current) {
+ this.__js_helper$_current = this.$ti._eval$1("1?")._as(_current);
+ }
+ };
+ A.initHooks_closure.prototype = {
+ call$1(o) {
+ return this.getTag(o);
+ },
+ $signature: 8
+ };
+ A.initHooks_closure0.prototype = {
+ call$2(o, tag) {
+ return this.getUnknownTag(o, tag);
+ },
+ $signature: 13
+ };
+ A.initHooks_closure1.prototype = {
+ call$1(tag) {
+ return this.prototypeForTag(A._asString(tag));
+ },
+ $signature: 14
+ };
+ A.StringMatch.prototype = {};
+ A.NativeByteBuffer.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_ByteBuffer_RkP;
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeTypedData.prototype = {};
+ A.NativeByteData.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_ByteData_zNC;
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeTypedArray.prototype = {
+ get$length(receiver) {
+ return receiver.length;
+ },
+ $isJavaScriptIndexingBehavior: 1
+ };
+ A.NativeTypedArrayOfDouble.prototype = {
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isIterable: 1,
+ $isList: 1
+ };
+ A.NativeTypedArrayOfInt.prototype = {$isIterable: 1, $isList: 1};
+ A.NativeFloat32List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Float32List_LB7;
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeFloat64List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Float64List_LB7;
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeInt16List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Int16List_uXf;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeInt32List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Int32List_O50;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeInt8List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Int8List_ekJ;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeUint16List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Uint16List_2bx;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeUint32List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Uint32List_2bx;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeUint8ClampedList.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Uint8ClampedList_Jik;
+ },
+ get$length(receiver) {
+ return receiver.length;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A.NativeUint8List.prototype = {
+ get$runtimeType(receiver) {
+ return B.Type_Uint8List_WLA;
+ },
+ get$length(receiver) {
+ return receiver.length;
+ },
+ $index(receiver, index) {
+ A._checkValidIndex(index, receiver, receiver.length);
+ return receiver[index];
+ },
+ $isTrustedGetRuntimeType: 1
+ };
+ A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin.prototype = {};
+ A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin.prototype = {};
+ A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.prototype = {};
+ A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.prototype = {};
+ A.Rti.prototype = {
+ _eval$1(recipe) {
+ return A._Universe_evalInEnvironment(init.typeUniverse, this, recipe);
+ },
+ _bind$1(typeOrTuple) {
+ return A._Universe_bind(init.typeUniverse, this, typeOrTuple);
+ }
+ };
+ A._FunctionParameters.prototype = {};
+ A._Type.prototype = {
+ toString$0(_) {
+ return A._rtiToString(this._rti, null);
+ }
+ };
+ A._Error.prototype = {
+ toString$0(_) {
+ return this.__rti$_message;
+ }
+ };
+ A._TypeError.prototype = {$isTypeError: 1};
+ A._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = {
+ call$1(_) {
+ var t1 = this._box_0,
+ f = t1.storedCallback;
+ t1.storedCallback = null;
+ f.call$0();
+ },
+ $signature: 4
+ };
+ A._AsyncRun__initializeScheduleImmediate_closure.prototype = {
+ call$1(callback) {
+ var t1, t2;
+ this._box_0.storedCallback = type$.void_Function._as(callback);
+ t1 = this.div;
+ t2 = this.span;
+ t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2);
+ },
+ $signature: 15
+ };
+ A._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = {
+ call$0() {
+ this.callback.call$0();
+ },
+ $signature: 2
+ };
+ A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = {
+ call$0() {
+ this.callback.call$0();
+ },
+ $signature: 2
+ };
+ A._TimerImpl.prototype = {
+ _TimerImpl$2(milliseconds, callback) {
+ if (self.setTimeout != null)
+ this._handle = self.setTimeout(A.convertDartClosureToJS(new A._TimerImpl_internalCallback(this, callback), 0), milliseconds);
+ else
+ throw A.wrapException(A.UnsupportedError$("`setTimeout()` not found."));
+ },
+ cancel$0() {
+ if (self.setTimeout != null) {
+ var t1 = this._handle;
+ if (t1 == null)
+ return;
+ self.clearTimeout(t1);
+ this._handle = null;
+ } else
+ throw A.wrapException(A.UnsupportedError$("Canceling a timer."));
+ },
+ $isTimer: 1
+ };
+ A._TimerImpl_internalCallback.prototype = {
+ call$0() {
+ this.$this._handle = null;
+ this.callback.call$0();
+ },
+ $signature: 0
+ };
+ A._AsyncAwaitCompleter.prototype = {
+ complete$1(value) {
+ var t2, _this = this,
+ t1 = _this.$ti;
+ t1._eval$1("1/?")._as(value);
+ if (value == null)
+ value = t1._precomputed1._as(value);
+ if (!_this.isSync)
+ _this._future._asyncComplete$1(value);
+ else {
+ t2 = _this._future;
+ if (t1._eval$1("Future<1>")._is(value))
+ t2._chainFuture$1(value);
+ else
+ t2._completeWithValue$1(value);
+ }
+ },
+ completeError$2(e, st) {
+ var t1 = this._future;
+ if (this.isSync)
+ t1._completeError$2(e, st);
+ else
+ t1._asyncCompleteError$2(e, st);
+ },
+ $isCompleter: 1
+ };
+ A._awaitOnObject_closure.prototype = {
+ call$1(result) {
+ return this.bodyFunction.call$2(0, result);
+ },
+ $signature: 3
+ };
+ A._awaitOnObject_closure0.prototype = {
+ call$2(error, stackTrace) {
+ this.bodyFunction.call$2(1, new A.ExceptionAndStackTrace(error, type$.StackTrace._as(stackTrace)));
+ },
+ $signature: 16
+ };
+ A._wrapJsFunctionForAsync_closure.prototype = {
+ call$2(errorCode, result) {
+ this.$protected(A._asInt(errorCode), result);
+ },
+ $signature: 17
+ };
+ A.AsyncError.prototype = {
+ toString$0(_) {
+ return A.S(this.error);
+ },
+ $isError: 1,
+ get$stackTrace() {
+ return this.stackTrace;
+ }
+ };
+ A._Completer.prototype = {
+ completeError$2(error, stackTrace) {
+ A.checkNotNullable(error, "error", type$.Object);
+ if ((this.future._state & 30) !== 0)
+ throw A.wrapException(A.StateError$("Future already completed"));
+ if (stackTrace == null)
+ stackTrace = A.AsyncError_defaultStackTrace(error);
+ this._completeError$2(error, stackTrace);
+ },
+ completeError$1(error) {
+ return this.completeError$2(error, null);
+ },
+ $isCompleter: 1
+ };
+ A._AsyncCompleter.prototype = {
+ complete$1(value) {
+ var t2,
+ t1 = this.$ti;
+ t1._eval$1("1/?")._as(value);
+ t2 = this.future;
+ if ((t2._state & 30) !== 0)
+ throw A.wrapException(A.StateError$("Future already completed"));
+ t2._asyncComplete$1(t1._eval$1("1/")._as(value));
+ },
+ complete$0() {
+ return this.complete$1(null);
+ },
+ _completeError$2(error, stackTrace) {
+ this.future._asyncCompleteError$2(error, stackTrace);
+ }
+ };
+ A._SyncCompleter.prototype = {
+ complete$1(value) {
+ var t2,
+ t1 = this.$ti;
+ t1._eval$1("1/?")._as(value);
+ t2 = this.future;
+ if ((t2._state & 30) !== 0)
+ throw A.wrapException(A.StateError$("Future already completed"));
+ t2._complete$1(t1._eval$1("1/")._as(value));
+ },
+ _completeError$2(error, stackTrace) {
+ this.future._completeError$2(error, stackTrace);
+ }
+ };
+ A._FutureListener.prototype = {
+ matchesErrorTest$1(asyncError) {
+ if ((this.state & 15) !== 6)
+ return true;
+ return this.result._zone.runUnary$2$2(type$.bool_Function_Object._as(this.callback), asyncError.error, type$.bool, type$.Object);
+ },
+ handleError$1(asyncError) {
+ var exception, _this = this,
+ errorCallback = _this.errorCallback,
+ result = null,
+ t1 = type$.dynamic,
+ t2 = type$.Object,
+ t3 = asyncError.error,
+ t4 = _this.result._zone;
+ if (type$.dynamic_Function_Object_StackTrace._is(errorCallback))
+ result = t4.runBinary$3$3(errorCallback, t3, asyncError.stackTrace, t1, t2, type$.StackTrace);
+ else
+ result = t4.runUnary$2$2(type$.dynamic_Function_Object._as(errorCallback), t3, t1, t2);
+ try {
+ t1 = _this.$ti._eval$1("2/")._as(result);
+ return t1;
+ } catch (exception) {
+ if (type$.TypeError._is(A.unwrapException(exception))) {
+ if ((_this.state & 1) !== 0)
+ throw A.wrapException(A.ArgumentError$("The error handler of Future.then must return a value of the returned future's type", "onError"));
+ throw A.wrapException(A.ArgumentError$("The error handler of Future.catchError must return a value of the future's type", "onError"));
+ } else
+ throw exception;
+ }
+ }
+ };
+ A._Future.prototype = {
+ _setChained$1(source) {
+ this._state = this._state & 1 | 4;
+ this._resultOrListeners = source;
+ },
+ then$1$2$onError(f, onError, $R) {
+ var currentZone, result, t2,
+ t1 = this.$ti;
+ t1._bind$1($R)._eval$1("1/(2)")._as(f);
+ currentZone = $.Zone__current;
+ if (currentZone === B.C__RootZone) {
+ if (onError != null && !type$.dynamic_Function_Object_StackTrace._is(onError) && !type$.dynamic_Function_Object._is(onError))
+ throw A.wrapException(A.ArgumentError$value(onError, "onError", string$.Error_));
+ } else {
+ $R._eval$1("@<0/>")._bind$1(t1._precomputed1)._eval$1("1(2)")._as(f);
+ if (onError != null)
+ onError = A._registerErrorHandler(onError, currentZone);
+ }
+ result = new A._Future(currentZone, $R._eval$1("_Future<0>"));
+ t2 = onError == null ? 1 : 3;
+ this._addListener$1(new A._FutureListener(result, t2, f, onError, t1._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>")));
+ return result;
+ },
+ then$1$1(f, $R) {
+ return this.then$1$2$onError(f, null, $R);
+ },
+ _thenAwait$1$2(f, onError, $E) {
+ var result,
+ t1 = this.$ti;
+ t1._bind$1($E)._eval$1("1/(2)")._as(f);
+ result = new A._Future($.Zone__current, $E._eval$1("_Future<0>"));
+ this._addListener$1(new A._FutureListener(result, 19, f, onError, t1._eval$1("@<1>")._bind$1($E)._eval$1("_FutureListener<1,2>")));
+ return result;
+ },
+ whenComplete$1(action) {
+ var t1, result;
+ type$.dynamic_Function._as(action);
+ t1 = this.$ti;
+ result = new A._Future($.Zone__current, t1);
+ this._addListener$1(new A._FutureListener(result, 8, action, null, t1._eval$1("@<1>")._bind$1(t1._precomputed1)._eval$1("_FutureListener<1,2>")));
+ return result;
+ },
+ _setErrorObject$1(error) {
+ this._state = this._state & 1 | 16;
+ this._resultOrListeners = error;
+ },
+ _cloneResult$1(source) {
+ this._state = source._state & 30 | this._state & 1;
+ this._resultOrListeners = source._resultOrListeners;
+ },
+ _addListener$1(listener) {
+ var source, _this = this,
+ t1 = _this._state;
+ if (t1 <= 3) {
+ listener._nextListener = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
+ _this._resultOrListeners = listener;
+ } else {
+ if ((t1 & 4) !== 0) {
+ source = type$._Future_dynamic._as(_this._resultOrListeners);
+ if ((source._state & 24) === 0) {
+ source._addListener$1(listener);
+ return;
+ }
+ _this._cloneResult$1(source);
+ }
+ A._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new A._Future__addListener_closure(_this, listener)));
+ }
+ },
+ _prependListeners$1(listeners) {
+ var t1, existingListeners, next, cursor, next0, source, _this = this, _box_0 = {};
+ _box_0.listeners = listeners;
+ if (listeners == null)
+ return;
+ t1 = _this._state;
+ if (t1 <= 3) {
+ existingListeners = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
+ _this._resultOrListeners = listeners;
+ if (existingListeners != null) {
+ next = listeners._nextListener;
+ for (cursor = listeners; next != null; cursor = next, next = next0)
+ next0 = next._nextListener;
+ cursor._nextListener = existingListeners;
+ }
+ } else {
+ if ((t1 & 4) !== 0) {
+ source = type$._Future_dynamic._as(_this._resultOrListeners);
+ if ((source._state & 24) === 0) {
+ source._prependListeners$1(listeners);
+ return;
+ }
+ _this._cloneResult$1(source);
+ }
+ _box_0.listeners = _this._reverseListeners$1(listeners);
+ A._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new A._Future__prependListeners_closure(_box_0, _this)));
+ }
+ },
+ _removeListeners$0() {
+ var current = type$.nullable__FutureListener_dynamic_dynamic._as(this._resultOrListeners);
+ this._resultOrListeners = null;
+ return this._reverseListeners$1(current);
+ },
+ _reverseListeners$1(listeners) {
+ var current, prev, next;
+ for (current = listeners, prev = null; current != null; prev = current, current = next) {
+ next = current._nextListener;
+ current._nextListener = prev;
+ }
+ return prev;
+ },
+ _chainForeignFuture$1(source) {
+ var e, s, exception, _this = this;
+ _this._state ^= 2;
+ try {
+ source.then$1$2$onError(new A._Future__chainForeignFuture_closure(_this), new A._Future__chainForeignFuture_closure0(_this), type$.Null);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ A.scheduleMicrotask(new A._Future__chainForeignFuture_closure1(_this, e, s));
+ }
+ },
+ _complete$1(value) {
+ var listeners, _this = this,
+ t1 = _this.$ti;
+ t1._eval$1("1/")._as(value);
+ if (t1._eval$1("Future<1>")._is(value))
+ if (t1._is(value))
+ A._Future__chainCoreFutureSync(value, _this);
+ else
+ _this._chainForeignFuture$1(value);
+ else {
+ listeners = _this._removeListeners$0();
+ t1._precomputed1._as(value);
+ _this._state = 8;
+ _this._resultOrListeners = value;
+ A._Future__propagateToListeners(_this, listeners);
+ }
+ },
+ _completeWithValue$1(value) {
+ var listeners, _this = this;
+ _this.$ti._precomputed1._as(value);
+ listeners = _this._removeListeners$0();
+ _this._state = 8;
+ _this._resultOrListeners = value;
+ A._Future__propagateToListeners(_this, listeners);
+ },
+ _completeError$2(error, stackTrace) {
+ var listeners;
+ type$.Object._as(error);
+ type$.StackTrace._as(stackTrace);
+ listeners = this._removeListeners$0();
+ this._setErrorObject$1(A.AsyncError$(error, stackTrace));
+ A._Future__propagateToListeners(this, listeners);
+ },
+ _asyncComplete$1(value) {
+ var t1 = this.$ti;
+ t1._eval$1("1/")._as(value);
+ if (t1._eval$1("Future<1>")._is(value)) {
+ this._chainFuture$1(value);
+ return;
+ }
+ this._asyncCompleteWithValue$1(value);
+ },
+ _asyncCompleteWithValue$1(value) {
+ var _this = this;
+ _this.$ti._precomputed1._as(value);
+ _this._state ^= 2;
+ A._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new A._Future__asyncCompleteWithValue_closure(_this, value)));
+ },
+ _chainFuture$1(value) {
+ var t1 = this.$ti;
+ t1._eval$1("Future<1>")._as(value);
+ if (t1._is(value)) {
+ A._Future__chainCoreFutureAsync(value, this);
+ return;
+ }
+ this._chainForeignFuture$1(value);
+ },
+ _asyncCompleteError$2(error, stackTrace) {
+ type$.StackTrace._as(stackTrace);
+ this._state ^= 2;
+ A._rootScheduleMicrotask(null, null, this._zone, type$.void_Function._as(new A._Future__asyncCompleteError_closure(this, error, stackTrace)));
+ },
+ $isFuture: 1
+ };
+ A._Future__addListener_closure.prototype = {
+ call$0() {
+ A._Future__propagateToListeners(this.$this, this.listener);
+ },
+ $signature: 0
+ };
+ A._Future__prependListeners_closure.prototype = {
+ call$0() {
+ A._Future__propagateToListeners(this.$this, this._box_0.listeners);
+ },
+ $signature: 0
+ };
+ A._Future__chainForeignFuture_closure.prototype = {
+ call$1(value) {
+ var error, stackTrace, exception,
+ t1 = this.$this;
+ t1._state ^= 2;
+ try {
+ t1._completeWithValue$1(t1.$ti._precomputed1._as(value));
+ } catch (exception) {
+ error = A.unwrapException(exception);
+ stackTrace = A.getTraceFromException(exception);
+ t1._completeError$2(error, stackTrace);
+ }
+ },
+ $signature: 4
+ };
+ A._Future__chainForeignFuture_closure0.prototype = {
+ call$2(error, stackTrace) {
+ this.$this._completeError$2(type$.Object._as(error), type$.StackTrace._as(stackTrace));
+ },
+ $signature: 5
+ };
+ A._Future__chainForeignFuture_closure1.prototype = {
+ call$0() {
+ this.$this._completeError$2(this.e, this.s);
+ },
+ $signature: 0
+ };
+ A._Future__chainCoreFutureAsync_closure.prototype = {
+ call$0() {
+ A._Future__chainCoreFutureSync(this._box_0.source, this.target);
+ },
+ $signature: 0
+ };
+ A._Future__asyncCompleteWithValue_closure.prototype = {
+ call$0() {
+ this.$this._completeWithValue$1(this.value);
+ },
+ $signature: 0
+ };
+ A._Future__asyncCompleteError_closure.prototype = {
+ call$0() {
+ this.$this._completeError$2(this.error, this.stackTrace);
+ },
+ $signature: 0
+ };
+ A._Future__propagateToListeners_handleWhenCompleteCallback.prototype = {
+ call$0() {
+ var e, s, t1, exception, t2, originalSource, _this = this, completeResult = null;
+ try {
+ t1 = _this._box_0.listener;
+ completeResult = t1.result._zone.run$1$1(type$.dynamic_Function._as(t1.callback), type$.dynamic);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ t1 = _this.hasError && type$.AsyncError._as(_this._box_1.source._resultOrListeners).error === e;
+ t2 = _this._box_0;
+ if (t1)
+ t2.listenerValueOrError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
+ else
+ t2.listenerValueOrError = A.AsyncError$(e, s);
+ t2.listenerHasError = true;
+ return;
+ }
+ if (completeResult instanceof A._Future && (completeResult._state & 24) !== 0) {
+ if ((completeResult._state & 16) !== 0) {
+ t1 = _this._box_0;
+ t1.listenerValueOrError = type$.AsyncError._as(completeResult._resultOrListeners);
+ t1.listenerHasError = true;
+ }
+ return;
+ }
+ if (completeResult instanceof A._Future) {
+ originalSource = _this._box_1.source;
+ t1 = _this._box_0;
+ t1.listenerValueOrError = completeResult.then$1$1(new A._Future__propagateToListeners_handleWhenCompleteCallback_closure(originalSource), type$.dynamic);
+ t1.listenerHasError = false;
+ }
+ },
+ $signature: 0
+ };
+ A._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = {
+ call$1(_) {
+ return this.originalSource;
+ },
+ $signature: 18
+ };
+ A._Future__propagateToListeners_handleValueCallback.prototype = {
+ call$0() {
+ var e, s, t1, t2, t3, t4, t5, exception;
+ try {
+ t1 = this._box_0;
+ t2 = t1.listener;
+ t3 = t2.$ti;
+ t4 = t3._precomputed1;
+ t5 = t4._as(this.sourceResult);
+ t1.listenerValueOrError = t2.result._zone.runUnary$2$2(t3._eval$1("2/(1)")._as(t2.callback), t5, t3._eval$1("2/"), t4);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ t1 = this._box_0;
+ t1.listenerValueOrError = A.AsyncError$(e, s);
+ t1.listenerHasError = true;
+ }
+ },
+ $signature: 0
+ };
+ A._Future__propagateToListeners_handleError.prototype = {
+ call$0() {
+ var asyncError, e, s, t1, exception, t2, _this = this;
+ try {
+ asyncError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
+ t1 = _this._box_0;
+ if (t1.listener.matchesErrorTest$1(asyncError) && t1.listener.errorCallback != null) {
+ t1.listenerValueOrError = t1.listener.handleError$1(asyncError);
+ t1.listenerHasError = false;
+ }
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ t1 = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
+ t2 = _this._box_0;
+ if (t1.error === e)
+ t2.listenerValueOrError = t1;
+ else
+ t2.listenerValueOrError = A.AsyncError$(e, s);
+ t2.listenerHasError = true;
+ }
+ },
+ $signature: 0
+ };
+ A._AsyncCallbackEntry.prototype = {};
+ A.Stream.prototype = {
+ get$length(_) {
+ var t1 = {},
+ future = new A._Future($.Zone__current, type$._Future_int);
+ t1.count = 0;
+ this.listen$4$cancelOnError$onDone$onError(new A.Stream_length_closure(t1, this), true, new A.Stream_length_closure0(t1, future), future.get$_completeError());
+ return future;
+ },
+ get$first(_) {
+ var future = new A._Future($.Zone__current, A._instanceType(this)._eval$1("_Future<1>")),
+ subscription = this.listen$4$cancelOnError$onDone$onError(null, true, new A.Stream_first_closure(future), future.get$_completeError());
+ subscription.onData$1(new A.Stream_first_closure0(this, subscription, future));
+ return future;
+ }
+ };
+ A.Stream_length_closure.prototype = {
+ call$1(_) {
+ A._instanceType(this.$this)._precomputed1._as(_);
+ ++this._box_0.count;
+ },
+ $signature() {
+ return A._instanceType(this.$this)._eval$1("~(1)");
+ }
+ };
+ A.Stream_length_closure0.prototype = {
+ call$0() {
+ this.future._complete$1(this._box_0.count);
+ },
+ $signature: 0
+ };
+ A.Stream_first_closure.prototype = {
+ call$0() {
+ var e, s, t1, exception, stackTrace;
+ try {
+ t1 = A.IterableElementError_noElement();
+ throw A.wrapException(t1);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ t1 = e;
+ stackTrace = s;
+ if (stackTrace == null)
+ stackTrace = A.AsyncError_defaultStackTrace(t1);
+ this.future._completeError$2(t1, stackTrace);
+ }
+ },
+ $signature: 0
+ };
+ A.Stream_first_closure0.prototype = {
+ call$1(value) {
+ A._cancelAndValue(this.subscription, this.future, A._instanceType(this.$this)._precomputed1._as(value));
+ },
+ $signature() {
+ return A._instanceType(this.$this)._eval$1("~(1)");
+ }
+ };
+ A._StreamController.prototype = {
+ get$_pendingEvents() {
+ var t1, _this = this;
+ if ((_this._state & 8) === 0)
+ return A._instanceType(_this)._eval$1("_PendingEvents<1>?")._as(_this._varData);
+ t1 = A._instanceType(_this);
+ return t1._eval$1("_PendingEvents<1>?")._as(t1._eval$1("_StreamControllerAddStreamState<1>")._as(_this._varData).get$_varData());
+ },
+ _ensurePendingEvents$0() {
+ var events, t1, _this = this;
+ if ((_this._state & 8) === 0) {
+ events = _this._varData;
+ if (events == null)
+ events = _this._varData = new A._PendingEvents(A._instanceType(_this)._eval$1("_PendingEvents<1>"));
+ return A._instanceType(_this)._eval$1("_PendingEvents<1>")._as(events);
+ }
+ t1 = A._instanceType(_this);
+ events = t1._eval$1("_StreamControllerAddStreamState<1>")._as(_this._varData).get$_varData();
+ return t1._eval$1("_PendingEvents<1>")._as(events);
+ },
+ get$_subscription() {
+ var varData = this._varData;
+ if ((this._state & 8) !== 0)
+ varData = type$._StreamControllerAddStreamState_nullable_Object._as(varData).get$_varData();
+ return A._instanceType(this)._eval$1("_ControllerSubscription<1>")._as(varData);
+ },
+ _badEventState$0() {
+ if ((this._state & 4) !== 0)
+ return new A.StateError("Cannot add event after closing");
+ return new A.StateError("Cannot add event while adding a stream");
+ },
+ _ensureDoneFuture$0() {
+ var t1 = this._doneFuture;
+ if (t1 == null)
+ t1 = this._doneFuture = (this._state & 2) !== 0 ? $.$get$Future__nullFuture() : new A._Future($.Zone__current, type$._Future_void);
+ return t1;
+ },
+ add$1(_, value) {
+ var t2, _this = this,
+ t1 = A._instanceType(_this);
+ t1._precomputed1._as(value);
+ t2 = _this._state;
+ if (t2 >= 4)
+ throw A.wrapException(_this._badEventState$0());
+ if ((t2 & 1) !== 0)
+ _this._sendData$1(value);
+ else if ((t2 & 3) === 0)
+ _this._ensurePendingEvents$0().add$1(0, new A._DelayedData(value, t1._eval$1("_DelayedData<1>")));
+ },
+ close$0() {
+ var _this = this,
+ t1 = _this._state;
+ if ((t1 & 4) !== 0)
+ return _this._ensureDoneFuture$0();
+ if (t1 >= 4)
+ throw A.wrapException(_this._badEventState$0());
+ t1 = _this._state = t1 | 4;
+ if ((t1 & 1) !== 0)
+ _this._sendDone$0();
+ else if ((t1 & 3) === 0)
+ _this._ensurePendingEvents$0().add$1(0, B.C__DelayedDone);
+ return _this._ensureDoneFuture$0();
+ },
+ _subscribe$4(onData, onError, onDone, cancelOnError) {
+ var t2, t3, t4, t5, t6, t7, t8, subscription, pendingEvents, addState, _this = this,
+ t1 = A._instanceType(_this);
+ t1._eval$1("~(1)?")._as(onData);
+ type$.nullable_void_Function._as(onDone);
+ if ((_this._state & 3) !== 0)
+ throw A.wrapException(A.StateError$("Stream has already been listened to."));
+ t2 = $.Zone__current;
+ t3 = cancelOnError ? 1 : 0;
+ t4 = onError != null ? 32 : 0;
+ t5 = A._BufferingStreamSubscription__registerDataHandler(t2, onData, t1._precomputed1);
+ t6 = A._BufferingStreamSubscription__registerErrorHandler(t2, onError);
+ t7 = onDone == null ? A.async___nullDoneHandler$closure() : onDone;
+ t8 = type$.void_Function;
+ subscription = new A._ControllerSubscription(_this, t5, t6, t8._as(t7), t2, t3 | t4, t1._eval$1("_ControllerSubscription<1>"));
+ pendingEvents = _this.get$_pendingEvents();
+ t4 = _this._state |= 1;
+ if ((t4 & 8) !== 0) {
+ addState = t1._eval$1("_StreamControllerAddStreamState<1>")._as(_this._varData);
+ addState.set$_varData(subscription);
+ addState.resume$0();
+ } else
+ _this._varData = subscription;
+ subscription._setPendingEvents$1(pendingEvents);
+ t1 = t8._as(new A._StreamController__subscribe_closure(_this));
+ t2 = subscription._state;
+ subscription._state = t2 | 64;
+ t1.call$0();
+ subscription._state &= 4294967231;
+ subscription._checkState$1((t2 & 4) !== 0);
+ return subscription;
+ },
+ _recordCancel$1(subscription) {
+ var result, onCancel, cancelResult, e, s, exception, result0, _this = this,
+ t1 = A._instanceType(_this);
+ t1._eval$1("StreamSubscription<1>")._as(subscription);
+ result = null;
+ if ((_this._state & 8) !== 0)
+ result = t1._eval$1("_StreamControllerAddStreamState<1>")._as(_this._varData).cancel$0();
+ _this._varData = null;
+ _this._state = _this._state & 4294967286 | 2;
+ onCancel = _this.onCancel;
+ if (onCancel != null)
+ if (result == null)
+ try {
+ cancelResult = onCancel.call$0();
+ if (cancelResult instanceof A._Future)
+ result = cancelResult;
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ result0 = new A._Future($.Zone__current, type$._Future_void);
+ result0._asyncCompleteError$2(e, s);
+ result = result0;
+ }
+ else
+ result = result.whenComplete$1(onCancel);
+ t1 = new A._StreamController__recordCancel_complete(_this);
+ if (result != null)
+ result = result.whenComplete$1(t1);
+ else
+ t1.call$0();
+ return result;
+ },
+ $isStreamController: 1,
+ $is_StreamControllerLifecycle: 1,
+ $is_EventDispatch: 1
+ };
+ A._StreamController__subscribe_closure.prototype = {
+ call$0() {
+ A._runGuarded(this.$this.onListen);
+ },
+ $signature: 0
+ };
+ A._StreamController__recordCancel_complete.prototype = {
+ call$0() {
+ var doneFuture = this.$this._doneFuture;
+ if (doneFuture != null && (doneFuture._state & 30) === 0)
+ doneFuture._asyncComplete$1(null);
+ },
+ $signature: 0
+ };
+ A._AsyncStreamControllerDispatch.prototype = {
+ _sendData$1(data) {
+ var t1 = this.$ti;
+ t1._precomputed1._as(data);
+ this.get$_subscription()._addPending$1(new A._DelayedData(data, t1._eval$1("_DelayedData<1>")));
+ },
+ _sendError$2(error, stackTrace) {
+ this.get$_subscription()._addPending$1(new A._DelayedError(error, stackTrace));
+ },
+ _sendDone$0() {
+ this.get$_subscription()._addPending$1(B.C__DelayedDone);
+ }
+ };
+ A._AsyncStreamController.prototype = {};
+ A._ControllerStream.prototype = {
+ get$hashCode(_) {
+ return (A.Primitives_objectHashCode(this._controller) ^ 892482866) >>> 0;
+ },
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ if (this === other)
+ return true;
+ return other instanceof A._ControllerStream && other._controller === this._controller;
+ }
+ };
+ A._ControllerSubscription.prototype = {
+ _onCancel$0() {
+ return this._controller._recordCancel$1(this);
+ },
+ _onPause$0() {
+ var t1 = this._controller,
+ t2 = A._instanceType(t1);
+ t2._eval$1("StreamSubscription<1>")._as(this);
+ if ((t1._state & 8) !== 0)
+ t2._eval$1("_StreamControllerAddStreamState<1>")._as(t1._varData).pause$0();
+ A._runGuarded(t1.onPause);
+ },
+ _onResume$0() {
+ var t1 = this._controller,
+ t2 = A._instanceType(t1);
+ t2._eval$1("StreamSubscription<1>")._as(this);
+ if ((t1._state & 8) !== 0)
+ t2._eval$1("_StreamControllerAddStreamState<1>")._as(t1._varData).resume$0();
+ A._runGuarded(t1.onResume);
+ }
+ };
+ A._StreamSinkWrapper.prototype = {};
+ A._BufferingStreamSubscription.prototype = {
+ _setPendingEvents$1(pendingEvents) {
+ var _this = this;
+ A._instanceType(_this)._eval$1("_PendingEvents<1>?")._as(pendingEvents);
+ if (pendingEvents == null)
+ return;
+ _this.set$_pending(pendingEvents);
+ if (pendingEvents.lastPendingEvent != null) {
+ _this._state |= 128;
+ pendingEvents.schedule$1(_this);
+ }
+ },
+ onData$1(handleData) {
+ var t1 = A._instanceType(this);
+ this.set$_onData(A._BufferingStreamSubscription__registerDataHandler(this._zone, t1._eval$1("~(1)?")._as(handleData), t1._precomputed1));
+ },
+ cancel$0() {
+ var t1 = this._state &= 4294967279;
+ if ((t1 & 8) === 0)
+ this._cancel$0();
+ t1 = this._cancelFuture;
+ return t1 == null ? $.$get$Future__nullFuture() : t1;
+ },
+ asFuture$1$1(futureValue, $E) {
+ var result, _this = this, t1 = {};
+ t1.resultValue = null;
+ if (!$E._is(null))
+ throw A.wrapException(A.ArgumentError$notNull("futureValue"));
+ $E._as(futureValue);
+ t1.resultValue = futureValue;
+ result = new A._Future($.Zone__current, $E._eval$1("_Future<0>"));
+ _this.set$_onDone(new A._BufferingStreamSubscription_asFuture_closure(t1, result));
+ _this._state |= 32;
+ _this._onError = new A._BufferingStreamSubscription_asFuture_closure0(_this, result);
+ return result;
+ },
+ _cancel$0() {
+ var t2, _this = this,
+ t1 = _this._state |= 8;
+ if ((t1 & 128) !== 0) {
+ t2 = _this._pending;
+ if (t2._state === 1)
+ t2._state = 3;
+ }
+ if ((t1 & 64) === 0)
+ _this.set$_pending(null);
+ _this._cancelFuture = _this._onCancel$0();
+ },
+ _onPause$0() {
+ },
+ _onResume$0() {
+ },
+ _onCancel$0() {
+ return null;
+ },
+ _addPending$1($event) {
+ var t1, _this = this,
+ pending = _this._pending;
+ if (pending == null) {
+ pending = new A._PendingEvents(A._instanceType(_this)._eval$1("_PendingEvents<1>"));
+ _this.set$_pending(pending);
+ }
+ pending.add$1(0, $event);
+ t1 = _this._state;
+ if ((t1 & 128) === 0) {
+ t1 |= 128;
+ _this._state = t1;
+ if (t1 < 256)
+ pending.schedule$1(_this);
+ }
+ },
+ _sendData$1(data) {
+ var t2, _this = this,
+ t1 = A._instanceType(_this)._precomputed1;
+ t1._as(data);
+ t2 = _this._state;
+ _this._state = t2 | 64;
+ _this._zone.runUnaryGuarded$1$2(_this._onData, data, t1);
+ _this._state &= 4294967231;
+ _this._checkState$1((t2 & 4) !== 0);
+ },
+ _sendError$2(error, stackTrace) {
+ var cancelFuture, _this = this,
+ t1 = _this._state,
+ t2 = new A._BufferingStreamSubscription__sendError_sendError(_this, error, stackTrace);
+ if ((t1 & 1) !== 0) {
+ _this._state = t1 | 16;
+ _this._cancel$0();
+ cancelFuture = _this._cancelFuture;
+ if (cancelFuture != null && cancelFuture !== $.$get$Future__nullFuture())
+ cancelFuture.whenComplete$1(t2);
+ else
+ t2.call$0();
+ } else {
+ t2.call$0();
+ _this._checkState$1((t1 & 4) !== 0);
+ }
+ },
+ _sendDone$0() {
+ var cancelFuture, _this = this,
+ t1 = new A._BufferingStreamSubscription__sendDone_sendDone(_this);
+ _this._cancel$0();
+ _this._state |= 16;
+ cancelFuture = _this._cancelFuture;
+ if (cancelFuture != null && cancelFuture !== $.$get$Future__nullFuture())
+ cancelFuture.whenComplete$1(t1);
+ else
+ t1.call$0();
+ },
+ _checkState$1(wasInputPaused) {
+ var t2, isInputPaused, _this = this,
+ t1 = _this._state;
+ if ((t1 & 128) !== 0 && _this._pending.lastPendingEvent == null) {
+ t1 = _this._state = t1 & 4294967167;
+ if ((t1 & 4) !== 0)
+ if (t1 < 256) {
+ t2 = _this._pending;
+ t2 = t2 == null ? null : t2.lastPendingEvent == null;
+ t2 = t2 !== false;
+ } else
+ t2 = false;
+ else
+ t2 = false;
+ if (t2) {
+ t1 &= 4294967291;
+ _this._state = t1;
+ }
+ }
+ for (; true; wasInputPaused = isInputPaused) {
+ if ((t1 & 8) !== 0) {
+ _this.set$_pending(null);
+ return;
+ }
+ isInputPaused = (t1 & 4) !== 0;
+ if (wasInputPaused === isInputPaused)
+ break;
+ _this._state = t1 ^ 64;
+ if (isInputPaused)
+ _this._onPause$0();
+ else
+ _this._onResume$0();
+ t1 = _this._state &= 4294967231;
+ }
+ if ((t1 & 128) !== 0 && t1 < 256)
+ _this._pending.schedule$1(_this);
+ },
+ set$_onData(_onData) {
+ this._onData = A._instanceType(this)._eval$1("~(1)")._as(_onData);
+ },
+ set$_onDone(_onDone) {
+ this._onDone = type$.void_Function._as(_onDone);
+ },
+ set$_pending(_pending) {
+ this._pending = A._instanceType(this)._eval$1("_PendingEvents<1>?")._as(_pending);
+ },
+ $isStreamSubscription: 1,
+ $is_EventDispatch: 1
+ };
+ A._BufferingStreamSubscription_asFuture_closure.prototype = {
+ call$0() {
+ this.result._complete$1(this._box_0.resultValue);
+ },
+ $signature: 0
+ };
+ A._BufferingStreamSubscription_asFuture_closure0.prototype = {
+ call$2(error, stackTrace) {
+ var cancelFuture = this.$this.cancel$0(),
+ t1 = this.result;
+ if (cancelFuture !== $.$get$Future__nullFuture())
+ cancelFuture.whenComplete$1(new A._BufferingStreamSubscription_asFuture__closure(t1, error, stackTrace));
+ else
+ t1._completeError$2(error, stackTrace);
+ },
+ $signature: 5
+ };
+ A._BufferingStreamSubscription_asFuture__closure.prototype = {
+ call$0() {
+ this.result._completeError$2(this.error, this.stackTrace);
+ },
+ $signature: 2
+ };
+ A._BufferingStreamSubscription__sendError_sendError.prototype = {
+ call$0() {
+ var onError, t3, t4,
+ t1 = this.$this,
+ t2 = t1._state;
+ if ((t2 & 8) !== 0 && (t2 & 16) === 0)
+ return;
+ t1._state = t2 | 64;
+ onError = t1._onError;
+ t2 = this.error;
+ t3 = type$.Object;
+ t4 = t1._zone;
+ if (type$.void_Function_Object_StackTrace._is(onError))
+ t4.runBinaryGuarded$2$3(onError, t2, this.stackTrace, t3, type$.StackTrace);
+ else
+ t4.runUnaryGuarded$1$2(type$.void_Function_Object._as(onError), t2, t3);
+ t1._state &= 4294967231;
+ },
+ $signature: 0
+ };
+ A._BufferingStreamSubscription__sendDone_sendDone.prototype = {
+ call$0() {
+ var t1 = this.$this,
+ t2 = t1._state;
+ if ((t2 & 16) === 0)
+ return;
+ t1._state = t2 | 74;
+ t1._zone.runGuarded$1(t1._onDone);
+ t1._state &= 4294967231;
+ },
+ $signature: 0
+ };
+ A._StreamImpl.prototype = {
+ listen$4$cancelOnError$onDone$onError(onData, cancelOnError, onDone, onError) {
+ var t1 = this.$ti;
+ t1._eval$1("~(1)?")._as(onData);
+ type$.nullable_void_Function._as(onDone);
+ return this._controller._subscribe$4(t1._eval$1("~(1)?")._as(onData), onError, onDone, cancelOnError === true);
+ },
+ listen$1(onData) {
+ return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null);
+ },
+ listen$2$cancelOnError(onData, cancelOnError) {
+ return this.listen$4$cancelOnError$onDone$onError(onData, cancelOnError, null, null);
+ },
+ listen$2$onDone(onData, onDone) {
+ return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, null);
+ }
+ };
+ A._DelayedEvent.prototype = {
+ set$next(next) {
+ this.next = type$.nullable__DelayedEvent_dynamic._as(next);
+ },
+ get$next() {
+ return this.next;
+ }
+ };
+ A._DelayedData.prototype = {
+ perform$1(dispatch) {
+ this.$ti._eval$1("_EventDispatch<1>")._as(dispatch)._sendData$1(this.value);
+ }
+ };
+ A._DelayedError.prototype = {
+ perform$1(dispatch) {
+ dispatch._sendError$2(this.error, this.stackTrace);
+ }
+ };
+ A._DelayedDone.prototype = {
+ perform$1(dispatch) {
+ dispatch._sendDone$0();
+ },
+ get$next() {
+ return null;
+ },
+ set$next(_) {
+ throw A.wrapException(A.StateError$("No events after a done."));
+ },
+ $is_DelayedEvent: 1
+ };
+ A._PendingEvents.prototype = {
+ schedule$1(dispatch) {
+ var t1, _this = this;
+ _this.$ti._eval$1("_EventDispatch<1>")._as(dispatch);
+ t1 = _this._state;
+ if (t1 === 1)
+ return;
+ if (t1 >= 1) {
+ _this._state = 1;
+ return;
+ }
+ A.scheduleMicrotask(new A._PendingEvents_schedule_closure(_this, dispatch));
+ _this._state = 1;
+ },
+ add$1(_, $event) {
+ var _this = this,
+ lastEvent = _this.lastPendingEvent;
+ if (lastEvent == null)
+ _this.firstPendingEvent = _this.lastPendingEvent = $event;
+ else {
+ lastEvent.set$next($event);
+ _this.lastPendingEvent = $event;
+ }
+ }
+ };
+ A._PendingEvents_schedule_closure.prototype = {
+ call$0() {
+ var t2, $event, nextEvent,
+ t1 = this.$this,
+ oldState = t1._state;
+ t1._state = 0;
+ if (oldState === 3)
+ return;
+ t2 = t1.$ti._eval$1("_EventDispatch<1>")._as(this.dispatch);
+ $event = t1.firstPendingEvent;
+ nextEvent = $event.get$next();
+ t1.firstPendingEvent = nextEvent;
+ if (nextEvent == null)
+ t1.lastPendingEvent = null;
+ $event.perform$1(t2);
+ },
+ $signature: 0
+ };
+ A._StreamIterator.prototype = {};
+ A._cancelAndValue_closure.prototype = {
+ call$0() {
+ return this.future._complete$1(this.value);
+ },
+ $signature: 0
+ };
+ A._Zone.prototype = {$isZone: 1};
+ A._rootHandleError_closure.prototype = {
+ call$0() {
+ A.Error_throwWithStackTrace(this.error, this.stackTrace);
+ },
+ $signature: 0
+ };
+ A._RootZone.prototype = {
+ runGuarded$1(f) {
+ var e, s, exception;
+ type$.void_Function._as(f);
+ try {
+ if (B.C__RootZone === $.Zone__current) {
+ f.call$0();
+ return;
+ }
+ A._rootRun(null, null, this, f, type$.void);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ A._rootHandleError(type$.Object._as(e), type$.StackTrace._as(s));
+ }
+ },
+ runUnaryGuarded$1$2(f, arg, $T) {
+ var e, s, exception;
+ $T._eval$1("~(0)")._as(f);
+ $T._as(arg);
+ try {
+ if (B.C__RootZone === $.Zone__current) {
+ f.call$1(arg);
+ return;
+ }
+ A._rootRunUnary(null, null, this, f, arg, type$.void, $T);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ A._rootHandleError(type$.Object._as(e), type$.StackTrace._as(s));
+ }
+ },
+ runBinaryGuarded$2$3(f, arg1, arg2, T1, T2) {
+ var e, s, exception;
+ T1._eval$1("@<0>")._bind$1(T2)._eval$1("~(1,2)")._as(f);
+ T1._as(arg1);
+ T2._as(arg2);
+ try {
+ if (B.C__RootZone === $.Zone__current) {
+ f.call$2(arg1, arg2);
+ return;
+ }
+ A._rootRunBinary(null, null, this, f, arg1, arg2, type$.void, T1, T2);
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ s = A.getTraceFromException(exception);
+ A._rootHandleError(type$.Object._as(e), type$.StackTrace._as(s));
+ }
+ },
+ bindCallbackGuarded$1(f) {
+ return new A._RootZone_bindCallbackGuarded_closure(this, type$.void_Function._as(f));
+ },
+ bindUnaryCallbackGuarded$1$1(f, $T) {
+ return new A._RootZone_bindUnaryCallbackGuarded_closure(this, $T._eval$1("~(0)")._as(f), $T);
+ },
+ run$1$1(f, $R) {
+ $R._eval$1("0()")._as(f);
+ if ($.Zone__current === B.C__RootZone)
+ return f.call$0();
+ return A._rootRun(null, null, this, f, $R);
+ },
+ runUnary$2$2(f, arg, $R, $T) {
+ $R._eval$1("@<0>")._bind$1($T)._eval$1("1(2)")._as(f);
+ $T._as(arg);
+ if ($.Zone__current === B.C__RootZone)
+ return f.call$1(arg);
+ return A._rootRunUnary(null, null, this, f, arg, $R, $T);
+ },
+ runBinary$3$3(f, arg1, arg2, $R, T1, T2) {
+ $R._eval$1("@<0>")._bind$1(T1)._bind$1(T2)._eval$1("1(2,3)")._as(f);
+ T1._as(arg1);
+ T2._as(arg2);
+ if ($.Zone__current === B.C__RootZone)
+ return f.call$2(arg1, arg2);
+ return A._rootRunBinary(null, null, this, f, arg1, arg2, $R, T1, T2);
+ },
+ registerBinaryCallback$3$1(f, $R, T1, T2) {
+ return $R._eval$1("@<0>")._bind$1(T1)._bind$1(T2)._eval$1("1(2,3)")._as(f);
+ }
+ };
+ A._RootZone_bindCallbackGuarded_closure.prototype = {
+ call$0() {
+ return this.$this.runGuarded$1(this.f);
+ },
+ $signature: 0
+ };
+ A._RootZone_bindUnaryCallbackGuarded_closure.prototype = {
+ call$1(arg) {
+ var t1 = this.T;
+ return this.$this.runUnaryGuarded$1$2(this.f, t1._as(arg), t1);
+ },
+ $signature() {
+ return this.T._eval$1("~(0)");
+ }
+ };
+ A._HashMap.prototype = {
+ get$length(_) {
+ return this._collection$_length;
+ },
+ get$isEmpty(_) {
+ return this._collection$_length === 0;
+ },
+ get$keys() {
+ return new A._HashMapKeyIterable(this, this.$ti._eval$1("_HashMapKeyIterable<1>"));
+ },
+ containsKey$1(key) {
+ var strings, nums;
+ if (typeof key == "string" && key !== "__proto__") {
+ strings = this._collection$_strings;
+ return strings == null ? false : strings[key] != null;
+ } else if (typeof key == "number" && (key & 1073741823) === key) {
+ nums = this._collection$_nums;
+ return nums == null ? false : nums[key] != null;
+ } else
+ return this._containsKey$1(key);
+ },
+ _containsKey$1(key) {
+ var rest = this._collection$_rest;
+ if (rest == null)
+ return false;
+ return this._findBucketIndex$2(this._getBucket$2(rest, key), key) >= 0;
+ },
+ $index(_, key) {
+ var strings, t1, nums;
+ if (typeof key == "string" && key !== "__proto__") {
+ strings = this._collection$_strings;
+ t1 = strings == null ? null : A._HashMap__getTableEntry(strings, key);
+ return t1;
+ } else if (typeof key == "number" && (key & 1073741823) === key) {
+ nums = this._collection$_nums;
+ t1 = nums == null ? null : A._HashMap__getTableEntry(nums, key);
+ return t1;
+ } else
+ return this._get$1(key);
+ },
+ _get$1(key) {
+ var bucket, index,
+ rest = this._collection$_rest;
+ if (rest == null)
+ return null;
+ bucket = this._getBucket$2(rest, key);
+ index = this._findBucketIndex$2(bucket, key);
+ return index < 0 ? null : bucket[index + 1];
+ },
+ $indexSet(_, key, value) {
+ var strings, nums, rest, hash, bucket, index, _this = this,
+ t1 = _this.$ti;
+ t1._precomputed1._as(key);
+ t1._rest[1]._as(value);
+ if (typeof key == "string" && key !== "__proto__") {
+ strings = _this._collection$_strings;
+ _this._collection$_addHashTableEntry$3(strings == null ? _this._collection$_strings = A._HashMap__newHashTable() : strings, key, value);
+ } else if (typeof key == "number" && (key & 1073741823) === key) {
+ nums = _this._collection$_nums;
+ _this._collection$_addHashTableEntry$3(nums == null ? _this._collection$_nums = A._HashMap__newHashTable() : nums, key, value);
+ } else {
+ rest = _this._collection$_rest;
+ if (rest == null)
+ rest = _this._collection$_rest = A._HashMap__newHashTable();
+ hash = A.objectHashCode(key) & 1073741823;
+ bucket = rest[hash];
+ if (bucket == null) {
+ A._HashMap__setTableEntry(rest, hash, [key, value]);
+ ++_this._collection$_length;
+ _this._collection$_keys = null;
+ } else {
+ index = _this._findBucketIndex$2(bucket, key);
+ if (index >= 0)
+ bucket[index + 1] = value;
+ else {
+ bucket.push(key, value);
+ ++_this._collection$_length;
+ _this._collection$_keys = null;
+ }
+ }
+ }
+ },
+ forEach$1(_, action) {
+ var keys, $length, t2, i, key, t3, _this = this,
+ t1 = _this.$ti;
+ t1._eval$1("~(1,2)")._as(action);
+ keys = _this._computeKeys$0();
+ for ($length = keys.length, t2 = t1._precomputed1, t1 = t1._rest[1], i = 0; i < $length; ++i) {
+ key = keys[i];
+ t2._as(key);
+ t3 = _this.$index(0, key);
+ action.call$2(key, t3 == null ? t1._as(t3) : t3);
+ if (keys !== _this._collection$_keys)
+ throw A.wrapException(A.ConcurrentModificationError$(_this));
+ }
+ },
+ _computeKeys$0() {
+ var strings, names, entries, index, i, nums, rest, bucket, $length, i0, _this = this,
+ result = _this._collection$_keys;
+ if (result != null)
+ return result;
+ result = A.List_List$filled(_this._collection$_length, null, false, type$.dynamic);
+ strings = _this._collection$_strings;
+ if (strings != null) {
+ names = Object.getOwnPropertyNames(strings);
+ entries = names.length;
+ for (index = 0, i = 0; i < entries; ++i) {
+ result[index] = names[i];
+ ++index;
+ }
+ } else
+ index = 0;
+ nums = _this._collection$_nums;
+ if (nums != null) {
+ names = Object.getOwnPropertyNames(nums);
+ entries = names.length;
+ for (i = 0; i < entries; ++i) {
+ result[index] = +names[i];
+ ++index;
+ }
+ }
+ rest = _this._collection$_rest;
+ if (rest != null) {
+ names = Object.getOwnPropertyNames(rest);
+ entries = names.length;
+ for (i = 0; i < entries; ++i) {
+ bucket = rest[names[i]];
+ $length = bucket.length;
+ for (i0 = 0; i0 < $length; i0 += 2) {
+ result[index] = bucket[i0];
+ ++index;
+ }
+ }
+ }
+ return _this._collection$_keys = result;
+ },
+ _collection$_addHashTableEntry$3(table, key, value) {
+ var t1 = this.$ti;
+ t1._precomputed1._as(key);
+ t1._rest[1]._as(value);
+ if (table[key] == null) {
+ ++this._collection$_length;
+ this._collection$_keys = null;
+ }
+ A._HashMap__setTableEntry(table, key, value);
+ },
+ _getBucket$2(table, key) {
+ return table[A.objectHashCode(key) & 1073741823];
+ }
+ };
+ A._IdentityHashMap.prototype = {
+ _findBucketIndex$2(bucket, key) {
+ var $length, i, t1;
+ if (bucket == null)
+ return -1;
+ $length = bucket.length;
+ for (i = 0; i < $length; i += 2) {
+ t1 = bucket[i];
+ if (t1 == null ? key == null : t1 === key)
+ return i;
+ }
+ return -1;
+ }
+ };
+ A._HashMapKeyIterable.prototype = {
+ get$length(_) {
+ return this._collection$_map._collection$_length;
+ },
+ get$isEmpty(_) {
+ return this._collection$_map._collection$_length === 0;
+ },
+ get$iterator(_) {
+ var t1 = this._collection$_map;
+ return new A._HashMapKeyIterator(t1, t1._computeKeys$0(), this.$ti._eval$1("_HashMapKeyIterator<1>"));
+ }
+ };
+ A._HashMapKeyIterator.prototype = {
+ get$current() {
+ var t1 = this._collection$_current;
+ return t1 == null ? this.$ti._precomputed1._as(t1) : t1;
+ },
+ moveNext$0() {
+ var _this = this,
+ keys = _this._collection$_keys,
+ offset = _this._offset,
+ t1 = _this._collection$_map;
+ if (keys !== t1._collection$_keys)
+ throw A.wrapException(A.ConcurrentModificationError$(t1));
+ else if (offset >= keys.length) {
+ _this.set$_collection$_current(null);
+ return false;
+ } else {
+ _this.set$_collection$_current(keys[offset]);
+ _this._offset = offset + 1;
+ return true;
+ }
+ },
+ set$_collection$_current(_current) {
+ this._collection$_current = this.$ti._eval$1("1?")._as(_current);
+ }
+ };
+ A.ListBase.prototype = {
+ get$iterator(receiver) {
+ return new A.ListIterator(receiver, this.get$length(receiver), A.instanceType(receiver)._eval$1("ListIterator<ListBase.E>"));
+ },
+ elementAt$1(receiver, index) {
+ return this.$index(receiver, index);
+ },
+ get$isNotEmpty(receiver) {
+ return this.get$length(receiver) !== 0;
+ },
+ toString$0(receiver) {
+ return A.Iterable_iterableToFullString(receiver, "[", "]");
+ }
+ };
+ A.MapBase.prototype = {
+ forEach$1(_, action) {
+ var t2, key, t3,
+ t1 = A._instanceType(this);
+ t1._eval$1("~(MapBase.K,MapBase.V)")._as(action);
+ for (t2 = this.get$keys(), t2 = t2.get$iterator(t2), t1 = t1._eval$1("MapBase.V"); t2.moveNext$0();) {
+ key = t2.get$current();
+ t3 = this.$index(0, key);
+ action.call$2(key, t3 == null ? t1._as(t3) : t3);
+ }
+ },
+ get$length(_) {
+ var t1 = this.get$keys();
+ return t1.get$length(t1);
+ },
+ get$isEmpty(_) {
+ var t1 = this.get$keys();
+ return t1.get$isEmpty(t1);
+ },
+ toString$0(_) {
+ return A.MapBase_mapToString(this);
+ },
+ $isMap: 1
+ };
+ A.MapBase_mapToString_closure.prototype = {
+ call$2(k, v) {
+ var t2,
+ t1 = this._box_0;
+ if (!t1.first)
+ this.result._contents += ", ";
+ t1.first = false;
+ t1 = this.result;
+ t2 = A.S(k);
+ t2 = t1._contents += t2;
+ t1._contents = t2 + ": ";
+ t2 = A.S(v);
+ t1._contents += t2;
+ },
+ $signature: 10
+ };
+ A._UnmodifiableMapMixin.prototype = {};
+ A.MapView.prototype = {
+ forEach$1(_, action) {
+ this._collection$_map.forEach$1(0, A._instanceType(this)._eval$1("~(1,2)")._as(action));
+ },
+ get$isEmpty(_) {
+ return this._collection$_map.__js_helper$_length === 0;
+ },
+ get$length(_) {
+ return this._collection$_map.__js_helper$_length;
+ },
+ toString$0(_) {
+ return A.MapBase_mapToString(this._collection$_map);
+ },
+ $isMap: 1
+ };
+ A.UnmodifiableMapView.prototype = {};
+ A.ListQueue.prototype = {
+ get$iterator(_) {
+ var _this = this;
+ return new A._ListQueueIterator(_this, _this._tail, _this._modificationCount, _this._head, _this.$ti._eval$1("_ListQueueIterator<1>"));
+ },
+ get$isEmpty(_) {
+ return this._head === this._tail;
+ },
+ get$length(_) {
+ return (this._tail - this._head & this._table.length - 1) >>> 0;
+ },
+ elementAt$1(_, index) {
+ var t2, t3, _this = this,
+ t1 = _this.get$length(0);
+ if (0 > index || index >= t1)
+ A.throwExpression(A.IndexError$withLength(index, t1, _this, null, "index"));
+ t1 = _this._table;
+ t2 = t1.length;
+ t3 = (_this._head + index & t2 - 1) >>> 0;
+ if (!(t3 >= 0 && t3 < t2))
+ return A.ioore(t1, t3);
+ t3 = t1[t3];
+ return t3 == null ? _this.$ti._precomputed1._as(t3) : t3;
+ },
+ toString$0(_) {
+ return A.Iterable_iterableToFullString(this, "{", "}");
+ },
+ removeFirst$0() {
+ var t2, result, _this = this,
+ t1 = _this._head;
+ if (t1 === _this._tail)
+ throw A.wrapException(A.IterableElementError_noElement());
+ ++_this._modificationCount;
+ t2 = _this._table;
+ if (!(t1 < t2.length))
+ return A.ioore(t2, t1);
+ result = t2[t1];
+ if (result == null)
+ result = _this.$ti._precomputed1._as(result);
+ B.JSArray_methods.$indexSet(t2, t1, null);
+ _this._head = (_this._head + 1 & _this._table.length - 1) >>> 0;
+ return result;
+ },
+ _add$1(element) {
+ var t2, t3, newTable, split, _this = this,
+ t1 = _this.$ti;
+ t1._precomputed1._as(element);
+ B.JSArray_methods.$indexSet(_this._table, _this._tail, element);
+ t2 = _this._tail;
+ t3 = _this._table.length;
+ t2 = (t2 + 1 & t3 - 1) >>> 0;
+ _this._tail = t2;
+ if (_this._head === t2) {
+ newTable = A.List_List$filled(t3 * 2, null, false, t1._eval$1("1?"));
+ t1 = _this._table;
+ t2 = _this._head;
+ split = t1.length - t2;
+ B.JSArray_methods.setRange$4(newTable, 0, split, t1, t2);
+ B.JSArray_methods.setRange$4(newTable, split, split + _this._head, _this._table, 0);
+ _this._head = 0;
+ _this._tail = _this._table.length;
+ _this.set$_table(newTable);
+ }
+ ++_this._modificationCount;
+ },
+ set$_table(_table) {
+ this._table = this.$ti._eval$1("List<1?>")._as(_table);
+ },
+ $isQueue: 1
+ };
+ A._ListQueueIterator.prototype = {
+ get$current() {
+ var t1 = this._collection$_current;
+ return t1 == null ? this.$ti._precomputed1._as(t1) : t1;
+ },
+ moveNext$0() {
+ var t2, t3, _this = this,
+ t1 = _this._queue;
+ if (_this._modificationCount !== t1._modificationCount)
+ A.throwExpression(A.ConcurrentModificationError$(t1));
+ t2 = _this._position;
+ if (t2 === _this._end) {
+ _this.set$_collection$_current(null);
+ return false;
+ }
+ t3 = t1._table;
+ if (!(t2 < t3.length))
+ return A.ioore(t3, t2);
+ _this.set$_collection$_current(t3[t2]);
+ _this._position = (_this._position + 1 & t1._table.length - 1) >>> 0;
+ return true;
+ },
+ set$_collection$_current(_current) {
+ this._collection$_current = this.$ti._eval$1("1?")._as(_current);
+ }
+ };
+ A._UnmodifiableMapView_MapView__UnmodifiableMapMixin.prototype = {};
+ A._JsonMap.prototype = {
+ $index(_, key) {
+ var result,
+ t1 = this._processed;
+ if (t1 == null)
+ return this._data.$index(0, key);
+ else if (typeof key != "string")
+ return null;
+ else {
+ result = t1[key];
+ return typeof result == "undefined" ? this._process$1(key) : result;
+ }
+ },
+ get$length(_) {
+ return this._processed == null ? this._data.__js_helper$_length : this._convert$_computeKeys$0().length;
+ },
+ get$isEmpty(_) {
+ return this.get$length(0) === 0;
+ },
+ get$keys() {
+ if (this._processed == null) {
+ var t1 = this._data;
+ return new A.LinkedHashMapKeyIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeyIterable<1>"));
+ }
+ return new A._JsonMapKeyIterable(this);
+ },
+ forEach$1(_, f) {
+ var keys, i, key, value, _this = this;
+ type$.void_Function_String_dynamic._as(f);
+ if (_this._processed == null)
+ return _this._data.forEach$1(0, f);
+ keys = _this._convert$_computeKeys$0();
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ value = _this._processed[key];
+ if (typeof value == "undefined") {
+ value = A._convertJsonToDartLazy(_this._original[key]);
+ _this._processed[key] = value;
+ }
+ f.call$2(key, value);
+ if (keys !== _this._data)
+ throw A.wrapException(A.ConcurrentModificationError$(_this));
+ }
+ },
+ _convert$_computeKeys$0() {
+ var keys = type$.nullable_List_dynamic._as(this._data);
+ if (keys == null)
+ keys = this._data = A._setArrayType(Object.keys(this._original), type$.JSArray_String);
+ return keys;
+ },
+ _process$1(key) {
+ var result;
+ if (!Object.prototype.hasOwnProperty.call(this._original, key))
+ return null;
+ result = A._convertJsonToDartLazy(this._original[key]);
+ return this._processed[key] = result;
+ }
+ };
+ A._JsonMapKeyIterable.prototype = {
+ get$length(_) {
+ return this._parent.get$length(0);
+ },
+ elementAt$1(_, index) {
+ var t1 = this._parent;
+ if (t1._processed == null)
+ t1 = t1.get$keys().elementAt$1(0, index);
+ else {
+ t1 = t1._convert$_computeKeys$0();
+ if (!(index >= 0 && index < t1.length))
+ return A.ioore(t1, index);
+ t1 = t1[index];
+ }
+ return t1;
+ },
+ get$iterator(_) {
+ var t1 = this._parent;
+ if (t1._processed == null) {
+ t1 = t1.get$keys();
+ t1 = t1.get$iterator(t1);
+ } else {
+ t1 = t1._convert$_computeKeys$0();
+ t1 = new J.ArrayIterator(t1, t1.length, A._arrayInstanceType(t1)._eval$1("ArrayIterator<1>"));
+ }
+ return t1;
+ }
+ };
+ A.Codec.prototype = {};
+ A.Converter.prototype = {};
+ A.JsonUnsupportedObjectError.prototype = {
+ toString$0(_) {
+ var safeString = A.Error_safeToString(this.unsupportedObject);
+ return (this.cause != null ? "Converting object to an encodable object failed:" : "Converting object did not return an encodable object:") + " " + safeString;
+ }
+ };
+ A.JsonCyclicError.prototype = {
+ toString$0(_) {
+ return "Cyclic error in JSON stringify";
+ }
+ };
+ A.JsonCodec.prototype = {
+ decode$2$reviver(source, reviver) {
+ var t1 = A._parseJson(source, this.get$decoder()._reviver);
+ return t1;
+ },
+ encode$2$toEncodable(value, toEncodable) {
+ var t1 = A._JsonStringStringifier_stringify(value, this.get$encoder()._toEncodable, null);
+ return t1;
+ },
+ get$encoder() {
+ return B.JsonEncoder_null;
+ },
+ get$decoder() {
+ return B.JsonDecoder_null;
+ }
+ };
+ A.JsonEncoder.prototype = {};
+ A.JsonDecoder.prototype = {};
+ A._JsonStringifier.prototype = {
+ writeStringContent$1(s) {
+ var offset, i, charCode, t1, t2, _this = this,
+ $length = s.length;
+ for (offset = 0, i = 0; i < $length; ++i) {
+ charCode = s.charCodeAt(i);
+ if (charCode > 92) {
+ if (charCode >= 55296) {
+ t1 = charCode & 64512;
+ if (t1 === 55296) {
+ t2 = i + 1;
+ t2 = !(t2 < $length && (s.charCodeAt(t2) & 64512) === 56320);
+ } else
+ t2 = false;
+ if (!t2)
+ if (t1 === 56320) {
+ t1 = i - 1;
+ t1 = !(t1 >= 0 && (s.charCodeAt(t1) & 64512) === 55296);
+ } else
+ t1 = false;
+ else
+ t1 = true;
+ if (t1) {
+ if (i > offset)
+ _this.writeStringSlice$3(s, offset, i);
+ offset = i + 1;
+ _this.writeCharCode$1(92);
+ _this.writeCharCode$1(117);
+ _this.writeCharCode$1(100);
+ t1 = charCode >>> 8 & 15;
+ _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1);
+ t1 = charCode >>> 4 & 15;
+ _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1);
+ t1 = charCode & 15;
+ _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1);
+ }
+ }
+ continue;
+ }
+ if (charCode < 32) {
+ if (i > offset)
+ _this.writeStringSlice$3(s, offset, i);
+ offset = i + 1;
+ _this.writeCharCode$1(92);
+ switch (charCode) {
+ case 8:
+ _this.writeCharCode$1(98);
+ break;
+ case 9:
+ _this.writeCharCode$1(116);
+ break;
+ case 10:
+ _this.writeCharCode$1(110);
+ break;
+ case 12:
+ _this.writeCharCode$1(102);
+ break;
+ case 13:
+ _this.writeCharCode$1(114);
+ break;
+ default:
+ _this.writeCharCode$1(117);
+ _this.writeCharCode$1(48);
+ _this.writeCharCode$1(48);
+ t1 = charCode >>> 4 & 15;
+ _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1);
+ t1 = charCode & 15;
+ _this.writeCharCode$1(t1 < 10 ? 48 + t1 : 87 + t1);
+ break;
+ }
+ } else if (charCode === 34 || charCode === 92) {
+ if (i > offset)
+ _this.writeStringSlice$3(s, offset, i);
+ offset = i + 1;
+ _this.writeCharCode$1(92);
+ _this.writeCharCode$1(charCode);
+ }
+ }
+ if (offset === 0)
+ _this.writeString$1(s);
+ else if (offset < $length)
+ _this.writeStringSlice$3(s, offset, $length);
+ },
+ _checkCycle$1(object) {
+ var t1, t2, i, t3;
+ for (t1 = this._seen, t2 = t1.length, i = 0; i < t2; ++i) {
+ t3 = t1[i];
+ if (object == null ? t3 == null : object === t3)
+ throw A.wrapException(new A.JsonCyclicError(object, null));
+ }
+ B.JSArray_methods.add$1(t1, object);
+ },
+ writeObject$1(object) {
+ var customJson, e, t1, exception, _this = this;
+ if (_this.writeJsonValue$1(object))
+ return;
+ _this._checkCycle$1(object);
+ try {
+ customJson = _this._toEncodable.call$1(object);
+ if (!_this.writeJsonValue$1(customJson)) {
+ t1 = A.JsonUnsupportedObjectError$(object, null, _this.get$_partialResult());
+ throw A.wrapException(t1);
+ }
+ t1 = _this._seen;
+ if (0 >= t1.length)
+ return A.ioore(t1, -1);
+ t1.pop();
+ } catch (exception) {
+ e = A.unwrapException(exception);
+ t1 = A.JsonUnsupportedObjectError$(object, e, _this.get$_partialResult());
+ throw A.wrapException(t1);
+ }
+ },
+ writeJsonValue$1(object) {
+ var t1, success, _this = this;
+ if (typeof object == "number") {
+ if (!isFinite(object))
+ return false;
+ _this.writeNumber$1(object);
+ return true;
+ } else if (object === true) {
+ _this.writeString$1("true");
+ return true;
+ } else if (object === false) {
+ _this.writeString$1("false");
+ return true;
+ } else if (object == null) {
+ _this.writeString$1("null");
+ return true;
+ } else if (typeof object == "string") {
+ _this.writeString$1('"');
+ _this.writeStringContent$1(object);
+ _this.writeString$1('"');
+ return true;
+ } else if (type$.List_dynamic._is(object)) {
+ _this._checkCycle$1(object);
+ _this.writeList$1(object);
+ t1 = _this._seen;
+ if (0 >= t1.length)
+ return A.ioore(t1, -1);
+ t1.pop();
+ return true;
+ } else if (type$.Map_dynamic_dynamic._is(object)) {
+ _this._checkCycle$1(object);
+ success = _this.writeMap$1(object);
+ t1 = _this._seen;
+ if (0 >= t1.length)
+ return A.ioore(t1, -1);
+ t1.pop();
+ return success;
+ } else
+ return false;
+ },
+ writeList$1(list) {
+ var t1, i, _this = this;
+ _this.writeString$1("[");
+ t1 = J.getInterceptor$asx(list);
+ if (t1.get$isNotEmpty(list)) {
+ _this.writeObject$1(t1.$index(list, 0));
+ for (i = 1; i < t1.get$length(list); ++i) {
+ _this.writeString$1(",");
+ _this.writeObject$1(t1.$index(list, i));
+ }
+ }
+ _this.writeString$1("]");
+ },
+ writeMap$1(map) {
+ var t1, keyValueList, i, separator, t2, _this = this, _box_0 = {};
+ if (map.get$isEmpty(map)) {
+ _this.writeString$1("{}");
+ return true;
+ }
+ t1 = map.get$length(map) * 2;
+ keyValueList = A.List_List$filled(t1, null, false, type$.nullable_Object);
+ i = _box_0.i = 0;
+ _box_0.allStringKeys = true;
+ map.forEach$1(0, new A._JsonStringifier_writeMap_closure(_box_0, keyValueList));
+ if (!_box_0.allStringKeys)
+ return false;
+ _this.writeString$1("{");
+ for (separator = '"'; i < t1; i += 2, separator = ',"') {
+ _this.writeString$1(separator);
+ _this.writeStringContent$1(A._asString(keyValueList[i]));
+ _this.writeString$1('":');
+ t2 = i + 1;
+ if (!(t2 < t1))
+ return A.ioore(keyValueList, t2);
+ _this.writeObject$1(keyValueList[t2]);
+ }
+ _this.writeString$1("}");
+ return true;
+ }
+ };
+ A._JsonStringifier_writeMap_closure.prototype = {
+ call$2(key, value) {
+ var t1, t2;
+ if (typeof key != "string")
+ this._box_0.allStringKeys = false;
+ t1 = this.keyValueList;
+ t2 = this._box_0;
+ B.JSArray_methods.$indexSet(t1, t2.i++, key);
+ B.JSArray_methods.$indexSet(t1, t2.i++, value);
+ },
+ $signature: 10
+ };
+ A._JsonStringStringifier.prototype = {
+ get$_partialResult() {
+ var t1 = this._sink._contents;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ writeNumber$1(number) {
+ var t1 = this._sink,
+ t2 = B.JSNumber_methods.toString$0(number);
+ t1._contents += t2;
+ },
+ writeString$1(string) {
+ this._sink._contents += string;
+ },
+ writeStringSlice$3(string, start, end) {
+ this._sink._contents += B.JSString_methods.substring$2(string, start, end);
+ },
+ writeCharCode$1(charCode) {
+ var t1 = this._sink,
+ t2 = A.Primitives_stringFromCharCode(charCode);
+ t1._contents += t2;
+ }
+ };
+ A.NoSuchMethodError_toString_closure.prototype = {
+ call$2(key, value) {
+ var t1, t2, t3;
+ type$.Symbol._as(key);
+ t1 = this.sb;
+ t2 = this._box_0;
+ t3 = t1._contents += t2.comma;
+ t3 += key._name;
+ t1._contents = t3;
+ t1._contents = t3 + ": ";
+ t3 = A.Error_safeToString(value);
+ t1._contents += t3;
+ t2.comma = ", ";
+ },
+ $signature: 19
+ };
+ A.DateTime.prototype = {
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ return other instanceof A.DateTime && this._value === other._value && this.isUtc === other.isUtc;
+ },
+ get$hashCode(_) {
+ var t1 = this._value;
+ return (t1 ^ B.JSInt_methods._shrOtherPositive$1(t1, 30)) & 1073741823;
+ },
+ toString$0(_) {
+ var _this = this,
+ y = A.DateTime__fourDigits(A.Primitives_getYear(_this)),
+ m = A.DateTime__twoDigits(A.Primitives_getMonth(_this)),
+ d = A.DateTime__twoDigits(A.Primitives_getDay(_this)),
+ h = A.DateTime__twoDigits(A.Primitives_getHours(_this)),
+ min = A.DateTime__twoDigits(A.Primitives_getMinutes(_this)),
+ sec = A.DateTime__twoDigits(A.Primitives_getSeconds(_this)),
+ ms = A.DateTime__threeDigits(A.Primitives_getMilliseconds(_this)),
+ t1 = y + "-" + m;
+ if (_this.isUtc)
+ return t1 + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + "Z";
+ else
+ return t1 + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms;
+ }
+ };
+ A.Duration.prototype = {
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ return other instanceof A.Duration && this._duration === other._duration;
+ },
+ get$hashCode(_) {
+ return B.JSInt_methods.get$hashCode(this._duration);
+ },
+ toString$0(_) {
+ var minutesPadding, seconds, secondsPadding,
+ microseconds = this._duration,
+ microseconds0 = microseconds % 3600000000,
+ minutes = B.JSInt_methods._tdivFast$1(microseconds0, 60000000);
+ microseconds0 %= 60000000;
+ minutesPadding = minutes < 10 ? "0" : "";
+ seconds = B.JSInt_methods._tdivFast$1(microseconds0, 1000000);
+ secondsPadding = seconds < 10 ? "0" : "";
+ return "" + (microseconds / 3600000000 | 0) + ":" + minutesPadding + minutes + ":" + secondsPadding + seconds + "." + B.JSString_methods.padLeft$2(B.JSInt_methods.toString$0(microseconds0 % 1000000), 6, "0");
+ }
+ };
+ A.Error.prototype = {
+ get$stackTrace() {
+ return A.getTraceFromException(this.$thrownJsError);
+ }
+ };
+ A.AssertionError.prototype = {
+ toString$0(_) {
+ var t1 = this.message;
+ if (t1 != null)
+ return "Assertion failed: " + A.Error_safeToString(t1);
+ return "Assertion failed";
+ }
+ };
+ A.TypeError.prototype = {};
+ A.ArgumentError.prototype = {
+ get$_errorName() {
+ return "Invalid argument" + (!this._hasValue ? "(s)" : "");
+ },
+ get$_errorExplanation() {
+ return "";
+ },
+ toString$0(_) {
+ var _this = this,
+ $name = _this.name,
+ nameString = $name == null ? "" : " (" + $name + ")",
+ message = _this.message,
+ messageString = message == null ? "" : ": " + A.S(message),
+ prefix = _this.get$_errorName() + nameString + messageString;
+ if (!_this._hasValue)
+ return prefix;
+ return prefix + _this.get$_errorExplanation() + ": " + A.Error_safeToString(_this.get$invalidValue());
+ },
+ get$invalidValue() {
+ return this.invalidValue;
+ }
+ };
+ A.RangeError.prototype = {
+ get$invalidValue() {
+ return A._asNumQ(this.invalidValue);
+ },
+ get$_errorName() {
+ return "RangeError";
+ },
+ get$_errorExplanation() {
+ var explanation,
+ start = this.start,
+ end = this.end;
+ if (start == null)
+ explanation = end != null ? ": Not less than or equal to " + A.S(end) : "";
+ else if (end == null)
+ explanation = ": Not greater than or equal to " + A.S(start);
+ else if (end > start)
+ explanation = ": Not in inclusive range " + A.S(start) + ".." + A.S(end);
+ else
+ explanation = end < start ? ": Valid value range is empty" : ": Only valid value is " + A.S(start);
+ return explanation;
+ }
+ };
+ A.IndexError.prototype = {
+ get$invalidValue() {
+ return A._asInt(this.invalidValue);
+ },
+ get$_errorName() {
+ return "RangeError";
+ },
+ get$_errorExplanation() {
+ if (A._asInt(this.invalidValue) < 0)
+ return ": index must not be negative";
+ var t1 = this.length;
+ if (t1 === 0)
+ return ": no indices are valid";
+ return ": index should be less than " + t1;
+ },
+ get$length(receiver) {
+ return this.length;
+ }
+ };
+ A.NoSuchMethodError.prototype = {
+ toString$0(_) {
+ var $arguments, t1, _i, t2, t3, argument, receiverText, actualParameters, _this = this, _box_0 = {},
+ sb = new A.StringBuffer("");
+ _box_0.comma = "";
+ $arguments = _this._core$_arguments;
+ for (t1 = $arguments.length, _i = 0, t2 = "", t3 = ""; _i < t1; ++_i, t3 = ", ") {
+ argument = $arguments[_i];
+ sb._contents = t2 + t3;
+ t2 = A.Error_safeToString(argument);
+ t2 = sb._contents += t2;
+ _box_0.comma = ", ";
+ }
+ _this._namedArguments.forEach$1(0, new A.NoSuchMethodError_toString_closure(_box_0, sb));
+ receiverText = A.Error_safeToString(_this._core$_receiver);
+ actualParameters = sb.toString$0(0);
+ return "NoSuchMethodError: method not found: '" + _this._core$_memberName._name + "'\nReceiver: " + receiverText + "\nArguments: [" + actualParameters + "]";
+ }
+ };
+ A.UnsupportedError.prototype = {
+ toString$0(_) {
+ return "Unsupported operation: " + this.message;
+ }
+ };
+ A.UnimplementedError.prototype = {
+ toString$0(_) {
+ return "UnimplementedError: " + this.message;
+ }
+ };
+ A.StateError.prototype = {
+ toString$0(_) {
+ return "Bad state: " + this.message;
+ }
+ };
+ A.ConcurrentModificationError.prototype = {
+ toString$0(_) {
+ var t1 = this.modifiedObject;
+ if (t1 == null)
+ return "Concurrent modification during iteration.";
+ return "Concurrent modification during iteration: " + A.Error_safeToString(t1) + ".";
+ }
+ };
+ A.OutOfMemoryError.prototype = {
+ toString$0(_) {
+ return "Out of Memory";
+ },
+ get$stackTrace() {
+ return null;
+ },
+ $isError: 1
+ };
+ A.StackOverflowError.prototype = {
+ toString$0(_) {
+ return "Stack Overflow";
+ },
+ get$stackTrace() {
+ return null;
+ },
+ $isError: 1
+ };
+ A._Exception.prototype = {
+ toString$0(_) {
+ return "Exception: " + this.message;
+ }
+ };
+ A.FormatException.prototype = {
+ toString$0(_) {
+ var t1, lineEnd, lineNum, lineStart, previousCharWasCR, i, char, end, start, prefix, postfix,
+ message = this.message,
+ report = "" !== message ? "FormatException: " + message : "FormatException",
+ offset = this.offset,
+ source = this.source;
+ if (typeof source == "string") {
+ if (offset != null)
+ t1 = offset < 0 || offset > source.length;
+ else
+ t1 = false;
+ if (t1)
+ offset = null;
+ if (offset == null) {
+ if (source.length > 78)
+ source = B.JSString_methods.substring$2(source, 0, 75) + "...";
+ return report + "\n" + source;
+ }
+ for (lineEnd = source.length, lineNum = 1, lineStart = 0, previousCharWasCR = false, i = 0; i < offset; ++i) {
+ if (!(i < lineEnd))
+ return A.ioore(source, i);
+ char = source.charCodeAt(i);
+ if (char === 10) {
+ if (lineStart !== i || !previousCharWasCR)
+ ++lineNum;
+ lineStart = i + 1;
+ previousCharWasCR = false;
+ } else if (char === 13) {
+ ++lineNum;
+ lineStart = i + 1;
+ previousCharWasCR = true;
+ }
+ }
+ report = lineNum > 1 ? report + (" (at line " + lineNum + ", character " + (offset - lineStart + 1) + ")\n") : report + (" (at character " + (offset + 1) + ")\n");
+ for (i = offset; i < lineEnd; ++i) {
+ if (!(i >= 0))
+ return A.ioore(source, i);
+ char = source.charCodeAt(i);
+ if (char === 10 || char === 13) {
+ lineEnd = i;
+ break;
+ }
+ }
+ if (lineEnd - lineStart > 78)
+ if (offset - lineStart < 75) {
+ end = lineStart + 75;
+ start = lineStart;
+ prefix = "";
+ postfix = "...";
+ } else {
+ if (lineEnd - offset < 75) {
+ start = lineEnd - 75;
+ end = lineEnd;
+ postfix = "";
+ } else {
+ start = offset - 36;
+ end = offset + 36;
+ postfix = "...";
+ }
+ prefix = "...";
+ }
+ else {
+ end = lineEnd;
+ start = lineStart;
+ prefix = "";
+ postfix = "";
+ }
+ return report + prefix + B.JSString_methods.substring$2(source, start, end) + postfix + "\n" + B.JSString_methods.$mul(" ", offset - start + prefix.length) + "^\n";
+ } else
+ return offset != null ? report + (" (at offset " + A.S(offset) + ")") : report;
+ }
+ };
+ A.Iterable.prototype = {
+ get$length(_) {
+ var count,
+ it = this.get$iterator(this);
+ for (count = 0; it.moveNext$0();)
+ ++count;
+ return count;
+ },
+ elementAt$1(_, index) {
+ var iterator, skipCount;
+ A.RangeError_checkNotNegative(index, "index");
+ iterator = this.get$iterator(this);
+ for (skipCount = index; iterator.moveNext$0();) {
+ if (skipCount === 0)
+ return iterator.get$current();
+ --skipCount;
+ }
+ throw A.wrapException(A.IndexError$withLength(index, index - skipCount, this, null, "index"));
+ },
+ toString$0(_) {
+ return A.Iterable_iterableToShortString(this, "(", ")");
+ }
+ };
+ A.Null.prototype = {
+ get$hashCode(_) {
+ return A.Object.prototype.get$hashCode.call(this, 0);
+ },
+ toString$0(_) {
+ return "null";
+ }
+ };
+ A.Object.prototype = {$isObject: 1,
+ $eq(_, other) {
+ return this === other;
+ },
+ get$hashCode(_) {
+ return A.Primitives_objectHashCode(this);
+ },
+ toString$0(_) {
+ return "Instance of '" + A.Primitives_objectTypeName(this) + "'";
+ },
+ noSuchMethod$1(_, invocation) {
+ throw A.wrapException(A.NoSuchMethodError_NoSuchMethodError$withInvocation(this, type$.Invocation._as(invocation)));
+ },
+ get$runtimeType(_) {
+ return A.getRuntimeTypeOfDartObject(this);
+ },
+ toString() {
+ return this.toString$0(this);
+ }
+ };
+ A._StringStackTrace.prototype = {
+ toString$0(_) {
+ return this._stackTrace;
+ },
+ $isStackTrace: 1
+ };
+ A.StringBuffer.prototype = {
+ get$length(_) {
+ return this._contents.length;
+ },
+ toString$0(_) {
+ var t1 = this._contents;
+ return t1.charCodeAt(0) == 0 ? t1 : t1;
+ },
+ $isStringSink: 1
+ };
+ A.promiseToFuture_closure.prototype = {
+ call$1(r) {
+ return this.completer.complete$1(this.T._eval$1("0/?")._as(r));
+ },
+ $signature: 3
+ };
+ A.promiseToFuture_closure0.prototype = {
+ call$1(e) {
+ if (e == null)
+ return this.completer.completeError$1(new A.NullRejectionException(e === undefined));
+ return this.completer.completeError$1(e);
+ },
+ $signature: 3
+ };
+ A.dartify_convert.prototype = {
+ call$1(o) {
+ var t1, millisSinceEpoch, proto, t2, dartObject, originalKeys, dartKeys, i, jsKey, dartKey, l, $length;
+ if (A._noDartifyRequired(o))
+ return o;
+ t1 = this._convertedObjects;
+ o.toString;
+ if (t1.containsKey$1(o))
+ return t1.$index(0, o);
+ if (o instanceof Date) {
+ millisSinceEpoch = o.getTime();
+ if (Math.abs(millisSinceEpoch) > 864e13)
+ A.throwExpression(A.ArgumentError$("DateTime is outside valid range: " + millisSinceEpoch, null));
+ A.checkNotNullable(true, "isUtc", type$.bool);
+ return new A.DateTime(millisSinceEpoch, true);
+ }
+ if (o instanceof RegExp)
+ throw A.wrapException(A.ArgumentError$("structured clone of RegExp", null));
+ if (typeof Promise != "undefined" && o instanceof Promise)
+ return A.promiseToFuture(o, type$.nullable_Object);
+ proto = Object.getPrototypeOf(o);
+ if (proto === Object.prototype || proto === null) {
+ t2 = type$.nullable_Object;
+ dartObject = A.LinkedHashMap_LinkedHashMap$_empty(t2, t2);
+ t1.$indexSet(0, o, dartObject);
+ originalKeys = Object.keys(o);
+ dartKeys = [];
+ for (t1 = J.getInterceptor$ax(originalKeys), t2 = t1.get$iterator(originalKeys); t2.moveNext$0();)
+ dartKeys.push(A.dartify(t2.get$current()));
+ for (i = 0; i < t1.get$length(originalKeys); ++i) {
+ jsKey = t1.$index(originalKeys, i);
+ if (!(i < dartKeys.length))
+ return A.ioore(dartKeys, i);
+ dartKey = dartKeys[i];
+ if (jsKey != null)
+ dartObject.$indexSet(0, dartKey, this.call$1(o[jsKey]));
+ }
+ return dartObject;
+ }
+ if (o instanceof Array) {
+ l = o;
+ dartObject = [];
+ t1.$indexSet(0, o, dartObject);
+ $length = A._asInt(o.length);
+ for (t1 = J.getInterceptor$asx(l), i = 0; i < $length; ++i)
+ dartObject.push(this.call$1(t1.$index(l, i)));
+ return dartObject;
+ }
+ return o;
+ },
+ $signature: 20
+ };
+ A.NullRejectionException.prototype = {
+ toString$0(_) {
+ return "Promise was rejected with a value of `" + (this.isUndefined ? "undefined" : "null") + "`.";
+ }
+ };
+ A._JSRandom.prototype = {
+ nextInt$1(max) {
+ if (max <= 0 || max > 4294967296)
+ throw A.wrapException(A.RangeError$("max must be in range 0 < max \u2264 2^32, was " + max));
+ return Math.random() * max >>> 0;
+ }
+ };
+ A.AsyncMemoizer.prototype = {};
+ A.Level.prototype = {
+ $eq(_, other) {
+ if (other == null)
+ return false;
+ return other instanceof A.Level && this.value === other.value;
+ },
+ get$hashCode(_) {
+ return this.value;
+ },
+ toString$0(_) {
+ return this.name;
+ }
+ };
+ A.LogRecord.prototype = {
+ toString$0(_) {
+ return "[" + this.level.name + "] " + this.loggerName + ": " + this.message;
+ }
+ };
+ A.Logger.prototype = {
+ get$fullName() {
+ var t1 = this.parent,
+ t2 = t1 == null ? null : t1.name.length !== 0,
+ t3 = this.name;
+ return t2 === true ? t1.get$fullName() + "." + t3 : t3;
+ },
+ get$level() {
+ var t1, effectiveLevel;
+ if (this.parent == null) {
+ t1 = this._level;
+ t1.toString;
+ effectiveLevel = t1;
+ } else {
+ t1 = $.$get$Logger_root()._level;
+ t1.toString;
+ effectiveLevel = t1;
+ }
+ return effectiveLevel;
+ },
+ log$4(logLevel, message, error, stackTrace) {
+ var record, _this = this,
+ t1 = logLevel.value;
+ if (t1 >= _this.get$level().value) {
+ if (t1 >= 2000) {
+ A.StackTrace_current();
+ logLevel.toString$0(0);
+ }
+ t1 = _this.get$fullName();
+ Date.now();
+ $.LogRecord__nextNumber = $.LogRecord__nextNumber + 1;
+ record = new A.LogRecord(logLevel, message, t1);
+ if (_this.parent == null)
+ _this._publish$1(record);
+ else
+ $.$get$Logger_root()._publish$1(record);
+ }
+ },
+ _publish$1(record) {
+ return null;
+ }
+ };
+ A.Logger_Logger_closure.prototype = {
+ call$0() {
+ var dot, $parent, t1,
+ thisName = this.name;
+ if (B.JSString_methods.startsWith$1(thisName, "."))
+ A.throwExpression(A.ArgumentError$("name shouldn't start with a '.'", null));
+ if (B.JSString_methods.endsWith$1(thisName, "."))
+ A.throwExpression(A.ArgumentError$("name shouldn't end with a '.'", null));
+ dot = B.JSString_methods.lastIndexOf$1(thisName, ".");
+ if (dot === -1)
+ $parent = thisName !== "" ? A.Logger_Logger("") : null;
+ else {
+ $parent = A.Logger_Logger(B.JSString_methods.substring$2(thisName, 0, dot));
+ thisName = B.JSString_methods.substring$1(thisName, dot + 1);
+ }
+ t1 = new A.Logger(thisName, $parent, A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Logger));
+ if ($parent == null)
+ t1._level = B.Level_INFO_800;
+ else
+ $parent._children.$indexSet(0, thisName, t1);
+ return t1;
+ },
+ $signature: 21
+ };
+ A.Pool.prototype = {
+ request$0() {
+ var t1, t2, _this = this;
+ if ((_this._closeMemo._completer.future._state & 30) !== 0)
+ throw A.wrapException(A.StateError$("request() may not be called on a closed Pool."));
+ t1 = _this._allocatedResources;
+ if (t1 < _this._maxAllocatedResources) {
+ _this._allocatedResources = t1 + 1;
+ return A.Future_Future$value(new A.PoolResource(_this), type$.PoolResource);
+ } else {
+ t1 = _this._onReleaseCallbacks;
+ if (!t1.get$isEmpty(0))
+ return _this._runOnRelease$1(t1.removeFirst$0());
+ else {
+ t1 = new A._Future($.Zone__current, type$._Future_PoolResource);
+ t2 = _this._requestedResources;
+ t2._add$1(t2.$ti._precomputed1._as(new A._AsyncCompleter(t1, type$._AsyncCompleter_PoolResource)));
+ _this._resetTimer$0();
+ return t1;
+ }
+ }
+ },
+ withResource$1$1(callback, $T) {
+ return this.withResource$body$Pool($T._eval$1("0/()")._as(callback), $T, $T);
+ },
+ withResource$body$Pool(callback, $T, $async$type) {
+ var $async$goto = 0,
+ $async$completer = A._makeAsyncAwaitCompleter($async$type),
+ $async$returnValue, $async$handler = 2, $async$currentError, $async$next = [], $async$self = this, resource, t1, t2;
+ var $async$withResource$1$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) {
+ if ($async$errorCode === 1) {
+ $async$currentError = $async$result;
+ $async$goto = $async$handler;
+ }
+ while (true)
+ switch ($async$goto) {
+ case 0:
+ // Function start
+ if (($async$self._closeMemo._completer.future._state & 30) !== 0)
+ throw A.wrapException(A.StateError$("withResource() may not be called on a closed Pool."));
+ $async$goto = 3;
+ return A._asyncAwait($async$self.request$0(), $async$withResource$1$1);
+ case 3:
+ // returning from await.
+ resource = $async$result;
+ $async$handler = 4;
+ t1 = callback.call$0();
+ $async$goto = 7;
+ return A._asyncAwait($T._eval$1("Future<0>")._is(t1) ? t1 : A._Future$value($T._as(t1), $T), $async$withResource$1$1);
+ case 7:
+ // returning from await.
+ t1 = $async$result;
+ $async$returnValue = t1;
+ $async$next = [1];
+ // goto finally
+ $async$goto = 5;
+ break;
+ $async$next.push(6);
+ // goto finally
+ $async$goto = 5;
+ break;
+ case 4:
+ // uncaught
+ $async$next = [2];
+ case 5:
+ // finally
+ $async$handler = 2;
+ t1 = resource;
+ if (t1._released)
+ A.throwExpression(A.StateError$("A PoolResource may only be released once."));
+ t1._released = true;
+ t1 = t1._pool;
+ t1._resetTimer$0();
+ t2 = t1._requestedResources;
+ if (!t2.get$isEmpty(0))
+ t2.removeFirst$0().complete$1(new A.PoolResource(t1));
+ else {
+ t2 = --t1._allocatedResources;
+ if ((t1._closeMemo._completer.future._state & 30) !== 0 && t2 === 0)
+ null.close$0();
+ }
+ // goto the next finally handler
+ $async$goto = $async$next.pop();
+ break;
+ case 6:
+ // after finally
+ case 1:
+ // return
+ return A._asyncReturn($async$returnValue, $async$completer);
+ case 2:
+ // rethrow
+ return A._asyncRethrow($async$currentError, $async$completer);
+ }
+ });
+ return A._asyncStartSync($async$withResource$1$1, $async$completer);
+ },
+ _runOnRelease$1(onRelease) {
+ var t1 = A.Future_Future$sync(type$.dynamic_Function._as(onRelease), type$.dynamic).then$1$1(new A.Pool__runOnRelease_closure(this), type$.Null),
+ onError = new A.Pool__runOnRelease_closure0(this),
+ t2 = t1.$ti,
+ t3 = $.Zone__current;
+ if (t3 !== B.C__RootZone)
+ onError = A._registerErrorHandler(onError, t3);
+ t1._addListener$1(new A._FutureListener(new A._Future(t3, t2), 2, null, onError, t2._eval$1("@<1>")._bind$1(t2._precomputed1)._eval$1("_FutureListener<1,2>")));
+ t1 = new A._Future($.Zone__current, type$._Future_PoolResource);
+ t2 = this._onReleaseCompleters;
+ t2._add$1(t2.$ti._precomputed1._as(new A._SyncCompleter(t1, type$._SyncCompleter_PoolResource)));
+ return t1;
+ },
+ _resetTimer$0() {
+ var t2,
+ t1 = this._timer;
+ if (t1 == null)
+ return;
+ t2 = this._requestedResources;
+ if (t2._head === t2._tail)
+ t1._restartable_timer$_timer.cancel$0();
+ else {
+ t1._restartable_timer$_timer.cancel$0();
+ t1._restartable_timer$_timer = A.Timer_Timer(t1._restartable_timer$_duration, t1._callback);
+ }
+ }
+ };
+ A.Pool__runOnRelease_closure.prototype = {
+ call$1(value) {
+ var t1 = this.$this;
+ t1._onReleaseCompleters.removeFirst$0().complete$1(new A.PoolResource(t1));
+ },
+ $signature: 4
+ };
+ A.Pool__runOnRelease_closure0.prototype = {
+ call$2(error, stackTrace) {
+ type$.Object._as(error);
+ type$.StackTrace._as(stackTrace);
+ this.$this._onReleaseCompleters.removeFirst$0().completeError$2(error, stackTrace);
+ },
+ $signature: 5
+ };
+ A.PoolResource.prototype = {};
+ A.SseClient.prototype = {
+ SseClient$2$debugKey(serverUrl, debugKey) {
+ var t2, t3, _this = this,
+ t1 = serverUrl + "?sseClientId=" + _this._clientId;
+ _this.__SseClient__serverUrl_A = t1;
+ t2 = type$.JSObject;
+ t1 = t2._as(new self.EventSource(t1, {withCredentials: true}));
+ _this.__SseClient__eventSource_A = t1;
+ new A._EventStream(t1, "open", false, type$._EventStream_JSObject).get$first(0).whenComplete$1(new A.SseClient_closure(_this));
+ t1 = type$.Function;
+ t3 = type$.JavaScriptFunction;
+ _this.__SseClient__eventSource_A.addEventListener("message", t3._as(A.allowInterop(_this.get$_onIncomingMessage(), t1)));
+ _this.__SseClient__eventSource_A.addEventListener("control", t3._as(A.allowInterop(_this.get$_onIncomingControlMessage(), t1)));
+ t1 = type$.nullable_void_Function_JSObject;
+ A._EventStreamSubscription$(_this.__SseClient__eventSource_A, "open", t1._as(new A.SseClient_closure0(_this)), false, t2);
+ A._EventStreamSubscription$(_this.__SseClient__eventSource_A, "error", t1._as(new A.SseClient_closure1(_this)), false, t2);
+ },
+ close$0() {
+ var _this = this,
+ t1 = _this.__SseClient__eventSource_A;
+ t1 === $ && A.throwLateFieldNI("_eventSource");
+ t1.close();
+ if ((_this._onConnected.future._state & 30) === 0) {
+ t1 = _this._outgoingController;
+ new A._ControllerStream(t1, A._instanceType(t1)._eval$1("_ControllerStream<1>")).listen$2$cancelOnError(null, true).asFuture$1$1(null, type$.void);
+ }
+ _this._incomingController.close$0();
+ _this._outgoingController.close$0();
+ },
+ _closeWithError$1(error) {
+ var stackTrace, t2,
+ t1 = this._incomingController;
+ A.checkNotNullable(error, "error", type$.Object);
+ if (t1._state >= 4)
+ A.throwExpression(t1._badEventState$0());
+ stackTrace = A.AsyncError_defaultStackTrace(error);
+ t2 = t1._state;
+ if ((t2 & 1) !== 0)
+ t1._sendError$2(error, stackTrace);
+ else if ((t2 & 3) === 0)
+ t1._ensurePendingEvents$0().add$1(0, new A._DelayedError(error, stackTrace));
+ this.close$0();
+ t1 = this._onConnected;
+ if ((t1.future._state & 30) === 0)
+ t1.completeError$1(error);
+ },
+ _onIncomingControlMessage$1(message) {
+ var data = type$.JSObject._as(message).data;
+ if (J.$eq$(A.dartify(data), "close"))
+ this.close$0();
+ else
+ throw A.wrapException(A.UnsupportedError$("[" + this._clientId + '] Illegal Control Message "' + A.S(data) + '"'));
+ },
+ _onIncomingMessage$1(message) {
+ this._incomingController.add$1(0, A._asString(B.C_JsonCodec.decode$2$reviver(A._asString(type$.JSObject._as(message).data), null)));
+ },
+ _onOutgoingDone$0() {
+ this.close$0();
+ },
+ _onOutgoingMessage$1(message) {
+ return this._onOutgoingMessage$body$SseClient(A._asStringQ(message));
+ },
+ _onOutgoingMessage$body$SseClient(message) {
+ var $async$goto = 0,
+ $async$completer = A._makeAsyncAwaitCompleter(type$.void),
+ $async$self = this, t1;
+ var $async$_onOutgoingMessage$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) {
+ if ($async$errorCode === 1)
+ return A._asyncRethrow($async$result, $async$completer);
+ while (true)
+ switch ($async$goto) {
+ case 0:
+ // Function start
+ t1 = {};
+ t1.encodedMessage = null;
+ $async$goto = 2;
+ return A._asyncAwait($.$get$_requestPool().withResource$1$1(new A.SseClient__onOutgoingMessage_closure(t1, $async$self, message), type$.Null), $async$_onOutgoingMessage$1);
+ case 2:
+ // returning from await.
+ // implicit return
+ return A._asyncReturn(null, $async$completer);
+ }
+ });
+ return A._asyncStartSync($async$_onOutgoingMessage$1, $async$completer);
+ }
+ };
+ A.SseClient_closure.prototype = {
+ call$0() {
+ var t2,
+ t1 = this.$this;
+ t1._onConnected.complete$0();
+ t2 = t1._outgoingController;
+ new A._ControllerStream(t2, A._instanceType(t2)._eval$1("_ControllerStream<1>")).listen$2$onDone(t1.get$_onOutgoingMessage(), t1.get$_onOutgoingDone());
+ },
+ $signature: 2
+ };
+ A.SseClient_closure0.prototype = {
+ call$1(_) {
+ var t1 = this.$this._errorTimer;
+ if (t1 != null)
+ t1.cancel$0();
+ },
+ $signature: 1
+ };
+ A.SseClient_closure1.prototype = {
+ call$1(error) {
+ var t1 = this.$this,
+ t2 = t1._errorTimer;
+ t2 = t2 == null ? null : t2._handle != null;
+ if (t2 !== true)
+ t1._errorTimer = A.Timer_Timer(B.Duration_5000000, new A.SseClient__closure(t1, error));
+ },
+ $signature: 1
+ };
+ A.SseClient__closure.prototype = {
+ call$0() {
+ this.$this._closeWithError$1(this.error);
+ },
+ $signature: 0
+ };
+ A.SseClient__onOutgoingMessage_closure.prototype = {
+ call$0() {
+ var $async$goto = 0,
+ $async$completer = A._makeAsyncAwaitCompleter(type$.Null),
+ $async$handler = 1, $async$currentError, $async$self = this, e, e0, url, error, augmentedError, exception, t1, t2, $async$exception;
+ var $async$call$0 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) {
+ if ($async$errorCode === 1) {
+ $async$currentError = $async$result;
+ $async$goto = $async$handler;
+ }
+ while (true)
+ switch ($async$goto) {
+ case 0:
+ // Function start
+ try {
+ $async$self._box_0.encodedMessage = B.C_JsonCodec.encode$2$toEncodable($async$self.message, null);
+ } catch (exception) {
+ t1 = A.unwrapException(exception);
+ if (t1 instanceof A.JsonUnsupportedObjectError) {
+ e = t1;
+ t1 = $async$self.$this;
+ t1._logger.log$4(B.Level_WARNING_900, "[" + t1._clientId + "] Unable to encode outgoing message: " + A.S(e), null, null);
+ } else if (t1 instanceof A.ArgumentError) {
+ e0 = t1;
+ t1 = $async$self.$this;
+ t1._logger.log$4(B.Level_WARNING_900, "[" + t1._clientId + "] Invalid argument: " + A.S(e0), null, null);
+ } else
+ throw exception;
+ }
+ $async$handler = 3;
+ t1 = $async$self.$this;
+ t2 = t1.__SseClient__serverUrl_A;
+ t2 === $ && A.throwLateFieldNI("_serverUrl");
+ url = t2 + "&messageId=" + ++t1._lastMessageId;
+ t1 = $async$self._box_0.encodedMessage;
+ if (t1 == null)
+ t1 = null;
+ t1 = {method: "POST", body: t1, credentials: "include"};
+ t2 = type$.JSObject;
+ $async$goto = 6;
+ return A._asyncAwait(A.promiseToFuture(t2._as(t2._as(self.window).fetch(url, t1)), t2), $async$call$0);
+ case 6:
+ // returning from await.
+ $async$handler = 1;
+ // goto after finally
+ $async$goto = 5;
+ break;
+ case 3:
+ // catch
+ $async$handler = 2;
+ $async$exception = $async$currentError;
+ error = A.unwrapException($async$exception);
+ t1 = $async$self.$this;
+ augmentedError = "[" + t1._clientId + "] SSE client failed to send " + A.S($async$self.message) + ":\n " + A.S(error);
+ t1._logger.log$4(B.Level_SEVERE_1000, augmentedError, null, null);
+ t1._closeWithError$1(augmentedError);
+ // goto after finally
+ $async$goto = 5;
+ break;
+ case 2:
+ // uncaught
+ // goto rethrow
+ $async$goto = 1;
+ break;
+ case 5:
+ // after finally
+ // implicit return
+ return A._asyncReturn(null, $async$completer);
+ case 1:
+ // rethrow
+ return A._asyncRethrow($async$currentError, $async$completer);
+ }
+ });
+ return A._asyncStartSync($async$call$0, $async$completer);
+ },
+ $signature: 7
+ };
+ A.generateUuidV4_generateBits.prototype = {
+ call$1(bitCount) {
+ return this.random.nextInt$1(B.JSInt_methods._shlPositive$1(1, bitCount));
+ },
+ $signature: 23
+ };
+ A.generateUuidV4_printDigits.prototype = {
+ call$2(value, count) {
+ return B.JSString_methods.padLeft$2(B.JSInt_methods.toRadixString$1(value, 16), count, "0");
+ },
+ $signature: 11
+ };
+ A.generateUuidV4_bitsDigits.prototype = {
+ call$2(bitCount, digitCount) {
+ return this.printDigits.call$2(this.generateBits.call$1(bitCount), digitCount);
+ },
+ $signature: 11
+ };
+ A.StreamChannelMixin.prototype = {};
+ A.EventStreamProvider.prototype = {};
+ A._EventStream.prototype = {
+ listen$4$cancelOnError$onDone$onError(onData, cancelOnError, onDone, onError) {
+ var t1 = A._instanceType(this);
+ t1._eval$1("~(1)?")._as(onData);
+ type$.nullable_void_Function._as(onDone);
+ return A._EventStreamSubscription$(this._target, this._eventType, onData, false, t1._precomputed1);
+ }
+ };
+ A._ElementEventStreamImpl.prototype = {};
+ A._EventStreamSubscription.prototype = {
+ cancel$0() {
+ var _this = this,
+ emptyFuture = A.Future_Future$value(null, type$.void);
+ if (_this._target == null)
+ return emptyFuture;
+ _this._unlisten$0();
+ _this._streams$_onData = _this._target = null;
+ return emptyFuture;
+ },
+ onData$1(handleData) {
+ var t1, _this = this;
+ _this.$ti._eval$1("~(1)?")._as(handleData);
+ if (_this._target == null)
+ throw A.wrapException(A.StateError$("Subscription has been canceled."));
+ _this._unlisten$0();
+ t1 = A._wrapZone(new A._EventStreamSubscription_onData_closure(handleData), type$.JSObject);
+ t1 = t1 == null ? null : type$.JavaScriptFunction._as(A.allowInterop(t1, type$.Function));
+ _this._streams$_onData = t1;
+ _this._tryResume$0();
+ },
+ _tryResume$0() {
+ var t1 = this._streams$_onData;
+ if (t1 != null)
+ this._target.addEventListener(this._eventType, t1, false);
+ },
+ _unlisten$0() {
+ var t1 = this._streams$_onData;
+ if (t1 != null)
+ this._target.removeEventListener(this._eventType, t1, false);
+ },
+ $isStreamSubscription: 1
+ };
+ A._EventStreamSubscription_closure.prototype = {
+ call$1(e) {
+ return this.onData.call$1(type$.JSObject._as(e));
+ },
+ $signature: 1
+ };
+ A._EventStreamSubscription_onData_closure.prototype = {
+ call$1(e) {
+ return this.handleData.call$1(type$.JSObject._as(e));
+ },
+ $signature: 1
+ };
+ A.main_closure.prototype = {
+ call$1(_) {
+ this.channel._outgoingController.close$0();
+ },
+ $signature: 1
+ };
+ A.main_closure0.prototype = {
+ call$1(s) {
+ var count, t1, t2, t3, i, t4, t5, lastEvent;
+ A._asString(s);
+ if (B.JSString_methods.startsWith$1(s, "send ")) {
+ count = A.int_parse(B.JSArray_methods.get$last(s.split(" ")), null);
+ for (t1 = this.channel._outgoingController, t2 = A._instanceType(t1), t3 = t2._precomputed1, t2 = t2._eval$1("_DelayedData<1>"), i = 0; i < count; ++i) {
+ t4 = t3._as("" + i);
+ t5 = t1._state;
+ if (t5 >= 4)
+ A.throwExpression(t1._badEventState$0());
+ if ((t5 & 1) !== 0)
+ t1._sendData$1(t4);
+ else if ((t5 & 3) === 0) {
+ t5 = t1._ensurePendingEvents$0();
+ t4 = new A._DelayedData(t4, t2);
+ lastEvent = t5.lastPendingEvent;
+ if (lastEvent == null)
+ t5.firstPendingEvent = t5.lastPendingEvent = t4;
+ else {
+ lastEvent.set$next(t4);
+ t5.lastPendingEvent = t4;
+ }
+ }
+ }
+ } else {
+ t1 = this.channel._outgoingController;
+ t1.add$1(0, A._instanceType(t1)._precomputed1._as(s));
+ }
+ },
+ $signature: 24
+ };
+ (function aliases() {
+ var _ = J.LegacyJavaScriptObject.prototype;
+ _.super$LegacyJavaScriptObject$toString = _.toString$0;
+ })();
+ (function installTearOffs() {
+ var _static_1 = hunkHelpers._static_1,
+ _static_0 = hunkHelpers._static_0,
+ _static_2 = hunkHelpers._static_2,
+ _instance_2_u = hunkHelpers._instance_2u,
+ _instance_1_u = hunkHelpers._instance_1u,
+ _instance_0_u = hunkHelpers._instance_0u;
+ _static_1(A, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 6);
+ _static_1(A, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 6);
+ _static_1(A, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 6);
+ _static_0(A, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0);
+ _static_1(A, "async___nullDataHandler$closure", "_nullDataHandler", 3);
+ _static_2(A, "async___nullErrorHandler$closure", "_nullErrorHandler", 9);
+ _static_0(A, "async___nullDoneHandler$closure", "_nullDoneHandler", 0);
+ _instance_2_u(A._Future.prototype, "get$_completeError", "_completeError$2", 9);
+ _static_1(A, "convert___defaultToEncodable$closure", "_defaultToEncodable", 8);
+ var _;
+ _instance_1_u(_ = A.SseClient.prototype, "get$_onIncomingControlMessage", "_onIncomingControlMessage$1", 1);
+ _instance_1_u(_, "get$_onIncomingMessage", "_onIncomingMessage$1", 1);
+ _instance_0_u(_, "get$_onOutgoingDone", "_onOutgoingDone$0", 0);
+ _instance_1_u(_, "get$_onOutgoingMessage", "_onOutgoingMessage$1", 22);
+ })();
+ (function inheritance() {
+ var _mixin = hunkHelpers.mixin,
+ _inherit = hunkHelpers.inherit,
+ _inheritMany = hunkHelpers.inheritMany;
+ _inherit(A.Object, null);
+ _inheritMany(A.Object, [A.JS_CONST, J.Interceptor, J.ArrayIterator, A.Error, A.Closure, A.Iterable, A.ListIterator, A.FixedLengthListMixin, A.Symbol, A.MapView, A.ConstantMap, A.JSInvocationMirror, A.TypeErrorDecoder, A.NullThrownFromJavaScriptException, A.ExceptionAndStackTrace, A._StackTrace, A._Required, A.MapBase, A.LinkedHashMapCell, A.LinkedHashMapKeyIterator, A.StringMatch, A.Rti, A._FunctionParameters, A._Type, A._TimerImpl, A._AsyncAwaitCompleter, A.AsyncError, A._Completer, A._FutureListener, A._Future, A._AsyncCallbackEntry, A.Stream, A._StreamController, A._AsyncStreamControllerDispatch, A._BufferingStreamSubscription, A._StreamSinkWrapper, A._DelayedEvent, A._DelayedDone, A._PendingEvents, A._StreamIterator, A._Zone, A._HashMapKeyIterator, A.ListBase, A._UnmodifiableMapMixin, A._ListQueueIterator, A.Codec, A.Converter, A._JsonStringifier, A.DateTime, A.Duration, A.OutOfMemoryError, A.StackOverflowError, A._Exception, A.FormatException, A.Null, A._StringStackTrace, A.StringBuffer, A.NullRejectionException, A._JSRandom, A.AsyncMemoizer, A.Level, A.LogRecord, A.Logger, A.Pool, A.PoolResource, A.StreamChannelMixin, A.EventStreamProvider, A._EventStreamSubscription]);
+ _inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JavaScriptBigInt, J.JavaScriptSymbol, J.JSNumber, J.JSString]);
+ _inheritMany(J.JavaScriptObject, [J.LegacyJavaScriptObject, J.JSArray, A.NativeByteBuffer, A.NativeTypedData]);
+ _inheritMany(J.LegacyJavaScriptObject, [J.PlainJavaScriptObject, J.UnknownJavaScriptObject, J.JavaScriptFunction]);
+ _inherit(J.JSUnmodifiableArray, J.JSArray);
+ _inheritMany(J.JSNumber, [J.JSInt, J.JSNumNotInt]);
+ _inheritMany(A.Error, [A.LateError, A.TypeError, A.JsNoSuchMethodError, A.UnknownJsTypeError, A._CyclicInitializationError, A.RuntimeError, A._Error, A.JsonUnsupportedObjectError, A.AssertionError, A.ArgumentError, A.NoSuchMethodError, A.UnsupportedError, A.UnimplementedError, A.StateError, A.ConcurrentModificationError]);
+ _inheritMany(A.Closure, [A.Closure0Args, A.Closure2Args, A.TearOffClosure, A.initHooks_closure, A.initHooks_closure1, A._AsyncRun__initializeScheduleImmediate_internalCallback, A._AsyncRun__initializeScheduleImmediate_closure, A._awaitOnObject_closure, A._Future__chainForeignFuture_closure, A._Future__propagateToListeners_handleWhenCompleteCallback_closure, A.Stream_length_closure, A.Stream_first_closure0, A._RootZone_bindUnaryCallbackGuarded_closure, A.promiseToFuture_closure, A.promiseToFuture_closure0, A.dartify_convert, A.Pool__runOnRelease_closure, A.SseClient_closure0, A.SseClient_closure1, A.generateUuidV4_generateBits, A._EventStreamSubscription_closure, A._EventStreamSubscription_onData_closure, A.main_closure, A.main_closure0]);
+ _inheritMany(A.Closure0Args, [A.nullFuture_closure, A._AsyncRun__scheduleImmediateJsOverride_internalCallback, A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, A._TimerImpl_internalCallback, A._Future__addListener_closure, A._Future__prependListeners_closure, A._Future__chainForeignFuture_closure1, A._Future__chainCoreFutureAsync_closure, A._Future__asyncCompleteWithValue_closure, A._Future__asyncCompleteError_closure, A._Future__propagateToListeners_handleWhenCompleteCallback, A._Future__propagateToListeners_handleValueCallback, A._Future__propagateToListeners_handleError, A.Stream_length_closure0, A.Stream_first_closure, A._StreamController__subscribe_closure, A._StreamController__recordCancel_complete, A._BufferingStreamSubscription_asFuture_closure, A._BufferingStreamSubscription_asFuture__closure, A._BufferingStreamSubscription__sendError_sendError, A._BufferingStreamSubscription__sendDone_sendDone, A._PendingEvents_schedule_closure, A._cancelAndValue_closure, A._rootHandleError_closure, A._RootZone_bindCallbackGuarded_closure, A.Logger_Logger_closure, A.SseClient_closure, A.SseClient__closure, A.SseClient__onOutgoingMessage_closure]);
+ _inherit(A.EfficientLengthIterable, A.Iterable);
+ _inheritMany(A.EfficientLengthIterable, [A.ListIterable, A.LinkedHashMapKeyIterable, A._HashMapKeyIterable]);
+ _inherit(A._UnmodifiableMapView_MapView__UnmodifiableMapMixin, A.MapView);
+ _inherit(A.UnmodifiableMapView, A._UnmodifiableMapView_MapView__UnmodifiableMapMixin);
+ _inherit(A.ConstantMapView, A.UnmodifiableMapView);
+ _inherit(A.ConstantStringMap, A.ConstantMap);
+ _inheritMany(A.Closure2Args, [A.Primitives_functionNoSuchMethod_closure, A.initHooks_closure0, A._awaitOnObject_closure0, A._wrapJsFunctionForAsync_closure, A._Future__chainForeignFuture_closure0, A._BufferingStreamSubscription_asFuture_closure0, A.MapBase_mapToString_closure, A._JsonStringifier_writeMap_closure, A.NoSuchMethodError_toString_closure, A.Pool__runOnRelease_closure0, A.generateUuidV4_printDigits, A.generateUuidV4_bitsDigits]);
+ _inherit(A.NullError, A.TypeError);
+ _inheritMany(A.TearOffClosure, [A.StaticClosure, A.BoundClosure]);
+ _inheritMany(A.MapBase, [A.JsLinkedHashMap, A._HashMap, A._JsonMap]);
+ _inheritMany(A.NativeTypedData, [A.NativeByteData, A.NativeTypedArray]);
+ _inheritMany(A.NativeTypedArray, [A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin]);
+ _inherit(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin, A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin);
+ _inherit(A.NativeTypedArrayOfDouble, A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin);
+ _inherit(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin);
+ _inherit(A.NativeTypedArrayOfInt, A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin);
+ _inheritMany(A.NativeTypedArrayOfDouble, [A.NativeFloat32List, A.NativeFloat64List]);
+ _inheritMany(A.NativeTypedArrayOfInt, [A.NativeInt16List, A.NativeInt32List, A.NativeInt8List, A.NativeUint16List, A.NativeUint32List, A.NativeUint8ClampedList, A.NativeUint8List]);
+ _inherit(A._TypeError, A._Error);
+ _inheritMany(A._Completer, [A._AsyncCompleter, A._SyncCompleter]);
+ _inherit(A._AsyncStreamController, A._StreamController);
+ _inheritMany(A.Stream, [A._StreamImpl, A._EventStream]);
+ _inherit(A._ControllerStream, A._StreamImpl);
+ _inherit(A._ControllerSubscription, A._BufferingStreamSubscription);
+ _inheritMany(A._DelayedEvent, [A._DelayedData, A._DelayedError]);
+ _inherit(A._RootZone, A._Zone);
+ _inherit(A._IdentityHashMap, A._HashMap);
+ _inheritMany(A.ListIterable, [A.ListQueue, A._JsonMapKeyIterable]);
+ _inherit(A.JsonCyclicError, A.JsonUnsupportedObjectError);
+ _inherit(A.JsonCodec, A.Codec);
+ _inheritMany(A.Converter, [A.JsonEncoder, A.JsonDecoder]);
+ _inherit(A._JsonStringStringifier, A._JsonStringifier);
+ _inheritMany(A.ArgumentError, [A.RangeError, A.IndexError]);
+ _inherit(A.SseClient, A.StreamChannelMixin);
+ _inherit(A._ElementEventStreamImpl, A._EventStream);
+ _mixin(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin, A.ListBase);
+ _mixin(A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin, A.FixedLengthListMixin);
+ _mixin(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin, A.ListBase);
+ _mixin(A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin, A.FixedLengthListMixin);
+ _mixin(A._AsyncStreamController, A._AsyncStreamControllerDispatch);
+ _mixin(A._UnmodifiableMapView_MapView__UnmodifiableMapMixin, A._UnmodifiableMapMixin);
+ })();
+ var init = {
+ typeUniverse: {eC: new Map(), tR: {}, eT: {}, tPV: {}, sEA: []},
+ mangledGlobalNames: {int: "int", double: "double", num: "num", String: "String", bool: "bool", Null: "Null", List: "List", Object: "Object", Map: "Map"},
+ mangledNames: {},
+ types: ["~()", "~(JSObject)", "Null()", "~(@)", "Null(@)", "Null(Object,StackTrace)", "~(~())", "Future<Null>()", "@(@)", "~(Object,StackTrace)", "~(Object?,Object?)", "String(int,int)", "~(String,@)", "@(@,String)", "@(String)", "Null(~())", "Null(@,StackTrace)", "~(int,@)", "_Future<@>(@)", "~(Symbol0,@)", "Object?(Object?)", "Logger()", "~(String?)", "int(int)", "~(String)"],
+ interceptorsByTag: null,
+ leafTags: null,
+ arrayRti: Symbol("$ti")
+ };
+ A._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"LegacyJavaScriptObject","UnknownJavaScriptObject":"LegacyJavaScriptObject","JavaScriptFunction":"LegacyJavaScriptObject","JSBool":{"bool":[],"TrustedGetRuntimeType":[]},"JSNull":{"Null":[],"TrustedGetRuntimeType":[]},"JavaScriptObject":{"JSObject":[]},"LegacyJavaScriptObject":{"JSObject":[]},"JSArray":{"List":["1"],"JSObject":[],"Iterable":["1"]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"JSObject":[],"Iterable":["1"]},"JSNumber":{"double":[],"num":[]},"JSInt":{"double":[],"int":[],"num":[],"TrustedGetRuntimeType":[]},"JSNumNotInt":{"double":[],"num":[],"TrustedGetRuntimeType":[]},"JSString":{"String":[],"Pattern":[],"TrustedGetRuntimeType":[]},"LateError":{"Error":[]},"EfficientLengthIterable":{"Iterable":["1"]},"ListIterable":{"Iterable":["1"]},"Symbol":{"Symbol0":[]},"ConstantMapView":{"UnmodifiableMapView":["1","2"],"_UnmodifiableMapView_MapView__UnmodifiableMapMixin":["1","2"],"MapView":["1","2"],"_UnmodifiableMapMixin":["1","2"],"Map":["1","2"]},"ConstantMap":{"Map":["1","2"]},"ConstantStringMap":{"ConstantMap":["1","2"],"Map":["1","2"]},"JSInvocationMirror":{"Invocation":[]},"NullError":{"TypeError":[],"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"Closure":{"Function":[]},"Closure0Args":{"Function":[]},"Closure2Args":{"Function":[]},"TearOffClosure":{"Function":[]},"StaticClosure":{"Function":[]},"BoundClosure":{"Function":[]},"_CyclicInitializationError":{"Error":[]},"RuntimeError":{"Error":[]},"JsLinkedHashMap":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.K":"1","MapBase.V":"2"},"LinkedHashMapKeyIterable":{"Iterable":["1"]},"NativeByteBuffer":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedData":{"JSObject":[]},"NativeByteData":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedArray":{"JavaScriptIndexingBehavior":["1"],"JSObject":[]},"NativeTypedArrayOfDouble":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"JSObject":[],"Iterable":["double"],"FixedLengthListMixin":["double"]},"NativeTypedArrayOfInt":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"]},"NativeFloat32List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"JSObject":[],"Iterable":["double"],"FixedLengthListMixin":["double"],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeFloat64List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"JSObject":[],"Iterable":["double"],"FixedLengthListMixin":["double"],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeInt16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8ClampedList":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"JSObject":[],"Iterable":["int"],"FixedLengthListMixin":["int"],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"_Error":{"Error":[]},"_TypeError":{"TypeError":[],"Error":[]},"_Future":{"Future":["1"]},"_TimerImpl":{"Timer":[]},"_AsyncAwaitCompleter":{"Completer":["1"]},"AsyncError":{"Error":[]},"_Completer":{"Completer":["1"]},"_AsyncCompleter":{"_Completer":["1"],"Completer":["1"]},"_SyncCompleter":{"_Completer":["1"],"Completer":["1"]},"_StreamController":{"StreamController":["1"],"_StreamControllerLifecycle":["1"],"_EventDispatch":["1"]},"_AsyncStreamController":{"_AsyncStreamControllerDispatch":["1"],"_StreamController":["1"],"StreamController":["1"],"_StreamControllerLifecycle":["1"],"_EventDispatch":["1"]},"_ControllerStream":{"_StreamImpl":["1"],"Stream":["1"]},"_ControllerSubscription":{"_BufferingStreamSubscription":["1"],"StreamSubscription":["1"],"_EventDispatch":["1"]},"_BufferingStreamSubscription":{"StreamSubscription":["1"],"_EventDispatch":["1"]},"_StreamImpl":{"Stream":["1"]},"_DelayedData":{"_DelayedEvent":["1"]},"_DelayedError":{"_DelayedEvent":["@"]},"_DelayedDone":{"_DelayedEvent":["@"]},"_Zone":{"Zone":[]},"_RootZone":{"_Zone":[],"Zone":[]},"_HashMap":{"MapBase":["1","2"],"Map":["1","2"]},"_IdentityHashMap":{"_HashMap":["1","2"],"MapBase":["1","2"],"Map":["1","2"],"MapBase.K":"1","MapBase.V":"2"},"_HashMapKeyIterable":{"Iterable":["1"]},"MapBase":{"Map":["1","2"]},"MapView":{"Map":["1","2"]},"UnmodifiableMapView":{"_UnmodifiableMapView_MapView__UnmodifiableMapMixin":["1","2"],"MapView":["1","2"],"_UnmodifiableMapMixin":["1","2"],"Map":["1","2"]},"ListQueue":{"Queue":["1"],"ListIterable":["1"],"Iterable":["1"],"ListIterable.E":"1"},"_JsonMap":{"MapBase":["String","@"],"Map":["String","@"],"MapBase.K":"String","MapBase.V":"@"},"_JsonMapKeyIterable":{"ListIterable":["String"],"Iterable":["String"],"ListIterable.E":"String"},"JsonUnsupportedObjectError":{"Error":[]},"JsonCyclicError":{"Error":[]},"JsonCodec":{"Codec":["Object?","String"]},"JsonEncoder":{"Converter":["Object?","String"]},"JsonDecoder":{"Converter":["String","Object?"]},"double":{"num":[]},"int":{"num":[]},"String":{"Pattern":[]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"NoSuchMethodError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"StateError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"OutOfMemoryError":{"Error":[]},"StackOverflowError":{"Error":[]},"_StringStackTrace":{"StackTrace":[]},"StringBuffer":{"StringSink":[]},"_EventStream":{"Stream":["1"]},"_ElementEventStreamImpl":{"_EventStream":["1"],"Stream":["1"]},"_EventStreamSubscription":{"StreamSubscription":["1"]},"Int8List":{"List":["int"],"Iterable":["int"]},"Uint8List":{"List":["int"],"Iterable":["int"]},"Uint8ClampedList":{"List":["int"],"Iterable":["int"]},"Int16List":{"List":["int"],"Iterable":["int"]},"Uint16List":{"List":["int"],"Iterable":["int"]},"Int32List":{"List":["int"],"Iterable":["int"]},"Uint32List":{"List":["int"],"Iterable":["int"]},"Float32List":{"List":["double"],"Iterable":["double"]},"Float64List":{"List":["double"],"Iterable":["double"]}}'));
+ A._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"EfficientLengthIterable":1,"NativeTypedArray":1,"_DelayedEvent":1,"StreamChannelMixin":1}'));
+ var string$ = {
+ Error_: "Error handler must accept one Object or one Object and a StackTrace as arguments, and return a value of the returned future's type"
+ };
+ var type$ = (function rtii() {
+ var findType = A.findType;
+ return {
+ $env_1_1_void: findType("@<~>"),
+ AsyncError: findType("AsyncError"),
+ ConstantMapView_Symbol_dynamic: findType("ConstantMapView<Symbol0,@>"),
+ Error: findType("Error"),
+ Function: findType("Function"),
+ Future_dynamic: findType("Future<@>"),
+ Invocation: findType("Invocation"),
+ Iterable_dynamic: findType("Iterable<@>"),
+ JSArray_String: findType("JSArray<String>"),
+ JSArray_dynamic: findType("JSArray<@>"),
+ JSNull: findType("JSNull"),
+ JSObject: findType("JSObject"),
+ JavaScriptFunction: findType("JavaScriptFunction"),
+ JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"),
+ JsLinkedHashMap_Symbol_dynamic: findType("JsLinkedHashMap<Symbol0,@>"),
+ List_dynamic: findType("List<@>"),
+ Logger: findType("Logger"),
+ Map_dynamic_dynamic: findType("Map<@,@>"),
+ Null: findType("Null"),
+ Object: findType("Object"),
+ PoolResource: findType("PoolResource"),
+ Record: findType("Record"),
+ StackTrace: findType("StackTrace"),
+ String: findType("String"),
+ Symbol: findType("Symbol0"),
+ TrustedGetRuntimeType: findType("TrustedGetRuntimeType"),
+ TypeError: findType("TypeError"),
+ UnknownJavaScriptObject: findType("UnknownJavaScriptObject"),
+ _AsyncCompleter_PoolResource: findType("_AsyncCompleter<PoolResource>"),
+ _AsyncCompleter_void: findType("_AsyncCompleter<~>"),
+ _ElementEventStreamImpl_JSObject: findType("_ElementEventStreamImpl<JSObject>"),
+ _EventStream_JSObject: findType("_EventStream<JSObject>"),
+ _Future_PoolResource: findType("_Future<PoolResource>"),
+ _Future_dynamic: findType("_Future<@>"),
+ _Future_int: findType("_Future<int>"),
+ _Future_void: findType("_Future<~>"),
+ _IdentityHashMap_of_nullable_Object_and_nullable_Object: findType("_IdentityHashMap<Object?,Object?>"),
+ _StreamControllerAddStreamState_nullable_Object: findType("_StreamControllerAddStreamState<Object?>"),
+ _SyncCompleter_PoolResource: findType("_SyncCompleter<PoolResource>"),
+ bool: findType("bool"),
+ bool_Function_Object: findType("bool(Object)"),
+ double: findType("double"),
+ dynamic: findType("@"),
+ dynamic_Function: findType("@()"),
+ dynamic_Function_Object: findType("@(Object)"),
+ dynamic_Function_Object_StackTrace: findType("@(Object,StackTrace)"),
+ int: findType("int"),
+ legacy_Never: findType("0&*"),
+ legacy_Object: findType("Object*"),
+ nullable_Future_Null: findType("Future<Null>?"),
+ nullable_JSObject: findType("JSObject?"),
+ nullable_List_dynamic: findType("List<@>?"),
+ nullable_Object: findType("Object?"),
+ nullable_StackTrace: findType("StackTrace?"),
+ nullable__DelayedEvent_dynamic: findType("_DelayedEvent<@>?"),
+ nullable__FutureListener_dynamic_dynamic: findType("_FutureListener<@,@>?"),
+ nullable_void_Function: findType("~()?"),
+ nullable_void_Function_JSObject: findType("~(JSObject)?"),
+ num: findType("num"),
+ void: findType("~"),
+ void_Function: findType("~()"),
+ void_Function_Object: findType("~(Object)"),
+ void_Function_Object_StackTrace: findType("~(Object,StackTrace)"),
+ void_Function_String_dynamic: findType("~(String,@)")
+ };
+ })();
+ (function constants() {
+ var makeConstList = hunkHelpers.makeConstList;
+ B.Interceptor_methods = J.Interceptor.prototype;
+ B.JSArray_methods = J.JSArray.prototype;
+ B.JSInt_methods = J.JSInt.prototype;
+ B.JSNumber_methods = J.JSNumber.prototype;
+ B.JSString_methods = J.JSString.prototype;
+ B.JavaScriptFunction_methods = J.JavaScriptFunction.prototype;
+ B.JavaScriptObject_methods = J.JavaScriptObject.prototype;
+ B.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype;
+ B.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype;
+ B.C_JS_CONST = function getTagFallback(o) {
+ var s = Object.prototype.toString.call(o);
+ return s.substring(8, s.length - 1);
+};
+ B.C_JS_CONST0 = function() {
+ var toStringFunction = Object.prototype.toString;
+ function getTag(o) {
+ var s = toStringFunction.call(o);
+ return s.substring(8, s.length - 1);
+ }
+ function getUnknownTag(object, tag) {
+ if (/^HTML[A-Z].*Element$/.test(tag)) {
+ var name = toStringFunction.call(object);
+ if (name == "[object Object]") return null;
+ return "HTMLElement";
+ }
+ }
+ function getUnknownTagGenericBrowser(object, tag) {
+ if (object instanceof HTMLElement) return "HTMLElement";
+ return getUnknownTag(object, tag);
+ }
+ function prototypeForTag(tag) {
+ if (typeof window == "undefined") return null;
+ if (typeof window[tag] == "undefined") return null;
+ var constructor = window[tag];
+ if (typeof constructor != "function") return null;
+ return constructor.prototype;
+ }
+ function discriminator(tag) { return null; }
+ var isBrowser = typeof HTMLElement == "function";
+ return {
+ getTag: getTag,
+ getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag,
+ prototypeForTag: prototypeForTag,
+ discriminator: discriminator };
+};
+ B.C_JS_CONST6 = function(getTagFallback) {
+ return function(hooks) {
+ if (typeof navigator != "object") return hooks;
+ var userAgent = navigator.userAgent;
+ if (typeof userAgent != "string") return hooks;
+ if (userAgent.indexOf("DumpRenderTree") >= 0) return hooks;
+ if (userAgent.indexOf("Chrome") >= 0) {
+ function confirm(p) {
+ return typeof window == "object" && window[p] && window[p].name == p;
+ }
+ if (confirm("Window") && confirm("HTMLElement")) return hooks;
+ }
+ hooks.getTag = getTagFallback;
+ };
+};
+ B.C_JS_CONST1 = function(hooks) {
+ if (typeof dartExperimentalFixupGetTag != "function") return hooks;
+ hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag);
+};
+ B.C_JS_CONST5 = function(hooks) {
+ if (typeof navigator != "object") return hooks;
+ var userAgent = navigator.userAgent;
+ if (typeof userAgent != "string") return hooks;
+ if (userAgent.indexOf("Firefox") == -1) return hooks;
+ var getTag = hooks.getTag;
+ var quickMap = {
+ "BeforeUnloadEvent": "Event",
+ "DataTransfer": "Clipboard",
+ "GeoGeolocation": "Geolocation",
+ "Location": "!Location",
+ "WorkerMessageEvent": "MessageEvent",
+ "XMLDocument": "!Document"};
+ function getTagFirefox(o) {
+ var tag = getTag(o);
+ return quickMap[tag] || tag;
+ }
+ hooks.getTag = getTagFirefox;
+};
+ B.C_JS_CONST4 = function(hooks) {
+ if (typeof navigator != "object") return hooks;
+ var userAgent = navigator.userAgent;
+ if (typeof userAgent != "string") return hooks;
+ if (userAgent.indexOf("Trident/") == -1) return hooks;
+ var getTag = hooks.getTag;
+ var quickMap = {
+ "BeforeUnloadEvent": "Event",
+ "DataTransfer": "Clipboard",
+ "HTMLDDElement": "HTMLElement",
+ "HTMLDTElement": "HTMLElement",
+ "HTMLPhraseElement": "HTMLElement",
+ "Position": "Geoposition"
+ };
+ function getTagIE(o) {
+ var tag = getTag(o);
+ var newTag = quickMap[tag];
+ if (newTag) return newTag;
+ if (tag == "Object") {
+ if (window.DataView && (o instanceof window.DataView)) return "DataView";
+ }
+ return tag;
+ }
+ function prototypeForTagIE(tag) {
+ var constructor = window[tag];
+ if (constructor == null) return null;
+ return constructor.prototype;
+ }
+ hooks.getTag = getTagIE;
+ hooks.prototypeForTag = prototypeForTagIE;
+};
+ B.C_JS_CONST2 = function(hooks) {
+ var getTag = hooks.getTag;
+ var prototypeForTag = hooks.prototypeForTag;
+ function getTagFixed(o) {
+ var tag = getTag(o);
+ if (tag == "Document") {
+ if (!!o.xmlVersion) return "!Document";
+ return "!HTMLDocument";
+ }
+ return tag;
+ }
+ function prototypeForTagFixed(tag) {
+ if (tag == "Document") return null;
+ return prototypeForTag(tag);
+ }
+ hooks.getTag = getTagFixed;
+ hooks.prototypeForTag = prototypeForTagFixed;
+};
+ B.C_JS_CONST3 = function(hooks) { return hooks; }
+;
+ B.C_JsonCodec = new A.JsonCodec();
+ B.C_OutOfMemoryError = new A.OutOfMemoryError();
+ B.C__DelayedDone = new A._DelayedDone();
+ B.C__JSRandom = new A._JSRandom();
+ B.C__Required = new A._Required();
+ B.C__RootZone = new A._RootZone();
+ B.Duration_0 = new A.Duration(0);
+ B.Duration_5000000 = new A.Duration(5000000);
+ B.JsonDecoder_null = new A.JsonDecoder(null);
+ B.JsonEncoder_null = new A.JsonEncoder(null);
+ B.Level_INFO_800 = new A.Level("INFO", 800);
+ B.Level_SEVERE_1000 = new A.Level("SEVERE", 1000);
+ B.Level_WARNING_900 = new A.Level("WARNING", 900);
+ B.List_empty = A._setArrayType(makeConstList([]), type$.JSArray_dynamic);
+ B.Object_empty = {};
+ B.Map_empty = new A.ConstantStringMap(B.Object_empty, [], A.findType("ConstantStringMap<Symbol0,@>"));
+ B.Symbol_call = new A.Symbol("call");
+ B.Type_ByteBuffer_RkP = A.typeLiteral("ByteBuffer");
+ B.Type_ByteData_zNC = A.typeLiteral("ByteData");
+ B.Type_Float32List_LB7 = A.typeLiteral("Float32List");
+ B.Type_Float64List_LB7 = A.typeLiteral("Float64List");
+ B.Type_Int16List_uXf = A.typeLiteral("Int16List");
+ B.Type_Int32List_O50 = A.typeLiteral("Int32List");
+ B.Type_Int8List_ekJ = A.typeLiteral("Int8List");
+ B.Type_Uint16List_2bx = A.typeLiteral("Uint16List");
+ B.Type_Uint32List_2bx = A.typeLiteral("Uint32List");
+ B.Type_Uint8ClampedList_Jik = A.typeLiteral("Uint8ClampedList");
+ B.Type_Uint8List_WLA = A.typeLiteral("Uint8List");
+ B._StringStackTrace_3uE = new A._StringStackTrace("");
+ })();
+ (function staticFields() {
+ $._JS_INTEROP_INTERCEPTOR_TAG = null;
+ $.toStringVisiting = A._setArrayType([], A.findType("JSArray<Object>"));
+ $.Primitives__identityHashCodeProperty = null;
+ $.BoundClosure__receiverFieldNameCache = null;
+ $.BoundClosure__interceptorFieldNameCache = null;
+ $.getTagFunction = null;
+ $.alternateTagFunction = null;
+ $.prototypeForTagFunction = null;
+ $.dispatchRecordsForInstanceTags = null;
+ $.interceptorsForUncacheableTags = null;
+ $.initNativeDispatchFlag = null;
+ $._nextCallback = null;
+ $._lastCallback = null;
+ $._lastPriorityCallback = null;
+ $._isInCallbackLoop = false;
+ $.Zone__current = B.C__RootZone;
+ $.LogRecord__nextNumber = 0;
+ $.Logger__loggers = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Logger);
+ })();
+ (function lazyInitializers() {
+ var _lazyFinal = hunkHelpers.lazyFinal;
+ _lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", () => A.getIsolateAffinityTag("_$dart_dartClosure"));
+ _lazyFinal($, "nullFuture", "$get$nullFuture", () => B.C__RootZone.run$1$1(new A.nullFuture_closure(), A.findType("Future<Null>")));
+ _lazyFinal($, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({
+ toString: function() {
+ return "$receiver$";
+ }
+ })));
+ _lazyFinal($, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({$method$: null,
+ toString: function() {
+ return "$receiver$";
+ }
+ })));
+ _lazyFinal($, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(null)));
+ _lazyFinal($, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function() {
+ var $argumentsExpr$ = "$arguments$";
+ try {
+ null.$method$($argumentsExpr$);
+ } catch (e) {
+ return e.message;
+ }
+ }()));
+ _lazyFinal($, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(void 0)));
+ _lazyFinal($, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function() {
+ var $argumentsExpr$ = "$arguments$";
+ try {
+ (void 0).$method$($argumentsExpr$);
+ } catch (e) {
+ return e.message;
+ }
+ }()));
+ _lazyFinal($, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(null)));
+ _lazyFinal($, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function() {
+ try {
+ null.$method$;
+ } catch (e) {
+ return e.message;
+ }
+ }()));
+ _lazyFinal($, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(void 0)));
+ _lazyFinal($, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function() {
+ try {
+ (void 0).$method$;
+ } catch (e) {
+ return e.message;
+ }
+ }()));
+ _lazyFinal($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", () => A._AsyncRun__initializeScheduleImmediate());
+ _lazyFinal($, "Future__nullFuture", "$get$Future__nullFuture", () => A.findType("_Future<Null>")._as($.$get$nullFuture()));
+ _lazyFinal($, "Logger_root", "$get$Logger_root", () => A.Logger_Logger(""));
+ _lazyFinal($, "_requestPool", "$get$_requestPool", () => {
+ var t4,
+ t1 = A.findType("Completer<PoolResource>"),
+ t2 = A.ListQueue$(t1),
+ t3 = A.ListQueue$(type$.void_Function);
+ t1 = A.ListQueue$(t1);
+ t4 = A.Completer_Completer(type$.dynamic);
+ return new A.Pool(t2, t3, t1, 1000, new A.AsyncMemoizer(t4, A.findType("AsyncMemoizer<@>")));
+ });
+ })();
+ (function nativeSupport() {
+ !function() {
+ var intern = function(s) {
+ var o = {};
+ o[s] = 1;
+ return Object.keys(hunkHelpers.convertToFastObject(o))[0];
+ };
+ init.getIsolateTag = function(name) {
+ return intern("___dart_" + name + init.isolateTag);
+ };
+ var tableProperty = "___dart_isolate_tags_";
+ var usedProperties = Object[tableProperty] || (Object[tableProperty] = Object.create(null));
+ var rootProperty = "_ZxYxX";
+ for (var i = 0;; i++) {
+ var property = intern(rootProperty + "_" + i + "_");
+ if (!(property in usedProperties)) {
+ usedProperties[property] = 1;
+ init.isolateTag = property;
+ break;
+ }
+ }
+ init.dispatchPropertyName = init.getIsolateTag("dispatch_record");
+ }();
+ hunkHelpers.setOrUpdateInterceptorsByTag({ArrayBuffer: A.NativeByteBuffer, ArrayBufferView: A.NativeTypedData, DataView: A.NativeByteData, Float32Array: A.NativeFloat32List, Float64Array: A.NativeFloat64List, Int16Array: A.NativeInt16List, Int32Array: A.NativeInt32List, Int8Array: A.NativeInt8List, Uint16Array: A.NativeUint16List, Uint32Array: A.NativeUint32List, Uint8ClampedArray: A.NativeUint8ClampedList, CanvasPixelArray: A.NativeUint8ClampedList, Uint8Array: A.NativeUint8List});
+ hunkHelpers.setOrUpdateLeafTags({ArrayBuffer: true, ArrayBufferView: false, DataView: true, Float32Array: true, Float64Array: true, Int16Array: true, Int32Array: true, Int8Array: true, Uint16Array: true, Uint32Array: true, Uint8ClampedArray: true, CanvasPixelArray: true, Uint8Array: false});
+ A.NativeTypedArray.$nativeSuperclassTag = "ArrayBufferView";
+ A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin.$nativeSuperclassTag = "ArrayBufferView";
+ A._NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin.$nativeSuperclassTag = "ArrayBufferView";
+ A.NativeTypedArrayOfDouble.$nativeSuperclassTag = "ArrayBufferView";
+ A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin.$nativeSuperclassTag = "ArrayBufferView";
+ A._NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin.$nativeSuperclassTag = "ArrayBufferView";
+ A.NativeTypedArrayOfInt.$nativeSuperclassTag = "ArrayBufferView";
+ })();
+ Function.prototype.call$1 = function(a) {
+ return this(a);
+ };
+ Function.prototype.call$0 = function() {
+ return this();
+ };
+ Function.prototype.call$2 = function(a, b) {
+ return this(a, b);
+ };
+ Function.prototype.call$3 = function(a, b, c) {
+ return this(a, b, c);
+ };
+ Function.prototype.call$4 = function(a, b, c, d) {
+ return this(a, b, c, d);
+ };
+ Function.prototype.call$1$1 = function(a) {
+ return this(a);
+ };
+ convertAllToFastObject(holders);
+ convertToFastObject($);
+ (function(callback) {
+ if (typeof document === "undefined") {
+ callback(null);
+ return;
+ }
+ if (typeof document.currentScript != "undefined") {
+ callback(document.currentScript);
+ return;
+ }
+ var scripts = document.scripts;
+ function onLoad(event) {
+ for (var i = 0; i < scripts.length; ++i) {
+ scripts[i].removeEventListener("load", onLoad, false);
+ }
+ callback(event.target);
+ }
+ for (var i = 0; i < scripts.length; ++i) {
+ scripts[i].addEventListener("load", onLoad, false);
+ }
+ })(function(currentScript) {
+ init.currentScript = currentScript;
+ var callMain = A.main;
+ if (typeof dartMainRunner === "function") {
+ dartMainRunner(callMain, []);
+ } else {
+ callMain([]);
+ }
+ });
+})();
diff --git a/pkgs/sse/test/web/index.html b/pkgs/sse/test/web/index.html
new file mode 100644
index 0000000..be26763
--- /dev/null
+++ b/pkgs/sse/test/web/index.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+ <title>SSE Broadcast Channel Test</title>
+</head>
+
+<body>
+ <button type="button">Close Sink</button>
+ <script type="application/javascript" src="index.dart.js"></script>
+</body>
+
+</html>
diff --git a/pkgs/sse/tool/build_js.sh b/pkgs/sse/tool/build_js.sh
new file mode 100755
index 0000000..ef29b70
--- /dev/null
+++ b/pkgs/sse/tool/build_js.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+dart compile js --no-source-maps test/web/index.dart -o test/web/index.dart.js
