From ddfa6deb3b2e51a2038bc595facec386f4501da6 Mon Sep 17 00:00:00 2001 From: Martin Kustermann Date: Fri, 7 Mar 2025 15:29:09 +0100 Subject: [PATCH] Add TodoMVC for dart2js & dart2wasm This is a Jaspr Dart Web application compiled with dart2js and dart2wasm. The source is from [0] and was compiled with a modified Jaspr CLI tool (see PR in [1]) using the following commands: ``` % rm -rf build % dart run --resident /packages/jaspr_cli/bin/jaspr.dart build -O4 --extra-js-compiler-option=--no-minify ``` ``` % rm -rf build % dart run --resident /packages/jaspr_cli/bin/jaspr.dart build -O4 --extra-wasm-compiler-option=--no-strip-wasm --experimental-wasm ``` The relevant files in `build/jaspr/*` were copied to the Speedometer benchmark folders. Used Dart SDK version is: 3.8.0-edge.4c8aedcb57fe678e6d30acfdc021aa9888576638 Before landing we should figure out: * do we want both dart2js and dart2wasm? * do we want -O2 or -O4? * can we rely on `js-string` builtin to be evailable or not? [0] https://github.com/mkustermann/todomvc [1] https://github.com/schultek/jaspr/pull/397 --- resources/tests.mjs | 57 + resources/todomvc/dart2js-jaspr/base.css | 141 + resources/todomvc/dart2js-jaspr/favicon.ico | Bin 0 -> 2595 bytes resources/todomvc/dart2js-jaspr/index.css | 393 + resources/todomvc/dart2js-jaspr/index.html | 22 + .../dart2js-jaspr/main.clients.dart.js | 9770 +++++++++++++++++ .../main.clients.dart.js_1.part.js | 1284 +++ resources/todomvc/dart2js-jaspr/main.dart.js | 9559 ++++++++++++++++ resources/todomvc/dart2wasm-jaspr/base.css | 141 + resources/todomvc/dart2wasm-jaspr/favicon.ico | Bin 0 -> 2595 bytes resources/todomvc/dart2wasm-jaspr/index.css | 393 + resources/todomvc/dart2wasm-jaspr/index.html | 22 + .../todomvc/dart2wasm-jaspr/main.dart.js | 15 + resources/todomvc/dart2wasm-jaspr/main.mjs | 599 + resources/todomvc/dart2wasm-jaspr/main.wasm | Bin 0 -> 115194 bytes 15 files changed, 22396 insertions(+) create mode 100644 resources/todomvc/dart2js-jaspr/base.css create mode 100644 resources/todomvc/dart2js-jaspr/favicon.ico create mode 100644 resources/todomvc/dart2js-jaspr/index.css create mode 100644 resources/todomvc/dart2js-jaspr/index.html create mode 100644 resources/todomvc/dart2js-jaspr/main.clients.dart.js create mode 100644 resources/todomvc/dart2js-jaspr/main.clients.dart.js_1.part.js create mode 100644 resources/todomvc/dart2js-jaspr/main.dart.js create mode 100644 resources/todomvc/dart2wasm-jaspr/base.css create mode 100644 resources/todomvc/dart2wasm-jaspr/favicon.ico create mode 100644 resources/todomvc/dart2wasm-jaspr/index.css create mode 100644 resources/todomvc/dart2wasm-jaspr/index.html create mode 100644 resources/todomvc/dart2wasm-jaspr/main.dart.js create mode 100644 resources/todomvc/dart2wasm-jaspr/main.mjs create mode 100644 resources/todomvc/dart2wasm-jaspr/main.wasm diff --git a/resources/tests.mjs b/resources/tests.mjs index d7cf6794a..ed158b17e 100644 --- a/resources/tests.mjs +++ b/resources/tests.mjs @@ -1113,6 +1113,63 @@ Suites.push({ ], }); +Suites.push({ + name: "TodoMVC-Dart2JS", + url: "resources/todomvc/dart2js-jaspr/index.html", + tags: ["todomvc"], + async prepare(page) { + (await page.waitForElement(".new-todo")).focus(); + }, + tests: [ + new BenchmarkTestStep(`Adding${numberOfItemsToAdd}Items`, (page) => { + const newTodo = page.querySelector(".new-todo"); + for (let i = 0; i < numberOfItemsToAdd; i++) { + newTodo.setValue(getTodoText("ja", i)); + newTodo.dispatchEvent("change"); + newTodo.enter("keypress"); + } + }), + new BenchmarkTestStep("CompletingAllItems", (page) => { + const checkboxes = page.querySelectorAll(".toggle"); + for (let i = 0; i < numberOfItemsToAdd; i++) + checkboxes[i].click(); + }), + new BenchmarkTestStep("DeletingAllItems", (page) => { + const deleteButtons = page.querySelectorAll(".destroy"); + for (let i = numberOfItemsToAdd - 1; i >= 0; i--) + deleteButtons[i].click(); + }), + ], +}); +Suites.push({ + name: "TodoMVC-Dart2Wasm", + url: "resources/todomvc/dart2wasm-jaspr/index.html", + tags: ["todomvc"], + async prepare(page) { + (await page.waitForElement(".new-todo")).focus(); + }, + tests: [ + new BenchmarkTestStep(`Adding${numberOfItemsToAdd}Items`, (page) => { + const newTodo = page.querySelector(".new-todo"); + for (let i = 0; i < numberOfItemsToAdd; i++) { + newTodo.setValue(getTodoText("ja", i)); + newTodo.dispatchEvent("change"); + newTodo.enter("keypress"); + } + }), + new BenchmarkTestStep("CompletingAllItems", (page) => { + const checkboxes = page.querySelectorAll(".toggle"); + for (let i = 0; i < numberOfItemsToAdd; i++) + checkboxes[i].click(); + }), + new BenchmarkTestStep("DeletingAllItems", (page) => { + const deleteButtons = page.querySelectorAll(".destroy"); + for (let i = numberOfItemsToAdd - 1; i >= 0; i--) + deleteButtons[i].click(); + }), + ], +}); + Object.freeze(Suites); Suites.forEach((suite) => { if (!suite.tags) diff --git a/resources/todomvc/dart2js-jaspr/base.css b/resources/todomvc/dart2js-jaspr/base.css new file mode 100644 index 000000000..da65968a7 --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/base.css @@ -0,0 +1,141 @@ +hr { + margin: 20px 0; + border: 0; + border-top: 1px dashed #c5c5c5; + border-bottom: 1px dashed #f7f7f7; +} + +.learn a { + font-weight: normal; + text-decoration: none; + color: #b83f45; +} + +.learn a:hover { + text-decoration: underline; + color: #787e7e; +} + +.learn h3, +.learn h4, +.learn h5 { + margin: 10px 0; + font-weight: 500; + line-height: 1.2; + color: #000; +} + +.learn h3 { + font-size: 24px; +} + +.learn h4 { + font-size: 18px; +} + +.learn h5 { + margin-bottom: 0; + font-size: 14px; +} + +.learn ul { + padding: 0; + margin: 0 0 30px 25px; +} + +.learn li { + line-height: 20px; +} + +.learn p { + font-size: 15px; + font-weight: 300; + line-height: 1.3; + margin-top: 0; + margin-bottom: 0; +} + +#issue-count { + display: none; +} + +.quote { + border: none; + margin: 20px 0 60px 0; +} + +.quote p { + font-style: italic; +} + +.quote p:before { + content: '“'; + font-size: 50px; + opacity: .15; + position: absolute; + top: -20px; + left: 3px; +} + +.quote p:after { + content: '”'; + font-size: 50px; + opacity: .15; + position: absolute; + bottom: -42px; + right: 3px; +} + +.quote footer { + position: absolute; + bottom: -40px; + right: 0; +} + +.quote footer img { + border-radius: 3px; +} + +.quote footer a { + margin-left: 5px; + vertical-align: middle; +} + +.speech-bubble { + position: relative; + padding: 10px; + background: rgba(0, 0, 0, .04); + border-radius: 5px; +} + +.speech-bubble:after { + content: ''; + position: absolute; + top: 100%; + right: 30px; + border: 13px solid transparent; + border-top-color: rgba(0, 0, 0, .04); +} + +.learn-bar > .learn { + position: absolute; + width: 272px; + top: 8px; + left: -300px; + padding: 10px; + border-radius: 5px; + background-color: rgba(255, 255, 255, .6); + transition-property: left; + transition-duration: 500ms; +} + +@media (min-width: 899px) { + .learn-bar { + width: auto; + padding-left: 300px; + } + + .learn-bar > .learn { + left: 8px; + } +} diff --git a/resources/todomvc/dart2js-jaspr/favicon.ico b/resources/todomvc/dart2js-jaspr/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..bd829b4fc70a3dc9baf443ebf39272c712b7bc46 GIT binary patch literal 2595 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 literal 0 HcmV?d00001 diff --git a/resources/todomvc/dart2js-jaspr/index.css b/resources/todomvc/dart2js-jaspr/index.css new file mode 100644 index 000000000..e2a84598a --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/index.css @@ -0,0 +1,393 @@ +@charset "utf-8"; + +html, +body { + margin: 0; + padding: 0; +} + +button { + margin: 0; + padding: 0; + border: 0; + background: none; + font-size: 100%; + vertical-align: baseline; + font-family: inherit; + font-weight: inherit; + color: inherit; + -webkit-appearance: none; + appearance: none; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +body { + font: 14px 'Helvetica Neue', Helvetica, Arial, sans-serif; + line-height: 1.4em; + background: #f5f5f5; + color: #111111; + min-width: 230px; + max-width: 550px; + margin: 0 auto; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + font-weight: 300; +} + +.hidden { + display: none; +} + +.todoapp { + background: #fff; + margin: 130px 0 40px 0; + position: relative; + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2), + 0 25px 50px 0 rgba(0, 0, 0, 0.1); +} + +.todoapp input::-webkit-input-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp input::-moz-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp input::input-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp h1 { + position: absolute; + top: -140px; + width: 100%; + font-size: 80px; + font-weight: 200; + text-align: center; + color: #b83f45; + -webkit-text-rendering: optimizeLegibility; + -moz-text-rendering: optimizeLegibility; + text-rendering: optimizeLegibility; +} + +.new-todo, +.edit { + position: relative; + margin: 0; + width: 100%; + font-size: 24px; + font-family: inherit; + font-weight: inherit; + line-height: 1.4em; + color: inherit; + padding: 6px; + border: 1px solid #999; + box-shadow: inset 0 -1px 5px 0 rgba(0, 0, 0, 0.2); + box-sizing: border-box; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +.new-todo { + padding: 16px 16px 16px 60px; + height: 65px; + border: none; + background: rgba(0, 0, 0, 0.003); + box-shadow: inset 0 -2px 1px rgba(0,0,0,0.03); +} + +.main { + position: relative; + z-index: 2; + border-top: 1px solid #e6e6e6; +} + +.toggle-all { + width: 1px; + height: 1px; + border: none; /* Mobile Safari */ + opacity: 0; + position: absolute; + right: 100%; + bottom: 100%; +} + +.toggle-all + label { + display: flex; + align-items: center; + justify-content: center; + width: 45px; + height: 65px; + font-size: 0; + position: absolute; + top: -65px; + left: -0; +} + +.toggle-all + label:before { + content: '❯'; + display: inline-block; + font-size: 22px; + color: #949494; + padding: 10px 27px 10px 27px; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); +} + +.toggle-all:checked + label:before { + color: #484848; +} + +.todo-list { + margin: 0; + padding: 0; + list-style: none; +} + +.todo-list li { + position: relative; + font-size: 24px; + border-bottom: 1px solid #ededed; +} + +.todo-list li:last-child { + border-bottom: none; +} + +.todo-list li.editing { + border-bottom: none; + padding: 0; +} + +.todo-list li.editing .edit { + display: block; + width: calc(100% - 43px); + padding: 12px 16px; + margin: 0 0 0 43px; +} + +.todo-list li.editing .view { + display: none; +} + +.todo-list li .toggle { + text-align: center; + width: 40px; + /* auto, since non-WebKit browsers doesn't support input styling */ + height: auto; + position: absolute; + top: 0; + bottom: 0; + margin: auto 0; + border: none; /* Mobile Safari */ + -webkit-appearance: none; + appearance: none; +} + +.todo-list li .toggle { + opacity: 0; +} + +.todo-list li .toggle + label { + /* + Firefox requires `#` to be escaped - https://bugzilla.mozilla.org/show_bug.cgi?id=922433 + IE and Edge requires *everything* to be escaped to render, so we do that instead of just the `#` - https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/7157459/ + */ + background-image: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%23949494%22%20stroke-width%3D%223%22/%3E%3C/svg%3E'); + background-repeat: no-repeat; + background-position: center left; +} + +.todo-list li .toggle:checked + label { + background-image: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%2359A193%22%20stroke-width%3D%223%22%2F%3E%3Cpath%20fill%3D%22%233EA390%22%20d%3D%22M72%2025L42%2071%2027%2056l-4%204%2020%2020%2034-52z%22%2F%3E%3C%2Fsvg%3E'); +} + +.todo-list li label { + word-break: break-all; + padding: 15px 15px 15px 60px; + display: block; + line-height: 1.2; + transition: color 0.4s; + font-weight: 400; + color: #484848; +} + +.todo-list li.completed label { + color: #949494; + text-decoration: line-through; +} + +.todo-list li .destroy { + display: none; + position: absolute; + top: 0; + right: 10px; + bottom: 0; + width: 40px; + height: 40px; + margin: auto 0; + font-size: 30px; + color: #949494; + transition: color 0.2s ease-out; +} + +.todo-list li .destroy:hover, +.todo-list li .destroy:focus { + color: #C18585; +} + +.todo-list li .destroy:after { + content: '×'; + display: block; + height: 100%; + line-height: 1.1; +} + +.todo-list li:hover .destroy { + display: block; +} + +.todo-list li .edit { + display: none; +} + +.todo-list li.editing:last-child { + margin-bottom: -1px; +} + +.footer { + padding: 10px 15px; + height: 20px; + text-align: center; + font-size: 15px; + border-top: 1px solid #e6e6e6; +} + +.footer:before { + content: ''; + position: absolute; + right: 0; + bottom: 0; + left: 0; + height: 50px; + overflow: hidden; + box-shadow: 0 1px 1px rgba(0, 0, 0, 0.2), + 0 8px 0 -3px #f6f6f6, + 0 9px 1px -3px rgba(0, 0, 0, 0.2), + 0 16px 0 -6px #f6f6f6, + 0 17px 2px -6px rgba(0, 0, 0, 0.2); +} + +.todo-count { + float: left; + text-align: left; +} + +.todo-count strong { + font-weight: 300; +} + +.filters { + margin: 0; + padding: 0; + list-style: none; + position: absolute; + right: 0; + left: 0; +} + +.filters li { + display: inline; +} + +.filters li span { + color: inherit; + margin: 3px; + padding: 3px 7px; + text-decoration: none; + border: 1px solid transparent; + border-radius: 3px; +} + +.filters li span:hover { + border-color: #DB7676; +} + +.filters li span.selected { + border-color: #CE4646; +} + +.clear-completed, +html .clear-completed:active { + float: right; + position: relative; + line-height: 19px; + text-decoration: none; + cursor: pointer; +} + +.clear-completed:hover { + text-decoration: underline; +} + +.info { + margin: 65px auto 0; + color: #4d4d4d; + font-size: 11px; + text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5); + text-align: center; +} + +.info p { + line-height: 1; +} + +.info a { + color: inherit; + text-decoration: none; + font-weight: 400; +} + +.info a:hover { + text-decoration: underline; +} + +/* + Hack to remove background from Mobile Safari. + Can't use it globally since it destroys checkboxes in Firefox +*/ +@media screen and (-webkit-min-device-pixel-ratio:0) { + .toggle-all, + .todo-list li .toggle { + background: none; + } + + .todo-list li .toggle { + height: 40px; + } +} + +@media (max-width: 430px) { + .footer { + height: 50px; + } + + .filters { + bottom: 10px; + } +} + +:focus, +.toggle:focus + label, +.toggle-all:focus + label { + box-shadow: 0 0 2px 2px #CF7D7D; + outline: 0; +} diff --git a/resources/todomvc/dart2js-jaspr/index.html b/resources/todomvc/dart2js-jaspr/index.html new file mode 100644 index 000000000..287dd21fd --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/index.html @@ -0,0 +1,22 @@ + + + + + + + + TodoMVC: Jaspr + + + + + + + + + + + diff --git a/resources/todomvc/dart2js-jaspr/main.clients.dart.js b/resources/todomvc/dart2js-jaspr/main.clients.dart.js new file mode 100644 index 000000000..07b0862cb --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/main.clients.dart.js @@ -0,0 +1,9770 @@ +// Generated by dart2js (, trust primitives, omit checks, lax runtime type, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.8.0-edge.4c8aedcb57fe678e6d30acfdc021aa9888576638. +// 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 an arbitrary argument +// string forwarded from the 'dart2js:load-priority' pragma option. +// 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 an +// arbitrary argument string forwarded from the 'dart2js:load-priority' +// pragma option. +// +// 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. +((s, d, e) => { + s[d] = s[d] || {}; + s[d][e] = s[d][e] || []; + s[d][e].push({p: "main", e: "beginPart"}); +})(self, "$__dart_deferred_initializers__", "eventLog"); +(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.$flags = 7; + 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) { + var t1 = A._setArrayType(allocation, $E._eval$1("JSArray<0>")); + t1.$flags = 1; + return t1; + }, + JSArray__compareAny(a, b) { + return J.compareTo$1$ns(a, b); + }, + 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$ns(receiver) { + if (typeof receiver == "number") + return J.JSNumber.prototype; + 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$isEmpty$asx(receiver) { + return J.getInterceptor$asx(receiver).get$isEmpty(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); + }, + $index$asx(receiver, a0) { + if (typeof a0 === "number") + if (Array.isArray(receiver) || typeof receiver == "string" || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) + if (a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0]; + return J.getInterceptor$asx(receiver).$index(receiver, a0); + }, + $indexSet$ax(receiver, a0, a1) { + if (typeof a0 === "number") + if ((Array.isArray(receiver) || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) && !(receiver.$flags & 2) && a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0] = a1; + return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); + }, + add$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).add$1(receiver, a0); + }, + compareTo$1$ns(receiver, a0) { + return J.getInterceptor$ns(receiver).compareTo$1(receiver, a0); + }, + elementAt$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); + }, + forEach$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); + }, + join$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).join$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() { + }, + LateError$fieldNI(fieldName) { + return new A.LateError("Field '" + fieldName + "' has not been initialized."); + }, + LateError$localNI(localName) { + return new A.LateError("Local '" + localName + "' has not been initialized."); + }, + SystemHash_combine(hash, value) { + hash = hash + value & 536870911; + hash = hash + ((hash & 524287) << 10) & 536870911; + return hash ^ hash >>> 6; + }, + SystemHash_finish(hash) { + hash = hash + ((hash & 67108863) << 3) & 536870911; + hash ^= hash >>> 11; + return hash + ((hash & 16383) << 15) & 536870911; + }, + 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; + }, + MappedIterable_MappedIterable(iterable, $function, $S, $T) { + if (type$.EfficientLengthIterable_dynamic._is(iterable)) + return new A.EfficientLengthMappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("EfficientLengthMappedIterable<1,2>")); + return new A.MappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("MappedIterable<1,2>")); + }, + IterableElementError_noElement() { + return new A.StateError("No element"); + }, + _CastIterableBase: function _CastIterableBase() { + }, + CastIterator: function CastIterator(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + _CastListBase: function _CastListBase() { + }, + CastList: function CastList(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + LateError: function LateError(t0) { + this._message = t0; + }, + SentinelValue: function SentinelValue() { + }, + 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; + }, + MappedIterable: function MappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + EfficientLengthMappedIterable: function EfficientLengthMappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + MappedIterator: function MappedIterator(t0, t1, t2) { + var _ = this; + _.__internal$_current = null; + _._iterator = t0; + _._f = t1; + _.$ti = t2; + }, + MappedListIterable: function MappedListIterable(t0, t1, t2) { + this._source = t0; + this._f = t1; + this.$ti = t2; + }, + WhereIterable: function WhereIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + WhereIterator: function WhereIterator(t0, t1) { + this._iterator = t0; + this._f = t1; + }, + FixedLengthListMixin: function FixedLengthListMixin() { + }, + ReversedListIterable: function ReversedListIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + __CastListBase__CastIterableBase_ListMixin: function __CastListBase__CastIterableBase_ListMixin() { + }, + 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_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 (object == null || 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); + if (object instanceof A._Record) + return object._toString$1(true); + return "Instance of '" + A.Primitives_objectTypeName(object) + "'"; + }, + Primitives_extractStackTrace(error) { + var jsError = error.$thrownJsError; + if (jsError == null) + return null; + return A.getTraceFromException(jsError); + }, + Primitives_trySetStackTrace(error, stackTrace) { + var jsError; + if (error.$thrownJsError == null) { + jsError = new Error(); + A.initializeExceptionWrapper(error, jsError); + error.$thrownJsError = jsError; + jsError.stack = stackTrace.toString$0(0); + } + }, + diagnoseIndexError(indexable, index) { + var $length, _s5_ = "index"; + if (!A._isInt(index)) + return new A.ArgumentError(true, index, _s5_, null); + $length = J.get$length$asx(indexable); + if (index < 0 || index >= $length) + return A.IndexError$withLength(index, $length, indexable, _s5_); + return A.RangeError$value(index, _s5_); + }, + wrapException(ex) { + return A.initializeExceptionWrapper(ex, new Error()); + }, + initializeExceptionWrapper(ex, wrapper) { + 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, wrapper) { + throw A.initializeExceptionWrapper(ex, wrapper == null ? new Error() : wrapper); + }, + throwUnsupportedOperation(o, operation, verb) { + var wrapper; + if (operation == null) + operation = 0; + if (verb == null) + verb = 0; + wrapper = Error(); + A.throwExpression(A._diagnoseUnsupportedOperation(o, operation, verb), wrapper); + }, + _diagnoseUnsupportedOperation(o, encodedOperation, encodedVerb) { + var operation, table, tableLength, index, verb, object, flags, article, adjective; + if (typeof encodedOperation == "string") + operation = encodedOperation; + else { + table = "[]=;add;removeWhere;retainWhere;removeRange;setRange;setInt8;setInt16;setInt32;setUint8;setUint16;setUint32;setFloat32;setFloat64".split(";"); + tableLength = table.length; + index = encodedOperation; + if (index > tableLength) { + encodedVerb = index / tableLength | 0; + index %= tableLength; + } + operation = table[index]; + } + verb = typeof encodedVerb == "string" ? encodedVerb : "modify;remove from;add to".split(";")[encodedVerb]; + object = type$.List_dynamic._is(o) ? "list" : "ByteData"; + flags = o.$flags | 0; + article = "a "; + if ((flags & 4) !== 0) + adjective = "constant "; + else if ((flags & 2) !== 0) { + adjective = "unmodifiable "; + article = "an "; + } else + adjective = (flags & 1) !== 0 ? "fixed-length " : ""; + return new A.UnsupportedError("'" + operation + "': Cannot " + verb + " " + article + adjective + object); + }, + 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) { + if (ex == null) + return new A.NullThrownFromJavaScriptException(ex); + if (ex instanceof A.ExceptionAndStackTrace) + return A.saveStackTrace(ex, ex.dartException); + 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$(message, match)); + else { + match = notClosure.matchTypeError$1(message); + if (match != null) { + match.method = "call"; + return A.saveStackTrace(ex, A.JsNoSuchMethodError$(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) + 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); + }, + fillLiteralMap(keyValuePairs, result) { + var index, index0, index1, + $length = keyValuePairs.length; + for (index = 0; index < $length; index = index1) { + index0 = index + 1; + index1 = index0 + 1; + result.$indexSet(0, keyValuePairs[index], keyValuePairs[index0]); + } + return result; + }, + _invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) { + switch (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 names, i, $name, + template = new A.BoundClosure("receiver", "interceptor"), + t1 = Object.getOwnPropertyNames(template); + t1.$flags = 1; + names = t1; + 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)); + }, + checkDeferredIsLoaded(loadId) { + if (!$._loadedLibraries.contains$1(0, loadId)) + throw A.wrapException(new A.DeferredNotLoadedError(loadId)); + }, + throwCyclicInit(staticName) { + throw A.wrapException(new A._CyclicInitializationError(staticName)); + }, + getIsolateAffinityTag($name) { + return init.getIsolateTag($name); + }, + _addEvent($event, hash, loadId, part) { + var dataObj = {p: part, e: $event}; + if (hash != null) + dataObj.h = hash; + dataObj.l = loadId; + dataObj.s = $.$get$thisScript(); + init.eventLog.push(dataObj); + }, + _getEventLog() { + var o = Array.from(init.eventLog).reverse(); + o.reduce((p, e, i, a) => { + e.i = a.length - i; + if (p == null) + return e.s; + if (e.s == null) + return p; + if (e.s === p) { + delete e.s; + return p; + } + return e.s; + }, null); + return o.map(e => JSON.stringify(e)).join("\n"); + }, + loadDeferredLibrary(loadId, priority) { + var t1, uris, hashes, index2uri, index2hash, i, index, total, isHunkLoaded, t2, deferredLibraryMultiLoader, _box_0 = {}, + indexes = init.deferredLibraryParts[loadId]; + if (indexes == null) + return A.Future_Future$value(null, type$.Null); + t1 = type$.JSArray_String; + uris = A._setArrayType([], t1); + hashes = A._setArrayType([], t1); + index2uri = init.deferredPartUris; + index2hash = init.deferredPartHashes; + for (i = 0; i < indexes.length; ++i) { + index = indexes[i]; + uris.push(index2uri[index]); + hashes.push(index2hash[index]); + } + total = hashes.length; + _box_0.waitingForLoad = A.List_List$filled(total, true, false, type$.bool); + _box_0.nextHunkToInitialize = 0; + isHunkLoaded = init.isHunkLoaded; + t1 = new A.loadDeferredLibrary_initializeSomeLoadedHunks(_box_0, total, uris, hashes, init.isHunkInitialized, loadId, isHunkLoaded, init.initializeLoadedHunk); + t2 = new A.loadDeferredLibrary_finalizeLoad(t1, loadId); + deferredLibraryMultiLoader = self.dartDeferredLibraryMultiLoader; + if (typeof deferredLibraryMultiLoader === "function") + return A._loadAllHunks(deferredLibraryMultiLoader, uris, hashes, loadId, priority, 0).then$1$1(new A.loadDeferredLibrary_closure(_box_0, total, t2), type$.Null); + return A.Future_wait(A.List_List$generate(total, new A.loadDeferredLibrary_loadAndInitialize(_box_0, hashes, isHunkLoaded, uris, loadId, priority, t1), type$.Future_dynamic), type$.dynamic).then$1$1(new A.loadDeferredLibrary_closure0(t2), type$.Null); + }, + _computeCspNonce() { + var nonce, + currentScript = init.currentScript; + if (currentScript == null) + return null; + nonce = currentScript.nonce; + return nonce != null && nonce !== "" ? nonce : currentScript.getAttribute("nonce"); + }, + _computeCrossOrigin() { + var currentScript = init.currentScript; + if (currentScript == null) + return null; + return currentScript.crossOrigin; + }, + _computePolicy() { + var newPolicy, + policyOptions = {createScriptURL: url => url}, + policyFactory = self.trustedTypes; + if (policyFactory == null) + return policyOptions; + newPolicy = policyFactory.createPolicy("dart:deferred-loading", policyOptions); + return newPolicy == null ? policyOptions : newPolicy; + }, + _getBasedScriptUrl(component, suffix) { + var base = $.$get$_thisScriptBaseUrl(), + encodedComponent = self.encodeURIComponent(component); + return $.$get$_deferredLoadingTrustedTypesPolicy().createScriptURL(base + encodedComponent + suffix); + }, + _computeThisScript() { + var currentScript = init.currentScript; + if (currentScript != null) + return String(currentScript.src); + if (!self.window && !!self.postMessage) + return A._computeThisScriptFromTrace(); + return null; + }, + _computeThisScriptFromTrace() { + var matches, + stack = new Error().stack; + if (stack == null) { + stack = function() { + try { + throw new Error(); + } catch (e) { + return e.stack; + } + }(); + if (stack == null) + throw A.wrapException(A.UnsupportedError$("No stack trace")); + } + matches = stack.match(new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m")); + if (matches != null) + return matches[1]; + matches = stack.match(new RegExp("^[^@]*@(.*):[0-9]*$", "m")); + if (matches != null) + return matches[1]; + throw A.wrapException(A.UnsupportedError$('Cannot extract URI from "' + stack + '"')); + }, + _loadAllHunks(loader, hunkNames, hashes, loadId, priority, retryCount) { + var hunksToLoad, urisToLoad, hashesToLoad, failure, jsSuccess, jsFailure, error, stackTrace, t1, pendingLoads, t2, i, hunkName, hash, completerForHunk, t3, base, encodedComponent, loadedHunksString, completer, exception, + isHunkLoaded = init.isHunkLoaded; + A._addEvent("startLoad", null, loadId, B.JSArray_methods.join$1(hunkNames, ";")); + t1 = type$.JSArray_String; + hunksToLoad = A._setArrayType([], t1); + urisToLoad = A._setArrayType([], t1); + hashesToLoad = A._setArrayType([], t1); + pendingLoads = A._setArrayType([], type$.JSArray_Future_dynamic); + for (t1 = retryCount > 0, t2 = "?dart2jsRetry=" + retryCount, i = 0; i < hunkNames.length; ++i) { + hunkName = hunkNames[i]; + hash = hashes[i]; + if (!isHunkLoaded(hash)) { + completerForHunk = $.$get$_loadingLibraries().$index(0, hunkName); + if (completerForHunk != null) { + pendingLoads.push(completerForHunk.future); + A._addEvent("reuse", null, loadId, hunkName); + } else { + J.add$1$ax(hunksToLoad, hunkName); + J.add$1$ax(hashesToLoad, hash); + t3 = t1 ? t2 : ""; + base = $.$get$_thisScriptBaseUrl(); + encodedComponent = self.encodeURIComponent(hunkName); + J.add$1$ax(urisToLoad, $.$get$_deferredLoadingTrustedTypesPolicy().createScriptURL(base + encodedComponent + t3).toString()); + } + } + } + if (J.get$length$asx(hunksToLoad) === 0) + return A.Future_wait(pendingLoads, type$.dynamic); + loadedHunksString = J.join$1$ax(hunksToLoad, ";"); + completer = new A._AsyncCompleter(new A._Future($.Zone__current, type$._Future_Null), type$._AsyncCompleter_Null); + J.forEach$1$ax(hunksToLoad, new A._loadAllHunks_closure(completer)); + A._addEvent("downloadMulti", null, loadId, loadedHunksString); + failure = new A._loadAllHunks_failure(retryCount, loadId, loader, priority, completer, loadedHunksString, hunksToLoad); + jsSuccess = A.convertDartClosureToJS(new A._loadAllHunks_success(hashesToLoad, isHunkLoaded, hunksToLoad, loadedHunksString, loadId, completer, failure), 0); + jsFailure = A.convertDartClosureToJS(new A._loadAllHunks_closure0(failure, hunksToLoad, hashesToLoad), 1); + try { + loader(urisToLoad, jsSuccess, jsFailure, loadId, priority); + } catch (exception) { + error = A.unwrapException(exception); + stackTrace = A.getTraceFromException(exception); + failure.call$5(error, "invoking dartDeferredLibraryMultiLoader hook", stackTrace, hunksToLoad, hashesToLoad); + } + t1 = A.List_List$of(pendingLoads, true, type$.Future_dynamic); + t1.push(completer.future); + return A.Future_wait(t1, type$.dynamic); + }, + _loadHunk(hunkName, loadId, priority, hash, retryCount) { + var uriAsString, deferredLibraryLoader, failure, jsSuccess, jsFailure, error, stackTrace, t3, exception, xhr, script, t1 = {}, + t2 = $.$get$_loadingLibraries(), + completer = t1.completer = t2.$index(0, hunkName); + A._addEvent("startLoad", null, loadId, hunkName); + t3 = completer == null; + if (!t3 && retryCount === 0) { + A._addEvent("reuse", null, loadId, hunkName); + return completer.future; + } + if (t3) { + completer = new A._AsyncCompleter(new A._Future($.Zone__current, type$._Future_Null), type$._AsyncCompleter_Null); + t2.$indexSet(0, hunkName, completer); + t1.completer = completer; + } + t2 = A._getBasedScriptUrl(hunkName, retryCount > 0 ? "?dart2jsRetry=" + retryCount : ""); + uriAsString = t2.toString(); + A._addEvent("download", null, loadId, hunkName); + deferredLibraryLoader = self.dartDeferredLibraryLoader; + failure = new A._loadHunk_failure(t1, retryCount, hunkName, loadId, priority, hash, uriAsString); + t3 = new A._loadHunk_success(t1, hash, hunkName, loadId, failure); + jsSuccess = A.convertDartClosureToJS(t3, 0); + jsFailure = A.convertDartClosureToJS(new A._loadHunk_closure(failure), 1); + if (typeof deferredLibraryLoader === "function") + try { + deferredLibraryLoader(uriAsString, jsSuccess, jsFailure, loadId, priority); + } catch (exception) { + error = A.unwrapException(exception); + stackTrace = A.getTraceFromException(exception); + failure.call$3(error, "invoking dartDeferredLibraryLoader hook", stackTrace); + } + else if (!self.window && !!self.postMessage) { + xhr = new XMLHttpRequest(); + xhr.open("GET", uriAsString); + xhr.addEventListener("load", A.convertDartClosureToJS(new A._loadHunk_closure0(xhr, failure, t3), 1), false); + xhr.addEventListener("error", new A._loadHunk_closure1(failure), false); + xhr.addEventListener("abort", new A._loadHunk_closure2(failure), false); + xhr.send(); + } else { + script = document.createElement("script"); + script.type = "text/javascript"; + script.src = t2; + t2 = $.$get$_cspNonce(); + if (t2 != null && t2 !== "") { + script.nonce = t2; + script.setAttribute("nonce", $.$get$_cspNonce()); + } + t2 = $.$get$_crossOrigin(); + if (t2 != null && t2 !== "") + script.crossOrigin = t2; + script.addEventListener("load", jsSuccess, false); + script.addEventListener("error", jsFailure, false); + document.body.appendChild(script); + } + return t1.completer.future; + }, + lookupAndCacheInterceptor(obj) { + var interceptor, interceptorClass, altTag, mark, t1, + tag = $.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 = $.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); + }, + JSSyntaxRegExp_makeNative(source, multiLine, caseSensitive, unicode, dotAll, global) { + var m = multiLine ? "m" : "", + i = caseSensitive ? "" : "i", + u = unicode ? "u" : "", + s = dotAll ? "s" : "", + g = global ? "g" : "", + regexp = function(source, modifiers) { + try { + return new RegExp(source, modifiers); + } catch (e) { + return e; + } + }(source, m + i + u + s + g); + if (regexp instanceof RegExp) + return regexp; + throw A.wrapException(A.FormatException$("Illegal RegExp pattern (" + String(regexp) + ")", source)); + }, + quoteStringForRegExp(string) { + if (/[[\]{}()*+?.\\^$|]/.test(string)) + return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&"); + return string; + }, + _stringIdentity(string) { + return string; + }, + stringReplaceAllFuncUnchecked(receiver, pattern, onMatch, onNonMatch) { + var match, t4, t5, + t1 = new A._AllMatchesIterator(pattern, receiver, 0), + t2 = type$.RegExpMatch, + startIndex = 0, t3 = ""; + for (; t1.moveNext$0();) { + match = t1.__js_helper$_current; + if (match == null) + match = t2._as(match); + t4 = match._match; + t5 = t4.index; + t3 = t3 + A.S(A._stringIdentity(B.JSString_methods.substring$2(receiver, startIndex, t5))) + A.S(onMatch.call$1(match)); + startIndex = t5 + t4[0].length; + } + t1 = t3 + A.S(A._stringIdentity(B.JSString_methods.substring$1(receiver, startIndex))); + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _Record_2: function _Record_2(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_isActive_todo: function _Record_2_isActive_todo(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_3: function _Record_3(t0, t1, t2) { + this._0 = t0; + this._1 = t1; + this._2 = t2; + }, + ConstantMap: function ConstantMap() { + }, + ConstantStringMap: function ConstantStringMap(t0, t1, t2) { + this._jsIndex = t0; + this._values = t1; + this.$ti = t2; + }, + _KeysOrValues: function _KeysOrValues(t0, t1) { + this.__js_helper$_elements = t0; + this.$ti = t1; + }, + _KeysOrValuesOrElementsIterator: function _KeysOrValuesOrElementsIterator(t0, t1, t2) { + var _ = this; + _.__js_helper$_elements = t0; + _.__js_helper$_length = t1; + _.__js_helper$_index = 0; + _.__js_helper$_current = null; + _.$ti = 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; + }, + DeferredNotLoadedError: function DeferredNotLoadedError(t0) { + this.libraryName = t0; + }, + loadDeferredLibrary_initializeSomeLoadedHunks: function loadDeferredLibrary_initializeSomeLoadedHunks(t0, t1, t2, t3, t4, t5, t6, t7) { + var _ = this; + _._box_0 = t0; + _.total = t1; + _.uris = t2; + _.hashes = t3; + _.isHunkInitialized = t4; + _.loadId = t5; + _.isHunkLoaded = t6; + _.initializer = t7; + }, + loadDeferredLibrary_finalizeLoad: function loadDeferredLibrary_finalizeLoad(t0, t1) { + this.initializeSomeLoadedHunks = t0; + this.loadId = t1; + }, + loadDeferredLibrary_closure: function loadDeferredLibrary_closure(t0, t1, t2) { + this._box_0 = t0; + this.total = t1; + this.finalizeLoad = t2; + }, + loadDeferredLibrary_loadAndInitialize: function loadDeferredLibrary_loadAndInitialize(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._box_0 = t0; + _.hashes = t1; + _.isHunkLoaded = t2; + _.uris = t3; + _.loadId = t4; + _.priority = t5; + _.initializeSomeLoadedHunks = t6; + }, + loadDeferredLibrary_loadAndInitialize_closure: function loadDeferredLibrary_loadAndInitialize_closure(t0, t1, t2) { + this._box_0 = t0; + this.i = t1; + this.initializeSomeLoadedHunks = t2; + }, + loadDeferredLibrary_closure0: function loadDeferredLibrary_closure0(t0) { + this.finalizeLoad = t0; + }, + _loadAllHunks_closure: function _loadAllHunks_closure(t0) { + this.completer = t0; + }, + _loadAllHunks_failure: function _loadAllHunks_failure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.retryCount = t0; + _.loadId = t1; + _.loader = t2; + _.priority = t3; + _.completer = t4; + _.loadedHunksString = t5; + _.hunksToLoad = t6; + }, + _loadAllHunks_failure_closure: function _loadAllHunks_failure_closure(t0) { + this.completer = t0; + }, + _loadAllHunks_failure_closure0: function _loadAllHunks_failure_closure0() { + }, + _loadAllHunks_success: function _loadAllHunks_success(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _.hashesToLoad = t0; + _.isHunkLoaded = t1; + _.hunksToLoad = t2; + _.loadedHunksString = t3; + _.loadId = t4; + _.completer = t5; + _.failure = t6; + }, + _loadAllHunks_closure0: function _loadAllHunks_closure0(t0, t1, t2) { + this.failure = t0; + this.hunksToLoad = t1; + this.hashesToLoad = t2; + }, + _loadHunk_failure: function _loadHunk_failure(t0, t1, t2, t3, t4, t5, t6) { + var _ = this; + _._box_0 = t0; + _.retryCount = t1; + _.hunkName = t2; + _.loadId = t3; + _.priority = t4; + _.hash = t5; + _.uriAsString = t6; + }, + _loadHunk_success: function _loadHunk_success(t0, t1, t2, t3, t4) { + var _ = this; + _._box_0 = t0; + _.hash = t1; + _.hunkName = t2; + _.loadId = t3; + _.failure = t4; + }, + _loadHunk_closure: function _loadHunk_closure(t0) { + this.failure = t0; + }, + _loadHunk_closure0: function _loadHunk_closure0(t0, t1, t2) { + this.xhr = t0; + this.failure = t1; + this.success = t2; + }, + _loadHunk_closure1: function _loadHunk_closure1(t0) { + this.failure = t0; + }, + _loadHunk_closure2: function _loadHunk_closure2(t0) { + this.failure = t0; + }, + JsLinkedHashMap: function JsLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _._last = _._first = _.__js_helper$_rest = _._nums = _._strings = null; + _._modifications = 0; + _.$ti = t0; + }, + JsLinkedHashMap_addAll_closure: function JsLinkedHashMap_addAll_closure(t0) { + this.$this = t0; + }, + LinkedHashMapCell: function LinkedHashMapCell(t0, t1) { + var _ = this; + _.hashMapCellKey = t0; + _.hashMapCellValue = t1; + _._previous = _._next = null; + }, + LinkedHashMapKeysIterable: function LinkedHashMapKeysIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + LinkedHashMapKeyIterator: function LinkedHashMapKeyIterator(t0, t1, t2) { + var _ = this; + _._map = t0; + _._modifications = t1; + _._cell = t2; + _.__js_helper$_current = null; + }, + LinkedHashMapEntriesIterable: function LinkedHashMapEntriesIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + LinkedHashMapEntryIterator: function LinkedHashMapEntryIterator(t0, t1, t2, t3) { + var _ = this; + _._map = t0; + _._modifications = t1; + _._cell = t2; + _.__js_helper$_current = null; + _.$ti = t3; + }, + 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; + }, + _Record: function _Record() { + }, + _Record2: function _Record2() { + }, + _Record3: function _Record3() { + }, + JSSyntaxRegExp: function JSSyntaxRegExp(t0, t1) { + var _ = this; + _.pattern = t0; + _._nativeRegExp = t1; + _._nativeAnchoredRegExp = _._nativeGlobalRegExp = null; + }, + _MatchImplementation: function _MatchImplementation(t0) { + this._match = t0; + }, + _AllMatchesIterator: function _AllMatchesIterator(t0, t1, t2) { + var _ = this; + _._regExp = t0; + _._string = t1; + _._nextIndex = t2; + _.__js_helper$_current = null; + }, + throwLateFieldADI(fieldName) { + throw A.initializeExceptionWrapper(new A.LateError("Field '" + fieldName + "' has been assigned during initialization."), new Error()); + }, + throwUnnamedLateFieldNI() { + throw A.initializeExceptionWrapper(A.LateError$fieldNI(""), new Error()); + }, + _Cell$() { + var t1 = new A._Cell(); + return t1._value = t1; + }, + _Cell: function _Cell() { + this._value = null; + }, + _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; + if (object instanceof A._Record) + return object._getRti$0(); + 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; + }, + evaluateRtiForRecord(recordRecipe, valuesList) { + var bindings, i, + values = valuesList, + $length = values.length; + if ($length === 0) + return type$.Record_0; + bindings = A._Universe_evalInEnvironment(init.typeUniverse, A._structuralTypeOf(values[0]), "@<0>"); + for (i = 1; i < $length; ++i) + bindings = A._Universe_bind(init.typeUniverse, bindings, A._structuralTypeOf(values[i])); + return A._Universe_evalInEnvironment(init.typeUniverse, bindings, recordRecipe); + }, + 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; + } + if (testRti === type$.int) + asFn = A._asInt; + else if (testRti === type$.nullable_int) + asFn = A._asIntQ; + else if (testRti === type$.String) + asFn = A._asString; + else if (testRti === type$.nullable_String) + asFn = A._asStringQ; + else if (testRti === type$.bool) + asFn = A._asBool; + else if (testRti === type$.nullable_bool) + asFn = A._asBoolQ; + else if (testRti === type$.num) + asFn = A._asNum; + else if (testRti === type$.nullable_num) + asFn = A._asNumQ; + else if (testRti === type$.double) + asFn = A._asDouble; + else if (testRti === type$.nullable_double) + asFn = A._asDoubleQ; + testRti._as = asFn; + return testRti._as(object); + }, + _nullIs(testRti) { + var kind = testRti._kind, + t1 = true; + 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; + 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; + throw A.initializeExceptionWrapper(A._errorForAsCheck(object, testRti), new Error()); + }, + _generalNullableAsCheckImplementation(object) { + var testRti = this; + if (object == null) + return object; + else if (testRti._is(object)) + return object; + throw A.initializeExceptionWrapper(A._errorForAsCheck(object, testRti), new Error()); + }, + _errorForAsCheck(object, testRti) { + return new A._TypeError("TypeError: " + 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__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.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "Object"), new Error()); + }, + _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.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool"), new Error()); + }, + _asBoolS(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool"), new Error()); + }, + _asBoolQ(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool?"), new Error()); + }, + _asDouble(object) { + if (typeof object == "number") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double"), new Error()); + }, + _asDoubleS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double"), new Error()); + }, + _asDoubleQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double?"), new Error()); + }, + _isInt(object) { + return typeof object == "number" && Math.floor(object) === object; + }, + _asInt(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int"), new Error()); + }, + _asIntS(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int"), new Error()); + }, + _asIntQ(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int?"), new Error()); + }, + _isNum(object) { + return typeof object == "number"; + }, + _asNum(object) { + if (typeof object == "number") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num"), new Error()); + }, + _asNumS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num"), new Error()); + }, + _asNumQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num?"), new Error()); + }, + _isString(object) { + return typeof object == "string"; + }, + _asString(object) { + if (typeof object == "string") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String"), new Error()); + }, + _asStringS(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String"), new Error()); + }, + _asStringQ(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String?"), new Error()); + }, + _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, offset, i, t1, t2, typeParametersText, typeSep, boundRti, kind, t3, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ", outerContextLength = null; + if (bounds != null) { + boundsLength = bounds.length; + if (genericContext == null) + genericContext = A._setArrayType([], type$.JSArray_String); + else + outerContextLength = genericContext.length; + offset = genericContext.length; + for (i = boundsLength; i > 0; --i) + genericContext.push("T" + (offset + i)); + for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) { + typeParametersText = typeParametersText + typeSep + genericContext[genericContext.length - 1 - i]; + 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 = ""; + 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, + 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; + return genericContext[genericContext.length - 1 - 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; + t1 = true; + if (!A.isSoundTopType(baseType)) + if (!(baseType === type$.Null || baseType === type$.JSNull)) + if (baseKind !== 7) + t1 = baseKind === 8 && A.isNullable(baseType._primary); + 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 requiredPositional, returnType, parameters, + t1 = parser.u, + head = stack.pop(), + optionalPositional = null, named = null; + if (typeof head == "number") + switch (head) { + case -1: + optionalPositional = stack.pop(); + break; + case -2: + named = stack.pop(); + break; + default: + stack.push(head); + break; + } + else + stack.push(head); + 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 kind = t._kind, + t1 = true; + 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); + 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 t1, div, span; + if (self.scheduleImmediate != null) + return A.async__AsyncRun__scheduleImmediateJsOverride$closure(); + if (self.MutationObserver != null && self.document != null) { + t1 = {}; + 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(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithSetImmediate(callback) { + self.setImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithTimer(callback) { + A._TimerImpl$(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$1(new A._wrapJsFunctionForAsync_closure($protected)); + }, + _SyncStarIterator__terminatedBody(_1, _2, _3) { + return 0; + }, + AsyncError_defaultStackTrace(error) { + var stackTrace; + if (type$.Error._is(error)) { + stackTrace = error.get$stackTrace(); + if (stackTrace != null) + return stackTrace; + } + return B.C__StringStackTrace; + }, + DeferredLoadException$(message) { + return new A.DeferredLoadException(message); + }, + Future_Future$value(value, $T) { + var t1; + $T._as(value); + t1 = new A._Future($.Zone__current, $T._eval$1("_Future<0>")); + t1._asyncComplete$1(value); + return t1; + }, + Future_wait(futures, $T) { + var handleError, future, pos, e, s, t1, t2, _i, t3, exception, t4, _box_0 = {}, cleanUp = null, + eagerError = false, + _future = new A._Future($.Zone__current, $T._eval$1("_Future>")); + _box_0.values = null; + _box_0.remaining = 0; + _box_0.stackTrace = _box_0.error = null; + handleError = new A.Future_wait_handleError(_box_0, cleanUp, eagerError, _future); + try { + for (t1 = futures.length, t2 = type$.Null, _i = 0, t3 = 0; _i < futures.length; futures.length === t1 || (0, A.throwConcurrentModificationError)(futures), ++_i) { + future = futures[_i]; + pos = t3; + future.then$1$2$onError(new A.Future_wait_closure(_box_0, pos, _future, $T, cleanUp, eagerError), handleError, t2); + t3 = ++_box_0.remaining; + } + if (t3 === 0) { + t1 = _future; + t1._completeWithValue$1(A._setArrayType([], $T._eval$1("JSArray<0>"))); + return t1; + } + _box_0.values = A.List_List$filled(t3, null, false, $T._eval$1("0?")); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + if (_box_0.remaining === 0 || eagerError) { + t1 = _future; + t2 = e; + t3 = s; + t4 = A._interceptError(t2, t3); + t2 = new A.AsyncError(t2, t3 == null ? A.AsyncError_defaultStackTrace(t2) : t3); + t1._asyncCompleteErrorObject$1(t2); + return t1; + } else { + _box_0.error = e; + _box_0.stackTrace = s; + } + } + return _future; + }, + _interceptError(error, stackTrace) { + if ($.Zone__current === B.C__RootZone) + return null; + return null; + }, + _interceptUserError(error, stackTrace) { + if ($.Zone__current !== B.C__RootZone) + A._interceptError(error, stackTrace); + if (stackTrace == null) + if (type$.Error._is(error)) { + stackTrace = error.get$stackTrace(); + if (stackTrace == null) { + A.Primitives_trySetStackTrace(error, B.C__StringStackTrace); + stackTrace = B.C__StringStackTrace; + } + } else + stackTrace = B.C__StringStackTrace; + else if (type$.Error._is(error)) + A.Primitives_trySetStackTrace(error, stackTrace); + return new A.AsyncError(error, stackTrace); + }, + _Future__chainCoreFuture(source, target, sync) { + var t2, ignoreError, listeners, _box_0 = {}, + t1 = _box_0.source = source; + for (; t2 = t1._state, (t2 & 4) !== 0;) { + t1 = t1._resultOrListeners; + _box_0.source = t1; + } + if (t1 === target) { + t2 = A.StackTrace_current(); + target._asyncCompleteErrorObject$1(new A.AsyncError(new A.ArgumentError(true, t1, null, "Cannot complete a future with itself"), t2)); + return; + } + ignoreError = target._state & 1; + t2 = t1._state = t2 | ignoreError; + if ((t2 & 24) === 0) { + listeners = target._resultOrListeners; + target._state = target._state & 1 | 4; + target._resultOrListeners = t1; + t1._prependListeners$1(listeners); + return; + } + if (!sync) + if (target._resultOrListeners == null) + t1 = (t2 & 16) === 0 || ignoreError !== 0; + else + t1 = false; + else + t1 = true; + if (t1) { + listeners = target._removeListeners$0(); + target._cloneResult$1(_box_0.source); + A._Future__propagateToListeners(target, listeners); + return; + } + target._state ^= 2; + A._rootScheduleMicrotask(null, null, target._zone, new A._Future__chainCoreFuture_closure(_box_0, target)); + }, + _Future__propagateToListeners(source, listeners) { + var _box_0, t2, t3, hasError, nextListener, nextListener0, sourceResult, t4, zone, oldZone, result, current, _box_1 = {}, + t1 = _box_1.source = source; + for (; true;) { + _box_0 = {}; + t2 = t1._state; + t3 = (t2 & 16) === 0; + hasError = !t3; + if (listeners == null) { + if (hasError && (t2 & 1) === 0) { + t1 = t1._resultOrListeners; + A._rootHandleError(t1.error, t1.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; + } + t2 = _box_1.source; + sourceResult = t2._resultOrListeners; + _box_0.listenerHasError = hasError; + _box_0.listenerValueOrError = sourceResult; + if (t3) { + t4 = t1.state; + t4 = (t4 & 1) !== 0 || (t4 & 15) === 8; + } else + t4 = true; + if (t4) { + zone = t1.result._zone; + if (hasError) { + t2 = t2._zone === zone; + t2 = !(t2 || t2); + } else + t2 = false; + if (t2) { + 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 (t3) { + 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) { + t2 = _box_0.listener.$ti; + t2 = t2._eval$1("Future<2>")._is(t1) || !t2._rest[1]._is(t1); + } else + t2 = false; + if (t2) { + result = _box_0.listener.result; + if ((t1._state & 24) !== 0) { + current = 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__chainCoreFuture(t1, result, true); + return; + } + } + result = _box_0.listener.result; + current = result._resultOrListeners; + result._resultOrListeners = null; + listeners = result._reverseListeners$1(current); + t1 = _box_0.listenerHasError; + t2 = _box_0.listenerValueOrError; + if (!t1) { + result._state = 8; + result._resultOrListeners = t2; + } else { + result._state = result._state & 1 | 16; + result._resultOrListeners = t2; + } + _box_1.source = result; + t1 = result; + } + }, + _registerErrorHandler(errorHandler, zone) { + if (type$.dynamic_Function_Object_StackTrace._is(errorHandler)) + return zone.registerBinaryCallback$1(errorHandler); + if (type$.dynamic_Function_Object._is(errorHandler)) + return 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, currentZone.bindCallbackGuarded$1(callback)); + }, + StreamIterator_StreamIterator(stream) { + A.checkNotNullable(stream, "stream", type$.Object); + return new A._StreamIterator(); + }, + _rootHandleError(error, stackTrace) { + A._schedulePriorityAsyncCallback(new A._rootHandleError_closure(error, stackTrace)); + }, + _rootRun($self, $parent, zone, f) { + 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) { + 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) { + 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) { + 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() { + }, + _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; + }, + _SyncStarIterator: function _SyncStarIterator(t0) { + var _ = this; + _._body = t0; + _._suspendedBodies = _._nestedIterator = _._datum = _._async$_current = null; + }, + _SyncStarIterable: function _SyncStarIterable(t0, t1) { + this._outerHelper = t0; + this.$ti = t1; + }, + AsyncError: function AsyncError(t0, t1) { + this.error = t0; + this.stackTrace = t1; + }, + DeferredLoadException: function DeferredLoadException(t0) { + this._async$_message = t0; + }, + Future_wait_handleError: function Future_wait_handleError(t0, t1, t2, t3) { + var _ = this; + _._box_0 = t0; + _.cleanUp = t1; + _.eagerError = t2; + _._future = t3; + }, + Future_wait_closure: function Future_wait_closure(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._box_0 = t0; + _.pos = t1; + _._future = t2; + _.T = t3; + _.cleanUp = t4; + _.eagerError = t5; + }, + _Completer: function _Completer() { + }, + _AsyncCompleter: function _AsyncCompleter(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__chainCoreFuture_closure: function _Future__chainCoreFuture_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__asyncCompleteErrorObject_closure: function _Future__asyncCompleteErrorObject_closure(t0, t1) { + this.$this = t0; + this.error = t1; + }, + _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, t1) { + this.joinedResult = t0; + this.originalSource = t1; + }, + _Future__propagateToListeners_handleWhenCompleteCallback_closure0: function _Future__propagateToListeners_handleWhenCompleteCallback_closure0(t0) { + this.joinedResult = 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; + }, + _StreamIterator: function _StreamIterator() { + }, + _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; + }, + LinkedHashMap_LinkedHashMap$_literal(keyValuePairs, $K, $V) { + return A.fillLiteralMap(keyValuePairs, new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>"))); + }, + LinkedHashMap_LinkedHashMap$_empty($K, $V) { + return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + HashSet_HashSet($E) { + return new A._HashSet($E._eval$1("_HashSet<0>")); + }, + _HashSet__newHashTable() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + }, + LinkedHashSet_LinkedHashSet($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + LinkedHashSet_LinkedHashSet$_empty($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + _LinkedHashSet__newHashTable() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + }, + _LinkedHashSetIterator$(_set, _modifications, $E) { + var t1 = new A._LinkedHashSetIterator(_set, _modifications, $E._eval$1("_LinkedHashSetIterator<0>")); + t1._collection$_cell = _set._collection$_first; + return t1; + }, + IterableExtensions_get_firstOrNull(_this) { + var iterator = J.get$iterator$ax(_this); + if (iterator.moveNext$0()) + return iterator.get$current(); + return null; + }, + MapBase_mapToString(m) { + var result, t1; + if (A.isToStringVisiting(m)) + return "{...}"; + result = new A.StringBuffer(""); + try { + t1 = {}; + $.toStringVisiting.push(m); + result._contents += "{"; + t1.first = true; + m.forEach$1(0, new A.MapBase_mapToString_closure(t1, result)); + result._contents += "}"; + } finally { + $.toStringVisiting.pop(); + } + t1 = result._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _HashSet: function _HashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._elements = _._collection$_rest = _._collection$_nums = _._collection$_strings = null; + _.$ti = t0; + }, + _HashSetIterator: function _HashSetIterator(t0, t1, t2) { + var _ = this; + _._set = t0; + _._elements = t1; + _._offset = 0; + _._collection$_current = null; + _.$ti = t2; + }, + _LinkedHashSet: function _LinkedHashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._collection$_last = _._collection$_first = _._collection$_rest = _._collection$_nums = _._collection$_strings = null; + _._collection$_modifications = 0; + _.$ti = t0; + }, + _LinkedHashSetCell: function _LinkedHashSetCell(t0) { + this._element = t0; + this._collection$_previous = this._collection$_next = null; + }, + _LinkedHashSetIterator: function _LinkedHashSetIterator(t0, t1, t2) { + var _ = this; + _._set = t0; + _._collection$_modifications = t1; + _._collection$_current = _._collection$_cell = null; + _.$ti = t2; + }, + ListBase: function ListBase() { + }, + MapBase: function MapBase() { + }, + MapBase_entries_closure: function MapBase_entries_closure(t0) { + this.$this = t0; + }, + MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) { + this._box_0 = t0; + this.result = t1; + }, + SetBase: function SetBase() { + }, + _SetBase: function _SetBase() { + }, + _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); + 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 (!Array.isArray(object)) + return new A._JsonMap(object, Object.create(null)); + for (i = 0; i < object.length; ++i) + object[i] = A._convertJsonToDartLazy(object[i]); + return object; + }, + _JsonMap: function _JsonMap(t0, t1) { + this._original = t0; + this._processed = t1; + this._data = null; + }, + _JsonMapKeyIterable: function _JsonMapKeyIterable(t0) { + this._convert$_parent = t0; + }, + Codec: function Codec() { + }, + Converter: function Converter() { + }, + JsonCodec: function JsonCodec() { + }, + JsonDecoder: function JsonDecoder(t0) { + this._reviver = t0; + }, + Error__throw(error, stackTrace) { + error = A.initializeExceptionWrapper(error, new Error()); + error.stack = stackTrace.toString$0(0); + throw error; + }, + 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$from(elements, growable, $E) { + var t1, _i, + list = A._setArrayType([], $E._eval$1("JSArray<0>")); + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + list.push(elements[_i]); + list.$flags = 1; + return list; + }, + 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();) + list.push(t1.get$current()); + return list; + }, + List_List$generate($length, generator, $E) { + var i, + result = J.JSArray_JSArray$growable($length, $E); + for (i = 0; i < $length; ++i) + result[i] = generator.call$1(i); + return result; + }, + RegExp_RegExp(source) { + return new A.JSSyntaxRegExp(source, A.JSSyntaxRegExp_makeNative(source, false, true, false, false, false)); + }, + 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; + }, + StackTrace_current() { + return A.getTraceFromException(new Error()); + }, + 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); + }, + 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, $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) { + return new A.FormatException(message, source); + }, + 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); + $.toStringVisiting.push(iterable); + try { + A._iterablePartsToStrings(iterable, parts); + } finally { + $.toStringVisiting.pop(); + } + t1 = A.StringBuffer__writeAll(leftDelimiter, 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); + $.toStringVisiting.push(iterable); + try { + t1 = buffer; + t1._contents = A.StringBuffer__writeAll(t1._contents, iterable, ", "); + } finally { + $.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()); + parts.push(next); + $length += next.length + 2; + ++count; + } + if (!it.moveNext$0()) { + if (count <= 5) + return; + ultimateString = parts.pop(); + penultimateString = parts.pop(); + } else { + penultimate = it.get$current(); + ++count; + if (!it.moveNext$0()) { + if (count <= 4) { + parts.push(A.S(penultimate)); + return; + } + ultimateString = A.S(penultimate); + 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; + $length -= parts.pop().length + 2; + --count; + } + parts.push("..."); + 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; + $length -= parts.pop().length + 2; + if (elision == null) { + $length += 5; + elision = "..."; + } + } + if (elision != null) + parts.push(elision); + parts.push(penultimateString); + parts.push(ultimateString); + }, + Object_hash(object1, object2, object3, object4) { + var t1; + if (B.C_SentinelValue === object3) { + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2)); + } + if (B.C_SentinelValue === object4) { + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3)); + } + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + object4 = J.get$hashCode$(object4); + object4 = A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3), object4)); + return object4; + }, + Object_hashAll(objects) { + var t1, _i, + hash = $.$get$_hashSeed(); + for (t1 = objects.length, _i = 0; _i < objects.length; objects.length === t1 || (0, A.throwConcurrentModificationError)(objects), ++_i) + hash = A.SystemHash_combine(hash, J.get$hashCode$(objects[_i])); + return A.SystemHash_finish(hash); + }, + print(object) { + A.printString(object); + }, + _Enum: function _Enum() { + }, + 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; + }, + 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; + }, + StackOverflowError: function StackOverflowError() { + }, + _Exception: function _Exception(t0) { + this.message = t0; + }, + FormatException: function FormatException(t0, t1) { + this.message = t0; + this.source = t1; + }, + Iterable: function Iterable() { + }, + MapEntry: function MapEntry(t0, t1, t2) { + this.key = t0; + this.value = t1; + this.$ti = t2; + }, + Null: function Null() { + }, + Object: function Object() { + }, + _StringStackTrace: function _StringStackTrace() { + }, + StringBuffer: function StringBuffer(t0) { + this._contents = t0; + }, + BrowserAppBinding: function BrowserAppBinding(t0, t1, t2) { + var _ = this; + _.__BrowserAppBinding_attachBetween_A = _.__BrowserAppBinding_attachTarget_A = $; + _.ComponentsBinding__rootElement = t0; + _.SchedulerBinding__schedulerPhase = t1; + _.SchedulerBinding__postFrameCallbacks = t2; + }, + _BrowserAppBinding_AppBinding_ComponentsBinding: function _BrowserAppBinding_AppBinding_ComponentsBinding() { + }, + registerClients(clients) { + A._applyClients(new A.registerClients_closure(A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.Component_Function_Map_String_dynamic), clients)); + }, + loadClient(loader, builder) { + return new A.loadClient_closure(loader, builder); + }, + _applyClients(fn) { + var t2, t3, currNode, value, match, t4, t5, comp, start, params, + t1 = self, + iterator = t1.document.createNodeIterator(t1.document, 128), + nodes = A._setArrayType([], type$.JSArray_Record_3_String_and_nullable_String_and_JSObject); + for (t1 = type$.String, t2 = type$.dynamic, t3 = type$.Map_String_dynamic; currNode = iterator.nextNode(), currNode != null;) { + value = currNode.nodeValue; + if (value == null) + value = ""; + match = $.$get$_compStartRegex().firstMatch$1(value); + if (match != null) { + t4 = match._match; + t5 = t4[1]; + t5.toString; + nodes.push(new A._Record_3(t5, t4[2], currNode)); + } + match = $.$get$_compEndRegex().firstMatch$1(value); + if (match != null) { + t4 = match._match[1]; + t4.toString; + if (B.JSArray_methods.get$last(nodes)._0 === t4) { + comp = nodes.pop(); + start = comp._2; + start.textContent = "@" + comp._0; + t5 = comp._1; + params = t5 != null ? t3._as(B.C_JsonCodec.decode$2$reviver(A.unescapeMarkerText(t5), null)) : A.LinkedHashMap_LinkedHashMap$_empty(t1, t2); + A._runBuilder(t4, fn.call$1(t4), params, new A._Record_2(start, currNode)); + } + } + } + }, + _runBuilder($name, builder, params, between) { + builder.toString; + return A._runBuilder$body($name, builder, params, between); + }, + _runBuilder$body($name, builder, params, between) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + e, st, t2, exception, t1; + var $async$_runBuilder = 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 = builder; + t1.toString; + builder = t1; + $async$goto = type$.Future_of_Component_Function_Map_String_dynamic._is(builder) ? 2 : 3; + break; + case 2: + // then + $async$goto = 4; + return A._asyncAwait(builder, $async$_runBuilder); + case 4: + // returning from await. + builder = $async$result; + case 3: + // join + try { + t1 = new A.BrowserAppBinding(null, B.SchedulerPhase_0, A._setArrayType([], type$.JSArray_of_void_Function)); + t2 = type$.Component_Function_Map_String_dynamic._as(builder).call$1(params); + t1.__BrowserAppBinding_attachTarget_A = "body"; + t1.__BrowserAppBinding_attachBetween_A = between; + t1.super$ComponentsBinding$attachRootComponent(t2); + } catch (exception) { + e = A.unwrapException(exception); + st = A.getTraceFromException(exception); + t1 = A.Error_throwWithStackTrace("Failed to attach client component '" + $name + "'. The following error occurred: " + A.S(e), st); + throw A.wrapException(t1); + } + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$_runBuilder, $async$completer); + }, + registerClients_closure: function registerClients_closure(t0, t1) { + this.builders = t0; + this.clients = t1; + }, + registerClients__closure: function registerClients__closure(t0, t1) { + this.name = t0; + this.builders = t1; + }, + loadClient_closure: function loadClient_closure(t0, t1) { + this.loader = t0; + this.builder = t1; + }, + loadClient__closure: function loadClient__closure(t0) { + this.builder = t0; + }, + RootDomRenderObject$(container, nodes) { + var t2, + t1 = new A.RootDomRenderObject(container, A._setArrayType([], type$.JSArray_JSObject)); + t1.node = container; + t2 = nodes == null ? A.NodeListIterable_toIterable(container.childNodes) : nodes; + t2 = A.List_List$of(t2, true, type$.JSObject); + t1.toHydrate = t2; + t2 = A.IterableExtensions_get_firstOrNull(t2); + t1.__RootDomRenderObject_beforeStart_F = t2 == null ? null : t2.previousSibling; + return t1; + }, + RootDomRenderObject_RootDomRenderObject$between(start, end) { + var t1, + nodes = A._setArrayType([], type$.JSArray_JSObject), + curr = start.nextSibling; + while (true) { + if (!(curr != null && curr !== end)) + break; + nodes.push(curr); + curr = curr.nextSibling; + } + t1 = start.parentElement; + t1.toString; + return A.RootDomRenderObject$(t1, nodes); + }, + EventBinding$(element, type, fn) { + var t1 = new A.EventBinding(type, fn); + t1.EventBinding$3(element, type, fn); + return t1; + }, + AttributeOperation_clearOrSetAttribute(_this, $name, value) { + if (value == null) { + if (!_this.hasAttribute($name)) + return; + _this.removeAttribute($name); + } else { + if (J.$eq$(_this.getAttribute($name), value)) + return; + _this.setAttribute($name, value); + } + }, + DomRenderObject: function DomRenderObject(t0) { + var _ = this; + _.node = null; + _.toHydrate = t0; + _.parent = _.events = null; + }, + DomRenderObject_clearEvents_closure: function DomRenderObject_clearEvents_closure() { + }, + DomRenderObject_updateElement_closure: function DomRenderObject_updateElement_closure() { + }, + DomRenderObject_updateElement_closure0: function DomRenderObject_updateElement_closure0(t0, t1, t2) { + this.prevEventTypes = t0; + this.dataEvents = t1; + this.elem = t2; + }, + DomRenderObject_updateElement_closure1: function DomRenderObject_updateElement_closure1(t0) { + this.dataEvents = t0; + }, + RootDomRenderObject: function RootDomRenderObject(t0, t1) { + var _ = this; + _.container = t0; + _.__RootDomRenderObject_beforeStart_F = $; + _.node = null; + _.toHydrate = t1; + _.parent = _.events = null; + }, + EventBinding: function EventBinding(t0, t1) { + this.type = t0; + this.fn = t1; + this.subscription = null; + }, + EventBinding_closure: function EventBinding_closure(t0) { + this.$this = t0; + }, + AppBinding: function AppBinding() { + }, + _AppBinding_Object_SchedulerBinding: function _AppBinding_Object_SchedulerBinding() { + }, + unescapeMarkerText(text) { + return A.stringReplaceAllFuncUnchecked(text, $.$get$_escapeRegex(), new A.unescapeMarkerText_closure(), null); + }, + unescapeMarkerText_closure: function unescapeMarkerText_closure() { + }, + SchedulerPhase: function SchedulerPhase(t0) { + this._name = t0; + }, + SchedulerBinding: function SchedulerBinding() { + }, + SchedulerBinding_scheduleBuild_closure: function SchedulerBinding_scheduleBuild_closure(t0, t1) { + this.$this = t0; + this.buildCallback = t1; + }, + _RootElement$(component) { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A._RootElement(null, false, t1, t2, component, B._ElementLifecycle_0); + }, + Element__sort(a, b) { + var t2, + t1 = a._depth; + t1.toString; + t2 = b._depth; + t2.toString; + if (t1 < t2) + return -1; + else if (t2 < t1) + return 1; + else { + t1 = b._dirty; + if (t1 && !a._dirty) + return -1; + else if (a._dirty && !t1) + return 1; + } + return 0; + }, + _InactiveElements__deactivateRecursively(element) { + element.deactivate$0(); + element.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + }, + ProxyElement$(component) { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.ProxyElement(t1, t2, component, B._ElementLifecycle_0); + }, + BuildOwner: function BuildOwner(t0, t1) { + var _ = this; + _._dirtyElements = t0; + _._isFirstBuild = _._scheduledBuild = false; + _._inactiveElements = t1; + _._dirtyElementsNeedsResorting = null; + }, + BuildOwner_performInitialBuild_closure: function BuildOwner_performInitialBuild_closure(t0, t1) { + this.$this = t0; + this.completeBuild = t1; + }, + ComponentsBinding: function ComponentsBinding() { + }, + _Root: function _Root(t0, t1, t2) { + this.child = t0; + this.children = t1; + this.key = t2; + }, + _RootElement: function _RootElement(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._children = null; + _._forgottenChildren = t2; + _._notificationTree = _._parent = null; + _._cachedHash = t3; + _._depth = null; + _._component = t4; + _._owner = _._binding = null; + _._lifecycleState = t5; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + Component: function Component() { + }, + _ElementLifecycle: function _ElementLifecycle(t0) { + this._name = t0; + }, + Element: function Element() { + }, + Element_updateChildren_replaceWithNullIfForgotten: function Element_updateChildren_replaceWithNullIfForgotten(t0) { + this.forgottenChildren = t0; + }, + Element_rebuild_closure: function Element_rebuild_closure(t0) { + this.$this = t0; + }, + Element_detachRenderObject_closure: function Element_detachRenderObject_closure() { + }, + Element__updateAncestorSiblingRecursively_closure: function Element__updateAncestorSiblingRecursively_closure() { + }, + _InactiveElements: function _InactiveElements(t0) { + this._framework$_elements = t0; + }, + _InactiveElements__unmount_closure: function _InactiveElements__unmount_closure(t0) { + this.$this = t0; + }, + ProxyComponent: function ProxyComponent() { + }, + ProxyElement: function ProxyElement(t0, t1, t2, t3) { + var _ = this; + _._children = null; + _._forgottenChildren = t0; + _._notificationTree = _._parent = null; + _._cachedHash = t1; + _._depth = null; + _._component = t2; + _._owner = _._binding = null; + _._lifecycleState = t3; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + RenderObject: function RenderObject() { + }, + ProxyRenderObjectElement: function ProxyRenderObjectElement() { + }, + RenderObjectElement: function RenderObjectElement() { + }, + _EventStreamSubscription$(_target, _eventType, onData, _useCapture) { + var result, + t1 = A._wrapZone(new A._EventStreamSubscription_closure(onData), type$.JSObject), + t2 = null; + if (t1 == null) + t1 = t2; + else { + if (typeof t1 == "function") + A.throwExpression(A.ArgumentError$("Attempting to rewrap a JS function.", null)); + result = function(_call, f) { + return function(arg1) { + return _call(f, arg1, arguments.length); + }; + }(A._callDartFunctionFast1, t1); + result[$.$get$DART_CLOSURE_PROPERTY_NAME()] = t1; + t1 = result; + } + if (t1 != null) + _target.addEventListener(_eventType, t1, false); + return new A._EventStreamSubscription(_target, _eventType, t1, false); + }, + _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; + }, + _EventStreamSubscription: function _EventStreamSubscription(t0, t1, t2, t3) { + var _ = this; + _._target = t0; + _._eventType = t1; + _._onData = t2; + _._useCapture = t3; + }, + _EventStreamSubscription_closure: function _EventStreamSubscription_closure(t0) { + this.onData = t0; + }, + __loadLibrary_prefix0() { + return A.loadDeferredLibrary("prefix0", ""); + }, + main() { + A.registerClients(A.LinkedHashMap_LinkedHashMap$_literal(["components/todomvc", A.loadClient(A.main_clients____loadLibrary_prefix0$closure(), new A.main_closure())], type$.String, type$.FutureOr_Component_Function_Map_String_dynamic_Function)); + }, + main_closure: function main_closure() { + }, + printString(string) { + if (typeof dartPrint == "function") { + dartPrint(string); + return; + } + if (typeof console == "object" && typeof console.log != "undefined") { + console.log(string); + return; + } + if (typeof print == "function") { + print(string); + return; + } + throw "Unable to print message: " + String(string); + }, + JSAnyUtilityExtension_instanceOfString(_this, constructorName) { + var parts, $constructor, t1, t2, _i, part; + if (constructorName.length === 0) + return false; + parts = constructorName.split("."); + $constructor = type$.JSObject._as(self); + for (t1 = parts.length, t2 = type$.nullable_JSObject, _i = 0; _i < t1; ++_i) { + part = parts[_i]; + $constructor = t2._as($constructor[part]); + if ($constructor == null) + return false; + } + return _this instanceof type$.JavaScriptFunction._as($constructor); + }, + _callDartFunctionFast1(callback, arg1, $length) { + if ($length >= 1) + return callback.call$1(arg1); + return callback.call$0(); + }, + NodeListIterable_toIterable(_this) { + return new A._SyncStarIterable(A.NodeListIterable_toIterable$body(_this), type$._SyncStarIterable_JSObject); + }, + NodeListIterable_toIterable$body($async$_this) { + return function() { + var _this = $async$_this; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], i, t1; + return function $async$NodeListIterable_toIterable($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + i = 0; + case 2: + // for condition + if (!(i < _this.length)) { + // goto after for + $async$goto = 4; + break; + } + t1 = _this.item(i); + t1.toString; + $async$goto = 5; + return $async$iterator._async$_current = t1, 1; + case 5: + // after yield + case 3: + // for update + ++i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + } + }, + B = {}, C = {}, D = {}; + var holders = [A, J, B, C, D]; + 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) + "'"; + }, + 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; + }, + get$runtimeType(receiver) { + return B.Type_JSObject_ttY; + }, + 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); + } + }; + 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 = { + cast$1$0(receiver, $R) { + return new A.CastList(receiver, A._arrayInstanceType(receiver)._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + add$1(receiver, value) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, 29); + receiver.push(value); + }, + remove$1(receiver, element) { + var i; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "remove", 1); + for (i = 0; i < receiver.length; ++i) + if (J.$eq$(receiver[i], element)) { + receiver.splice(i, 1); + return true; + } + return false; + }, + addAll$1(receiver, collection) { + var t1; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "addAll", 2); + for (t1 = collection.get$iterator(collection); t1.moveNext$0();) + receiver.push(t1.get$current()); + }, + clear$0(receiver) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "clear", "clear"); + receiver.length = 0; + }, + forEach$1(receiver, f) { + var i, + end = receiver.length; + for (i = 0; i < end; ++i) { + f.call$1(receiver[i]); + if (receiver.length !== end) + throw A.wrapException(A.ConcurrentModificationError$(receiver)); + } + }, + join$1(receiver, separator) { + var i, + list = A.List_List$filled(receiver.length, "", false, type$.String); + for (i = 0; i < receiver.length; ++i) + list[i] = A.S(receiver[i]); + return list.join(separator); + }, + elementAt$1(receiver, index) { + return receiver[index]; + }, + get$last(receiver) { + var t1 = receiver.length; + if (t1 > 0) + return receiver[t1 - 1]; + throw A.wrapException(A.IterableElementError_noElement()); + }, + sort$1(receiver, compare) { + var len, a, b, undefineds, i; + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, "sort"); + len = receiver.length; + if (len < 2) + return; + if (compare == null) + compare = J._interceptors_JSArray__compareAny$closure(); + if (len === 2) { + a = receiver[0]; + b = receiver[1]; + if (compare.call$2(a, b) > 0) { + receiver[0] = b; + receiver[1] = a; + } + return; + } + undefineds = 0; + if (A._arrayInstanceType(receiver)._precomputed1._is(null)) + for (i = 0; i < receiver.length; ++i) + if (receiver[i] === void 0) { + receiver[i] = null; + ++undefineds; + } + receiver.sort(A.convertDartClosureToJS(compare, 2)); + if (undefineds > 0) + this._replaceSomeNullsWithUndefined$1(receiver, undefineds); + }, + _replaceSomeNullsWithUndefined$1(receiver, count) { + var i0, + i = receiver.length; + for (; i0 = i - 1, i > 0; i = i0) + if (receiver[i0] === null) { + receiver[i0] = void 0; + --count; + if (count === 0) + break; + } + }, + get$isEmpty(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) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + if (!(index >= 0 && index < receiver.length)) + throw A.wrapException(A.diagnoseIndexError(receiver, index)); + receiver[index] = value; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(A._arrayInstanceType(receiver)); + }, + $isEfficientLengthIterable: 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) + throw A.wrapException(A.throwConcurrentModificationError(t1)); + t2 = _this._index; + if (t2 >= $length) { + _this._current = null; + return false; + } + _this._current = t1[t2]; + _this._index = t2 + 1; + return true; + } + }; + J.JSNumber.prototype = { + compareTo$1(receiver, b) { + var bIsNegative; + if (receiver < b) + return -1; + else if (receiver > b) + return 1; + else if (receiver === b) { + if (receiver === 0) { + bIsNegative = this.get$isNegative(b); + if (this.get$isNegative(receiver) === bIsNegative) + return 0; + if (this.get$isNegative(receiver)) + return -1; + return 1; + } + return 0; + } else if (isNaN(receiver)) { + if (isNaN(b)) + return 0; + return 1; + } else + return -1; + }, + get$isNegative(receiver) { + return receiver === 0 ? 1 / receiver < 0 : receiver < 0; + }, + 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; + }, + _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 + }; + 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 = { + 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); + }, + compareTo$1(receiver, other) { + var t1; + if (receiver === other) + t1 = 0; + else + t1 = receiver < other ? -1 : 1; + return t1; + }, + 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, + $isString: 1 + }; + A._CastIterableBase.prototype = { + get$iterator(_) { + return new A.CastIterator(J.get$iterator$ax(this.get$_source()), A._instanceType(this)._eval$1("CastIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.get$_source()); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.get$_source()); + }, + elementAt$1(_, index) { + return A._instanceType(this)._rest[1]._as(J.elementAt$1$ax(this.get$_source(), index)); + }, + toString$0(_) { + return J.toString$0$(this.get$_source()); + } + }; + A.CastIterator.prototype = { + moveNext$0() { + return this._source.moveNext$0(); + }, + get$current() { + return this.$ti._rest[1]._as(this._source.get$current()); + } + }; + A._CastListBase.prototype = { + $index(_, index) { + return this.$ti._rest[1]._as(J.$index$asx(this._source, index)); + }, + $indexSet(_, index, value) { + J.$indexSet$ax(this._source, index, this.$ti._precomputed1._as(value)); + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.CastList.prototype = { + cast$1$0(_, $R) { + return new A.CastList(this._source, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + get$_source() { + return this._source; + } + }; + A.LateError.prototype = { + toString$0(_) { + return "LateInitializationError: " + this._message; + } + }; + A.SentinelValue.prototype = {}; + 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")); + }, + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + join$1(_, separator) { + var first, t1, i, _this = this, + $length = _this.get$length(_this); + if (separator.length !== 0) { + if ($length === 0) + return ""; + first = A.S(_this.elementAt$1(0, 0)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + for (t1 = first, i = 1; i < $length; ++i) { + t1 = t1 + separator + A.S(_this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } else { + for (i = 0, t1 = ""; i < $length; ++i) { + t1 += A.S(_this.elementAt$1(0, i)); + if ($length !== _this.get$length(_this)) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }, + map$1$1(_, toElement, $T) { + return new A.MappedListIterable(this, toElement, A._instanceType(this)._eval$1("@")._bind$1($T)._eval$1("MappedListIterable<1,2>")); + } + }; + 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.__internal$_current = null; + return false; + } + _this.__internal$_current = t2.elementAt$1(t1, t3); + ++_this.__internal$_index; + return true; + } + }; + A.MappedIterable.prototype = { + get$iterator(_) { + return new A.MappedIterator(J.get$iterator$ax(this.__internal$_iterable), this._f, A._instanceType(this)._eval$1("MappedIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.__internal$_iterable); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.__internal$_iterable); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this.__internal$_iterable, index)); + } + }; + A.EfficientLengthMappedIterable.prototype = {$isEfficientLengthIterable: 1}; + A.MappedIterator.prototype = { + moveNext$0() { + var _this = this, + t1 = _this._iterator; + if (t1.moveNext$0()) { + _this.__internal$_current = _this._f.call$1(t1.get$current()); + return true; + } + _this.__internal$_current = null; + return false; + }, + get$current() { + var t1 = this.__internal$_current; + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + } + }; + A.MappedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this._source, index)); + } + }; + A.WhereIterable.prototype = { + get$iterator(_) { + return new A.WhereIterator(J.get$iterator$ax(this.__internal$_iterable), this._f); + } + }; + A.WhereIterator.prototype = { + moveNext$0() { + var t1, t2; + for (t1 = this._iterator, t2 = this._f; t1.moveNext$0();) + if (t2.call$1(t1.get$current())) + return true; + return false; + }, + get$current() { + return this._iterator.get$current(); + } + }; + A.FixedLengthListMixin.prototype = {}; + A.ReversedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + var t1 = this._source, + t2 = J.getInterceptor$asx(t1); + return t2.elementAt$1(t1, t2.get$length(t1) - 1 - index); + } + }; + A.__CastListBase__CastIterableBase_ListMixin.prototype = {}; + A._Record_2.prototype = {$recipe: "+(1,2)", $shape: 1}; + A._Record_2_isActive_todo.prototype = {$recipe: "+isActive,todo(1,2)", $shape: 2}; + A._Record_3.prototype = {$recipe: "+(1,2,3)", $shape: 3}; + A.ConstantMap.prototype = { + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(this) !== 0; + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + get$entries() { + return new A._SyncStarIterable(this.entries$body$ConstantMap(), A._instanceType(this)._eval$1("_SyncStarIterable>")); + }, + entries$body$ConstantMap() { + var $async$self = this; + return function() { + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, key; + return function $async$get$entries($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.get$keys(), t1 = t1.get$iterator(t1), t2 = A._instanceType($async$self)._eval$1("MapEntry<1,2>"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + key = t1.get$current(); + $async$goto = 4; + return $async$iterator._async$_current = new A.MapEntry(key, $async$self.$index(0, key), t2), 1; + case 4: + // after yield + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + $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; + }, + containsKey$1(key) { + if (typeof key != "string") + return false; + if ("__proto__" === key) + return false; + return this._jsIndex.hasOwnProperty(key); + }, + $index(_, key) { + if (!this.containsKey$1(key)) + return null; + return this._values[this._jsIndex[key]]; + }, + forEach$1(_, f) { + var t1, i, + keys = this.get$_keys(), + values = this._values; + for (t1 = keys.length, i = 0; i < t1; ++i) + f.call$2(keys[i], values[i]); + }, + get$keys() { + return new A._KeysOrValues(this.get$_keys(), this.$ti._eval$1("_KeysOrValues<1>")); + } + }; + A._KeysOrValues.prototype = { + get$length(_) { + return this.__js_helper$_elements.length; + }, + get$isEmpty(_) { + return 0 === this.__js_helper$_elements.length; + }, + get$iterator(_) { + var t1 = this.__js_helper$_elements; + return new A._KeysOrValuesOrElementsIterator(t1, t1.length, this.$ti._eval$1("_KeysOrValuesOrElementsIterator<1>")); + } + }; + A._KeysOrValuesOrElementsIterator.prototype = { + get$current() { + var t1 = this.__js_helper$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + t1 = _this.__js_helper$_index; + if (t1 >= _this.__js_helper$_length) { + _this.__js_helper$_current = null; + return false; + } + _this.__js_helper$_current = _this.__js_helper$_elements[t1]; + _this.__js_helper$_index = t1 + 1; + return true; + } + }; + 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) + "'"; + }, + get$runtimeType(_) { + var rti = A.closureFunctionType(this); + return A.createRuntimeType(rti == null ? A.instanceType(this) : rti); + }, + 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.DeferredNotLoadedError.prototype = { + toString$0(_) { + return "Deferred library " + this.libraryName + " was not loaded."; + } + }; + A.loadDeferredLibrary_initializeSomeLoadedHunks.prototype = { + call$0() { + var t1, i, t2, t3, t4, t5, t6, t7, t8, uri, hash, _this = this; + for (t1 = _this._box_0, i = t1.nextHunkToInitialize, t2 = _this.total, t3 = _this.loadId, t4 = _this.initializer, t5 = _this.isHunkLoaded, t6 = _this.isHunkInitialized, t7 = _this.uris, t8 = _this.hashes; i < t2; ++i) { + if (t1.waitingForLoad[i]) + return; + ++t1.nextHunkToInitialize; + uri = t7[i]; + hash = t8[i]; + if (t6(hash)) { + A._addEvent("alreadyInitialized", hash, t3, uri); + continue; + } + if (t5(hash)) { + A._addEvent("initialize", hash, t3, uri); + t4(hash); + } else { + A._addEvent("missing", hash, t3, uri); + throw A.wrapException(A.DeferredLoadException$("Loading " + t7[i] + " failed: the code with hash '" + hash + "' was not loaded.\nevent log:\n" + A._getEventLog() + "\n")); + } + } + }, + $signature: 0 + }; + A.loadDeferredLibrary_finalizeLoad.prototype = { + call$0() { + this.initializeSomeLoadedHunks.call$0(); + $._loadedLibraries.add$1(0, this.loadId); + }, + $signature: 0 + }; + A.loadDeferredLibrary_closure.prototype = { + call$1(__wc0_formal) { + this._box_0.waitingForLoad = A.List_List$filled(this.total, false, false, type$.bool); + this.finalizeLoad.call$0(); + }, + $signature: 1 + }; + A.loadDeferredLibrary_loadAndInitialize.prototype = { + call$1(i) { + var _this = this, + hash = _this.hashes[i]; + if (_this.isHunkLoaded(hash)) { + _this._box_0.waitingForLoad[i] = false; + return A.Future_Future$value(null, type$.dynamic); + } + return A._loadHunk(_this.uris[i], _this.loadId, _this.priority, hash, 0).then$1$1(new A.loadDeferredLibrary_loadAndInitialize_closure(_this._box_0, i, _this.initializeSomeLoadedHunks), type$.dynamic); + }, + $signature: 13 + }; + A.loadDeferredLibrary_loadAndInitialize_closure.prototype = { + call$1(__wc1_formal) { + this._box_0.waitingForLoad[this.i] = false; + this.initializeSomeLoadedHunks.call$0(); + }, + $signature: 27 + }; + A.loadDeferredLibrary_closure0.prototype = { + call$1(__wc2_formal) { + this.finalizeLoad.call$0(); + }, + $signature: 30 + }; + A._loadAllHunks_closure.prototype = { + call$1(hunkName) { + var t1 = this.completer; + $.$get$_loadingLibraries().$indexSet(0, hunkName, t1); + return t1; + }, + $signature: 6 + }; + A._loadAllHunks_failure.prototype = { + call$5(error, context, stackTrace, hunksToRetry, hashesToRetry) { + var i, t3, _this = this, + t1 = _this.retryCount, + t2 = _this.loadId; + if (t1 < 3) { + A._addEvent("retry" + t1, null, t2, B.JSArray_methods.join$1(hunksToRetry, ";")); + for (i = 0; i < hunksToRetry.length; ++i) + $.$get$_loadingLibraries().$indexSet(0, hunksToRetry[i], null); + t3 = _this.completer; + A._loadAllHunks(_this.loader, hunksToRetry, hashesToRetry, t2, _this.priority, t1 + 1).then$1$2$onError(new A._loadAllHunks_failure_closure(t3), t3.get$completeError(), type$.void); + } else { + t1 = _this.loadedHunksString; + A._addEvent("downloadFailure", null, t2, t1); + B.JSArray_methods.forEach$1(_this.hunksToLoad, new A._loadAllHunks_failure_closure0()); + if (stackTrace == null) + stackTrace = A.StackTrace_current(); + _this.completer.completeError$2(new A.DeferredLoadException("Loading " + t1 + " failed: " + A.S(error) + "\nContext: " + context + "\nevent log:\n" + A._getEventLog() + "\n"), stackTrace); + } + }, + $signature: 8 + }; + A._loadAllHunks_failure_closure.prototype = { + call$1(__wc0_formal) { + return this.completer.complete$1(null); + }, + $signature: 2 + }; + A._loadAllHunks_failure_closure0.prototype = { + call$1(hunkName) { + $.$get$_loadingLibraries().$indexSet(0, hunkName, null); + return null; + }, + $signature: 6 + }; + A._loadAllHunks_success.prototype = { + call$0() { + var t2, t3, i, _this = this, + t1 = type$.JSArray_String, + hunksToRetry = A._setArrayType([], t1), + hashesToRetry = A._setArrayType([], t1); + for (t1 = _this.hashesToLoad, t2 = _this.isHunkLoaded, t3 = _this.hunksToLoad, i = 0; i < t1.length; ++i) + if (!t2(t1[i])) { + hunksToRetry.push(t3[i]); + hashesToRetry.push(t1[i]); + } + if (hunksToRetry.length === 0) { + A._addEvent("downloadSuccess", null, _this.loadId, _this.loadedHunksString); + _this.completer.complete$1(null); + } else + _this.failure.call$5("Success callback invoked but parts " + B.JSArray_methods.join$1(hunksToRetry, ";") + " not loaded.", "", null, hunksToRetry, hashesToRetry); + }, + $signature: 0 + }; + A._loadAllHunks_closure0.prototype = { + call$1(error) { + this.failure.call$5(A.unwrapException(error), "js-failure-wrapper", A.getTraceFromException(error), this.hunksToLoad, this.hashesToLoad); + }, + $signature: 1 + }; + A._loadHunk_failure.prototype = { + call$3(error, context, stackTrace) { + var _this = this, + t1 = _this.retryCount, + t2 = _this.hunkName, + t3 = _this.loadId; + if (t1 < 3) { + A._addEvent("retry" + t1, null, t3, t2); + A._loadHunk(t2, t3, _this.priority, _this.hash, t1 + 1); + } else { + A._addEvent("downloadFailure", null, t3, t2); + $.$get$_loadingLibraries().$indexSet(0, t2, null); + if (stackTrace == null) + stackTrace = A.StackTrace_current(); + t1 = _this._box_0.completer; + t1.toString; + t1.completeError$2(new A.DeferredLoadException("Loading " + _this.uriAsString + " failed: " + A.S(error) + "\nContext: " + context + "\nevent log:\n" + A._getEventLog() + "\n"), stackTrace); + } + }, + $signature: 36 + }; + A._loadHunk_success.prototype = { + call$0() { + var _this = this, + t1 = _this.hunkName; + if (init.isHunkLoaded(_this.hash)) { + A._addEvent("downloadSuccess", null, _this.loadId, t1); + _this._box_0.completer.complete$1(null); + } else + _this.failure.call$3("Success callback invoked but part " + t1 + " not loaded.", "", null); + }, + $signature: 0 + }; + A._loadHunk_closure.prototype = { + call$1(error) { + this.failure.call$3(A.unwrapException(error), "js-failure-wrapper", A.getTraceFromException(error)); + }, + $signature: 1 + }; + A._loadHunk_closure0.prototype = { + call$1($event) { + var code, error, stackTrace, exception, _this = this, + t1 = _this.xhr, + $status = t1.status; + if ($status !== 200) + _this.failure.call$3("Request status: " + $status, "worker xhr", null); + code = t1.responseText; + try { + new Function(code)(); + _this.success.call$0(); + } catch (exception) { + error = A.unwrapException(exception); + stackTrace = A.getTraceFromException(exception); + _this.failure.call$3(error, "evaluating the code in worker xhr", stackTrace); + } + }, + $signature: 1 + }; + A._loadHunk_closure1.prototype = { + call$1(e) { + this.failure.call$3(e, "xhr error handler", null); + }, + $signature: 1 + }; + A._loadHunk_closure2.prototype = { + call$1(e) { + this.failure.call$3(e, "xhr abort handler", null); + }, + $signature: 1 + }; + A.JsLinkedHashMap.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this.__js_helper$_length !== 0; + }, + get$keys() { + return new A.LinkedHashMapKeysIterable(this, A._instanceType(this)._eval$1("LinkedHashMapKeysIterable<1>")); + }, + get$entries() { + return new A.LinkedHashMapEntriesIterable(this, A._instanceType(this)._eval$1("LinkedHashMapEntriesIterable<1,2>")); + }, + containsKey$1(key) { + var strings, nums; + if (typeof key == "string") { + strings = this._strings; + if (strings == null) + return false; + return strings[key] != null; + } else if (typeof key == "number" && (key & 0x3fffffff) === key) { + nums = this._nums; + if (nums == null) + return false; + return nums[key] != null; + } else + return this.internalContainsKey$1(key); + }, + internalContainsKey$1(key) { + var rest = this.__js_helper$_rest; + if (rest == null) + return false; + return this.internalFindBucketIndex$2(rest[this.internalComputeHashCode$1(key)], key) >= 0; + }, + addAll$1(_, other) { + other.forEach$1(0, new A.JsLinkedHashMap_addAll_closure(this)); + }, + $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, _this = this; + 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 + _this.internalSet$2(key, value); + }, + internalSet$2(key, value) { + var hash, bucket, index, _this = this, + 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)); + } + }, + remove$1(_, key) { + var _this = this; + if (typeof key == "string") + return _this.__js_helper$_removeHashTableEntry$2(_this._strings, key); + else if (typeof key == "number" && (key & 0x3fffffff) === key) + return _this.__js_helper$_removeHashTableEntry$2(_this._nums, key); + else + return _this.internalRemove$1(key); + }, + internalRemove$1(key) { + var hash, bucket, index, cell, _this = this, + rest = _this.__js_helper$_rest; + if (rest == null) + return null; + hash = _this.internalComputeHashCode$1(key); + bucket = rest[hash]; + index = _this.internalFindBucketIndex$2(bucket, key); + if (index < 0) + return null; + cell = bucket.splice(index, 1)[0]; + _this.__js_helper$_unlinkCell$1(cell); + if (bucket.length === 0) + delete rest[hash]; + return cell.hashMapCellValue; + }, + forEach$1(_, action) { + var _this = this, + 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 = table[key]; + if (cell == null) + table[key] = this._newLinkedCell$2(key, value); + else + cell.hashMapCellValue = value; + }, + __js_helper$_removeHashTableEntry$2(table, key) { + var cell; + if (table == null) + return null; + cell = table[key]; + if (cell == null) + return null; + this.__js_helper$_unlinkCell$1(cell); + delete table[key]; + return cell.hashMapCellValue; + }, + _modified$0() { + this._modifications = this._modifications + 1 & 1073741823; + }, + _newLinkedCell$2(key, value) { + var t1, _this = this, + cell = new A.LinkedHashMapCell(key, value); + if (_this._first == null) + _this._first = _this._last = cell; + else { + t1 = _this._last; + t1.toString; + cell._previous = t1; + _this._last = t1._next = cell; + } + ++_this.__js_helper$_length; + _this._modified$0(); + return cell; + }, + __js_helper$_unlinkCell$1(cell) { + var _this = this, + previous = cell._previous, + next = cell._next; + if (previous == null) + _this._first = next; + else + previous._next = next; + if (next == null) + _this._last = previous; + else + next._previous = previous; + --_this.__js_helper$_length; + _this._modified$0(); + }, + 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[""] = table; + delete table[""]; + return table; + } + }; + A.JsLinkedHashMap_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(1,2)"); + } + }; + A.LinkedHashMapCell.prototype = {}; + A.LinkedHashMapKeysIterable.prototype = { + get$length(_) { + return this._map.__js_helper$_length; + }, + get$isEmpty(_) { + return this._map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this._map; + return new A.LinkedHashMapKeyIterator(t1, t1._modifications, t1._first); + } + }; + 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.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = cell.hashMapCellKey; + _this._cell = cell._next; + return true; + } + } + }; + A.LinkedHashMapEntriesIterable.prototype = { + get$length(_) { + return this._map.__js_helper$_length; + }, + get$isEmpty(_) { + return this._map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this._map; + return new A.LinkedHashMapEntryIterator(t1, t1._modifications, t1._first, this.$ti._eval$1("LinkedHashMapEntryIterator<1,2>")); + } + }; + A.LinkedHashMapEntryIterator.prototype = { + get$current() { + var t1 = this.__js_helper$_current; + t1.toString; + return t1; + }, + 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.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = new A.MapEntry(cell.hashMapCellKey, cell.hashMapCellValue, _this.$ti._eval$1("MapEntry<1,2>")); + _this._cell = cell._next; + return true; + } + } + }; + A.initHooks_closure.prototype = { + call$1(o) { + return this.getTag(o); + }, + $signature: 9 + }; + A.initHooks_closure0.prototype = { + call$2(o, tag) { + return this.getUnknownTag(o, tag); + }, + $signature: 10 + }; + A.initHooks_closure1.prototype = { + call$1(tag) { + return this.prototypeForTag(tag); + }, + $signature: 11 + }; + A._Record.prototype = { + get$runtimeType(_) { + return A.createRuntimeType(this._getRti$0()); + }, + _getRti$0() { + return A.evaluateRtiForRecord(this.$recipe, this._getFieldValues$0()); + }, + toString$0(_) { + return this._toString$1(false); + }, + _toString$1(safe) { + var t2, separator, i, key, value, + keys = this._fieldKeys$0(), + values = this._getFieldValues$0(), + t1 = (safe ? "" + "Record " : "") + "("; + for (t2 = keys.length, separator = "", i = 0; i < t2; ++i, separator = ", ") { + t1 += separator; + key = keys[i]; + if (typeof key == "string") + t1 = t1 + key + ": "; + value = values[i]; + t1 = safe ? t1 + A.Primitives_safeToString(value) : t1 + A.S(value); + } + t1 += ")"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _fieldKeys$0() { + var t1, + shapeTag = this.$shape; + for (; $._Record__computedFieldKeys.length <= shapeTag;) + $._Record__computedFieldKeys.push(null); + t1 = $._Record__computedFieldKeys[shapeTag]; + if (t1 == null) { + t1 = this._computeFieldKeys$0(); + $._Record__computedFieldKeys[shapeTag] = t1; + } + return t1; + }, + _computeFieldKeys$0() { + var i, names, last, + recipe = this.$recipe, + position = recipe.indexOf("("), + joinedNames = recipe.substring(1, position), + fields = recipe.substring(position), + arity = fields === "()" ? 0 : fields.replace(/[^,]/g, "").length + 1, + result = A._setArrayType(new Array(arity), type$.JSArray_Object); + for (i = 0; i < arity; ++i) + result[i] = i; + if (joinedNames !== "") { + names = joinedNames.split(","); + i = names.length; + for (last = arity; i > 0;) { + --last; + --i; + result[last] = names[i]; + } + } + result = A.List_List$from(result, false, type$.Object); + result.$flags = 3; + return result; + } + }; + A._Record2.prototype = { + _getFieldValues$0() { + return [this._0, this._1]; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._Record2 && this.$shape === other.$shape && J.$eq$(this._0, other._0) && J.$eq$(this._1, other._1); + }, + get$hashCode(_) { + return A.Object_hash(this.$shape, this._0, this._1, B.C_SentinelValue); + } + }; + A._Record3.prototype = { + _getFieldValues$0() { + return [this._0, this._1, this._2]; + }, + $eq(_, other) { + var _this = this; + if (other == null) + return false; + return other instanceof A._Record3 && _this.$shape === other.$shape && J.$eq$(_this._0, other._0) && J.$eq$(_this._1, other._1) && J.$eq$(_this._2, other._2); + }, + get$hashCode(_) { + var _this = this; + return A.Object_hash(_this.$shape, _this._0, _this._1, _this._2); + } + }; + A.JSSyntaxRegExp.prototype = { + toString$0(_) { + return "RegExp/" + this.pattern + "/" + this._nativeRegExp.flags; + }, + get$_nativeGlobalVersion() { + var _this = this, + t1 = _this._nativeGlobalRegExp; + if (t1 != null) + return t1; + t1 = _this._nativeRegExp; + return _this._nativeGlobalRegExp = A.JSSyntaxRegExp_makeNative(_this.pattern, t1.multiline, !t1.ignoreCase, t1.unicode, t1.dotAll, true); + }, + firstMatch$1(string) { + var m = this._nativeRegExp.exec(string); + if (m == null) + return null; + return new A._MatchImplementation(m); + }, + _execGlobal$2(string, start) { + var match, + regexp = this.get$_nativeGlobalVersion(); + regexp.lastIndex = start; + match = regexp.exec(string); + if (match == null) + return null; + return new A._MatchImplementation(match); + } + }; + A._MatchImplementation.prototype = { + get$end() { + var t1 = this._match; + return t1.index + t1[0].length; + }, + group$1(index) { + return this._match[index]; + }, + $isMatch: 1, + $isRegExpMatch: 1 + }; + A._AllMatchesIterator.prototype = { + get$current() { + var t1 = this.__js_helper$_current; + return t1 == null ? type$.RegExpMatch._as(t1) : t1; + }, + moveNext$0() { + var t1, t2, t3, match, nextIndex, t4, _this = this, + string = _this._string; + if (string == null) + return false; + t1 = _this._nextIndex; + t2 = string.length; + if (t1 <= t2) { + t3 = _this._regExp; + match = t3._execGlobal$2(string, t1); + if (match != null) { + _this.__js_helper$_current = match; + nextIndex = match.get$end(); + if (match._match.index === nextIndex) { + t1 = false; + if (t3._nativeRegExp.unicode) { + t3 = _this._nextIndex; + t4 = t3 + 1; + if (t4 < t2) { + t2 = string.charCodeAt(t3); + if (t2 >= 55296 && t2 <= 56319) { + t1 = string.charCodeAt(t4); + t1 = t1 >= 56320 && t1 <= 57343; + } + } + } + nextIndex = (t1 ? nextIndex + 1 : nextIndex) + 1; + } + _this._nextIndex = nextIndex; + return true; + } + } + _this._string = _this.__js_helper$_current = null; + return false; + } + }; + A._Cell.prototype = { + _readLocal$0() { + var t1 = this._value; + if (t1 === this) + throw A.wrapException(new A.LateError("Local '' has not been initialized.")); + return t1; + } + }; + A.NativeByteBuffer.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteBuffer_rqD; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeTypedData.prototype = {}; + A.NativeByteData.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteData_9dB; + }, + $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]; + }, + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.NativeTypedArrayOfInt.prototype = { + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.NativeFloat32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float32List_9Kz; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeFloat64List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float64List_9Kz; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int16List_s5h; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int32List_O8Z; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt8List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int8List_rFV; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint16List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint32List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint8ClampedList.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint8ClampedList_04U; + }, + 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_8Eb; + }, + 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); + }, + $isType: 1 + }; + A._Error.prototype = { + toString$0(_) { + return this.__rti$_message; + } + }; + A._TypeError.prototype = {$isTypeError: 1}; + A._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = { + call$1(__wc0_formal) { + var t1 = this._box_0, + f = t1.storedCallback; + t1.storedCallback = null; + f.call$0(); + }, + $signature: 1 + }; + A._AsyncRun__initializeScheduleImmediate_closure.prototype = { + call$1(callback) { + var t1, t2; + this._box_0.storedCallback = callback; + t1 = this.div; + t2 = this.span; + t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2); + }, + $signature: 12 + }; + A._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 7 + }; + A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 7 + }; + A._TimerImpl.prototype = { + _TimerImpl$2(milliseconds, callback) { + if (self.setTimeout != null) + self.setTimeout(A.convertDartClosureToJS(new A._TimerImpl_internalCallback(this, callback), 0), milliseconds); + else + throw A.wrapException(A.UnsupportedError$("`setTimeout()` not found.")); + } + }; + A._TimerImpl_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 0 + }; + A._AsyncAwaitCompleter.prototype = { + complete$1(value) { + var t1, _this = this; + if (value == null) + value = _this.$ti._precomputed1._as(value); + if (!_this.isSync) + _this._future._asyncComplete$1(value); + else { + t1 = _this._future; + if (_this.$ti._eval$1("Future<1>")._is(value)) + t1._chainFuture$1(value); + else + t1._completeWithValue$1(value); + } + }, + completeError$2(e, st) { + var t1 = this._future; + if (this.isSync) + t1._completeErrorObject$1(new A.AsyncError(e, st)); + else + t1._asyncCompleteErrorObject$1(new A.AsyncError(e, st)); + } + }; + A._awaitOnObject_closure.prototype = { + call$1(result) { + return this.bodyFunction.call$2(0, result); + }, + $signature: 2 + }; + A._awaitOnObject_closure0.prototype = { + call$2(error, stackTrace) { + this.bodyFunction.call$2(1, new A.ExceptionAndStackTrace(error, stackTrace)); + }, + $signature: 14 + }; + A._wrapJsFunctionForAsync_closure.prototype = { + call$2(errorCode, result) { + this.$protected(errorCode, result); + }, + $signature: 15 + }; + A._SyncStarIterator.prototype = { + get$current() { + return this._async$_current; + }, + _resumeBody$2(errorCode, errorValue) { + var body, t1, exception; + errorCode = errorCode; + errorValue = errorValue; + body = this._body; + for (; true;) + try { + t1 = body(this, errorCode, errorValue); + return t1; + } catch (exception) { + errorValue = exception; + errorCode = 1; + } + }, + moveNext$0() { + var nestedIterator, exception, value, suspendedBodies, _this = this, errorValue = null, errorCode = 0; + for (; true;) { + nestedIterator = _this._nestedIterator; + if (nestedIterator != null) + try { + if (nestedIterator.moveNext$0()) { + _this._async$_current = nestedIterator.get$current(); + return true; + } else + _this._nestedIterator = null; + } catch (exception) { + errorValue = exception; + errorCode = 1; + _this._nestedIterator = null; + } + value = _this._resumeBody$2(errorCode, errorValue); + if (1 === value) + return true; + if (0 === value) { + _this._async$_current = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._body = A._SyncStarIterator__terminatedBody; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 0; + errorValue = null; + continue; + } + if (2 === value) { + errorCode = 0; + errorValue = null; + continue; + } + if (3 === value) { + errorValue = _this._datum; + _this._datum = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._async$_current = null; + _this._body = A._SyncStarIterator__terminatedBody; + throw errorValue; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 1; + continue; + } + throw A.wrapException(A.StateError$("sync*")); + } + return false; + }, + _yieldStar$1(iterable) { + var t1, t2, _this = this; + if (iterable instanceof A._SyncStarIterable) { + t1 = iterable._outerHelper(); + t2 = _this._suspendedBodies; + if (t2 == null) + t2 = _this._suspendedBodies = []; + t2.push(_this._body); + _this._body = t1; + return 2; + } else { + _this._nestedIterator = J.get$iterator$ax(iterable); + return 2; + } + } + }; + A._SyncStarIterable.prototype = { + get$iterator(_) { + return new A._SyncStarIterator(this._outerHelper()); + } + }; + A.AsyncError.prototype = { + toString$0(_) { + return A.S(this.error); + }, + $isError: 1, + get$stackTrace() { + return this.stackTrace; + } + }; + A.DeferredLoadException.prototype = { + toString$0(_) { + return "DeferredLoadException: '" + this._async$_message + "'"; + } + }; + A.Future_wait_handleError.prototype = { + call$2(theError, theStackTrace) { + var _this = this, + t1 = _this._box_0, + t2 = --t1.remaining; + if (t1.values != null) { + t1.values = null; + t1.error = theError; + t1.stackTrace = theStackTrace; + if (t2 === 0 || _this.eagerError) + _this._future._completeErrorObject$1(new A.AsyncError(theError, theStackTrace)); + } else if (t2 === 0 && !_this.eagerError) { + t2 = t1.error; + t2.toString; + t1 = t1.stackTrace; + t1.toString; + _this._future._completeErrorObject$1(new A.AsyncError(t2, t1)); + } + }, + $signature: 16 + }; + A.Future_wait_closure.prototype = { + call$1(value) { + var t1, value0, t3, t4, _i, t5, _this = this, + t2 = _this._box_0, + remainingResults = --t2.remaining, + valueList = t2.values; + if (valueList != null) { + J.$indexSet$ax(valueList, _this.pos, value); + if (J.$eq$(remainingResults, 0)) { + t2 = _this.T; + t1 = A._setArrayType([], t2._eval$1("JSArray<0>")); + for (t3 = valueList, t4 = t3.length, _i = 0; _i < t3.length; t3.length === t4 || (0, A.throwConcurrentModificationError)(t3), ++_i) { + value0 = t3[_i]; + t5 = value0; + if (t5 == null) + t5 = t2._as(t5); + J.add$1$ax(t1, t5); + } + _this._future._completeWithValue$1(t1); + } + } else if (J.$eq$(remainingResults, 0) && !_this.eagerError) { + t1 = t2.error; + t1.toString; + t2 = t2.stackTrace; + t2.toString; + _this._future._completeErrorObject$1(new A.AsyncError(t1, t2)); + } + }, + $signature() { + return this.T._eval$1("Null(0)"); + } + }; + A._Completer.prototype = { + completeError$2(error, stackTrace) { + var t1 = this.future; + if ((t1._state & 30) !== 0) + throw A.wrapException(A.StateError$("Future already completed")); + t1._asyncCompleteErrorObject$1(A._interceptUserError(error, stackTrace)); + }, + completeError$1(error) { + return this.completeError$2(error, null); + } + }; + A._AsyncCompleter.prototype = { + complete$1(value) { + var t1 = this.future; + if ((t1._state & 30) !== 0) + throw A.wrapException(A.StateError$("Future already completed")); + t1._asyncComplete$1(value); + } + }; + A._FutureListener.prototype = { + matchesErrorTest$1(asyncError) { + if ((this.state & 15) !== 6) + return true; + return this.result._zone.runUnary$2(this.callback, asyncError.error); + }, + handleError$1(asyncError) { + var exception, + errorCallback = this.errorCallback, + result = null, + t1 = asyncError.error, + t2 = this.result._zone; + if (type$.dynamic_Function_Object_StackTrace._is(errorCallback)) + result = t2.runBinary$3(errorCallback, t1, asyncError.stackTrace); + else + result = t2.runUnary$2(errorCallback, t1); + try { + t1 = 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 = { + then$1$2$onError(f, onError, $R) { + var result, t1, + 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 if (onError != null) + onError = A._registerErrorHandler(onError, currentZone); + result = new A._Future(currentZone, $R._eval$1("_Future<0>")); + t1 = onError == null ? 1 : 3; + this._addListener$1(new A._FutureListener(result, t1, f, onError, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>"))); + return result; + }, + then$1$1(f, $R) { + f.toString; + return this.then$1$2$onError(f, null, $R); + }, + _thenAwait$1$2(f, onError, $E) { + var result = new A._Future($.Zone__current, $E._eval$1("_Future<0>")); + this._addListener$1(new A._FutureListener(result, 19, f, onError, this.$ti._eval$1("@<1>")._bind$1($E)._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 _this = this, + t1 = _this._state; + if (t1 <= 3) { + listener._nextListener = _this._resultOrListeners; + _this._resultOrListeners = listener; + } else { + if ((t1 & 4) !== 0) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._addListener$1(listener); + return; + } + _this._cloneResult$1(t1); + } + A._rootScheduleMicrotask(null, null, _this._zone, new A._Future__addListener_closure(_this, listener)); + } + }, + _prependListeners$1(listeners) { + var t1, existingListeners, next, cursor, next0, _this = this, _box_0 = {}; + _box_0.listeners = listeners; + if (listeners == null) + return; + t1 = _this._state; + if (t1 <= 3) { + existingListeners = _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) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._prependListeners$1(listeners); + return; + } + _this._cloneResult$1(t1); + } + _box_0.listeners = _this._reverseListeners$1(listeners); + A._rootScheduleMicrotask(null, null, _this._zone, new A._Future__prependListeners_closure(_box_0, _this)); + } + }, + _removeListeners$0() { + var current = 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; + }, + _completeWithValue$1(value) { + var _this = this, + listeners = _this._removeListeners$0(); + _this._state = 8; + _this._resultOrListeners = value; + A._Future__propagateToListeners(_this, listeners); + }, + _completeWithResultOf$1(source) { + var t1, listeners, _this = this; + if ((source._state & 16) !== 0) { + t1 = _this._zone === source._zone; + t1 = !(t1 || t1); + } else + t1 = false; + if (t1) + return; + listeners = _this._removeListeners$0(); + _this._cloneResult$1(source); + A._Future__propagateToListeners(_this, listeners); + }, + _completeErrorObject$1(error) { + var listeners = this._removeListeners$0(); + this._setErrorObject$1(error); + A._Future__propagateToListeners(this, listeners); + }, + _asyncComplete$1(value) { + if (this.$ti._eval$1("Future<1>")._is(value)) { + this._chainFuture$1(value); + return; + } + this._asyncCompleteWithValue$1(value); + }, + _asyncCompleteWithValue$1(value) { + this._state ^= 2; + A._rootScheduleMicrotask(null, null, this._zone, new A._Future__asyncCompleteWithValue_closure(this, value)); + }, + _chainFuture$1(value) { + A._Future__chainCoreFuture(value, this, false); + return; + }, + _asyncCompleteErrorObject$1(error) { + this._state ^= 2; + A._rootScheduleMicrotask(null, null, this._zone, new A._Future__asyncCompleteErrorObject_closure(this, error)); + }, + $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__chainCoreFuture_closure.prototype = { + call$0() { + A._Future__chainCoreFuture(this._box_0.source, this.target, true); + }, + $signature: 0 + }; + A._Future__asyncCompleteWithValue_closure.prototype = { + call$0() { + this.$this._completeWithValue$1(this.value); + }, + $signature: 0 + }; + A._Future__asyncCompleteErrorObject_closure.prototype = { + call$0() { + this.$this._completeErrorObject$1(this.error); + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback.prototype = { + call$0() { + var e, s, t1, exception, t2, t3, originalSource, joinedResult, _this = this, completeResult = null; + try { + t1 = _this._box_0.listener; + completeResult = t1.result._zone.run$1(t1.callback); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + if (_this.hasError && _this._box_1.source._resultOrListeners.error === e) { + t1 = _this._box_0; + t1.listenerValueOrError = _this._box_1.source._resultOrListeners; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + return; + } + if (completeResult instanceof A._Future && (completeResult._state & 24) !== 0) { + if ((completeResult._state & 16) !== 0) { + t1 = _this._box_0; + t1.listenerValueOrError = completeResult._resultOrListeners; + t1.listenerHasError = true; + } + return; + } + if (completeResult instanceof A._Future) { + originalSource = _this._box_1.source; + joinedResult = new A._Future(originalSource._zone, originalSource.$ti); + completeResult.then$1$2$onError(new A._Future__propagateToListeners_handleWhenCompleteCallback_closure(joinedResult, originalSource), new A._Future__propagateToListeners_handleWhenCompleteCallback_closure0(joinedResult), type$.void); + t1 = _this._box_0; + t1.listenerValueOrError = joinedResult; + t1.listenerHasError = false; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = { + call$1(__wc0_formal) { + this.joinedResult._completeWithResultOf$1(this.originalSource); + }, + $signature: 1 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure0.prototype = { + call$2(e, s) { + this.joinedResult._completeErrorObject$1(new A.AsyncError(e, s)); + }, + $signature: 18 + }; + A._Future__propagateToListeners_handleValueCallback.prototype = { + call$0() { + var e, s, t1, t2, exception, t3; + try { + t1 = this._box_0; + t2 = t1.listener; + t1.listenerValueOrError = t2.result._zone.runUnary$2(t2.callback, this.sourceResult); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t3.listenerHasError = true; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleError.prototype = { + call$0() { + var asyncError, e, s, t1, exception, t2, t3, _this = this; + try { + asyncError = _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 = _this._box_1.source._resultOrListeners; + if (t1.error === e) { + t2 = _this._box_0; + t2.listenerValueOrError = t1; + t1 = t2; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + } + }, + $signature: 0 + }; + A._AsyncCallbackEntry.prototype = {}; + A._StreamIterator.prototype = {}; + A._Zone.prototype = {}; + 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; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$0(); + return; + } + A._rootRun(null, null, this, f); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runUnaryGuarded$1$2(f, arg) { + var e, s, exception; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$1(arg); + return; + } + A._rootRunUnary(null, null, this, f, arg); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runUnaryGuarded$2(f, arg) { + f.toString; + return this.runUnaryGuarded$1$2(f, arg, type$.dynamic); + }, + bindCallbackGuarded$1(f) { + return new A._RootZone_bindCallbackGuarded_closure(this, f); + }, + bindUnaryCallbackGuarded$1$1(f, $T) { + return new A._RootZone_bindUnaryCallbackGuarded_closure(this, f, $T); + }, + run$1$1(f) { + if ($.Zone__current === B.C__RootZone) + return f.call$0(); + return A._rootRun(null, null, this, f); + }, + run$1(f) { + f.toString; + return this.run$1$1(f, type$.dynamic); + }, + runUnary$2$2(f, arg) { + if ($.Zone__current === B.C__RootZone) + return f.call$1(arg); + return A._rootRunUnary(null, null, this, f, arg); + }, + runUnary$2(f, arg) { + var t1 = type$.dynamic; + f.toString; + return this.runUnary$2$2(f, arg, t1, t1); + }, + runBinary$3$3(f, arg1, arg2) { + if ($.Zone__current === B.C__RootZone) + return f.call$2(arg1, arg2); + return A._rootRunBinary(null, null, this, f, arg1, arg2); + }, + runBinary$3(f, arg1, arg2) { + var t1 = type$.dynamic; + f.toString; + return this.runBinary$3$3(f, arg1, arg2, t1, t1, t1); + }, + registerBinaryCallback$3$1(f) { + return f; + }, + registerBinaryCallback$1(f) { + var t1 = type$.dynamic; + f.toString; + return this.registerBinaryCallback$3$1(f, t1, t1, t1); + } + }; + A._RootZone_bindCallbackGuarded_closure.prototype = { + call$0() { + return this.$this.runGuarded$1(this.f); + }, + $signature: 0 + }; + A._RootZone_bindUnaryCallbackGuarded_closure.prototype = { + call$1(arg) { + return this.$this.runUnaryGuarded$2(this.f, arg); + }, + $signature() { + return this.T._eval$1("~(0)"); + } + }; + A._HashSet.prototype = { + get$iterator(_) { + return new A._HashSetIterator(this, this._computeElements$0(), A._instanceType(this)._eval$1("_HashSetIterator<1>")); + }, + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + contains$1(_, object) { + var strings, nums; + if (typeof object == "string" && object !== "__proto__") { + strings = this._collection$_strings; + return strings == null ? false : strings[object] != null; + } else if (typeof object == "number" && (object & 1073741823) === object) { + nums = this._collection$_nums; + return nums == null ? false : nums[object] != null; + } else + return this._contains$1(object); + }, + _contains$1(object) { + var rest = this._collection$_rest; + if (rest == null) + return false; + return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; + }, + add$1(_, element) { + var strings, nums, _this = this; + if (typeof element == "string" && element !== "__proto__") { + strings = _this._collection$_strings; + return _this._collection$_addHashTableEntry$2(strings == null ? _this._collection$_strings = A._HashSet__newHashTable() : strings, element); + } else if (typeof element == "number" && (element & 1073741823) === element) { + nums = _this._collection$_nums; + return _this._collection$_addHashTableEntry$2(nums == null ? _this._collection$_nums = A._HashSet__newHashTable() : nums, element); + } else + return _this._add$1(element); + }, + _add$1(element) { + var hash, bucket, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._HashSet__newHashTable(); + hash = _this._computeHashCode$1(element); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [element]; + else { + if (_this._findBucketIndex$2(bucket, element) >= 0) + return false; + bucket.push(element); + } + ++_this._collection$_length; + _this._elements = null; + return true; + }, + remove$1(_, object) { + var _this = this; + if (typeof object == "string" && object !== "__proto__") + return _this._removeHashTableEntry$2(_this._collection$_strings, object); + else if (typeof object == "number" && (object & 1073741823) === object) + return _this._removeHashTableEntry$2(_this._collection$_nums, object); + else + return _this._remove$1(object); + }, + _remove$1(object) { + var hash, bucket, index, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return false; + hash = _this._computeHashCode$1(object); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, object); + if (index < 0) + return false; + --_this._collection$_length; + _this._elements = null; + bucket.splice(index, 1); + if (0 === bucket.length) + delete rest[hash]; + return true; + }, + clear$0(_) { + var _this = this; + if (_this._collection$_length > 0) { + _this._collection$_strings = _this._collection$_nums = _this._collection$_rest = _this._elements = null; + _this._collection$_length = 0; + } + }, + _computeElements$0() { + var strings, index, names, entries, i, nums, rest, bucket, $length, i0, _this = this, + result = _this._elements; + if (result != null) + return result; + result = A.List_List$filled(_this._collection$_length, null, false, type$.dynamic); + strings = _this._collection$_strings; + index = 0; + if (strings != null) { + names = Object.getOwnPropertyNames(strings); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = names[i]; + ++index; + } + } + 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) { + result[index] = bucket[i0]; + ++index; + } + } + } + return _this._elements = result; + }, + _collection$_addHashTableEntry$2(table, element) { + if (table[element] != null) + return false; + table[element] = 0; + ++this._collection$_length; + this._elements = null; + return true; + }, + _removeHashTableEntry$2(table, element) { + if (table != null && table[element] != null) { + delete table[element]; + --this._collection$_length; + this._elements = null; + return true; + } else + return false; + }, + _computeHashCode$1(element) { + return J.get$hashCode$(element) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i], element)) + return i; + return -1; + } + }; + A._HashSetIterator.prototype = { + get$current() { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + elements = _this._elements, + offset = _this._offset, + t1 = _this._set; + if (elements !== t1._elements) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (offset >= elements.length) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = elements[offset]; + _this._offset = offset + 1; + return true; + } + } + }; + A._LinkedHashSet.prototype = { + get$iterator(_) { + var _this = this, + t1 = new A._LinkedHashSetIterator(_this, _this._collection$_modifications, A._instanceType(_this)._eval$1("_LinkedHashSetIterator<1>")); + t1._collection$_cell = _this._collection$_first; + return t1; + }, + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + contains$1(_, object) { + var strings, t1; + if (object !== "__proto__") { + strings = this._collection$_strings; + if (strings == null) + return false; + return strings[object] != null; + } else { + t1 = this._contains$1(object); + return t1; + } + }, + _contains$1(object) { + var rest = this._collection$_rest; + if (rest == null) + return false; + return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; + }, + forEach$1(_, action) { + var _this = this, + cell = _this._collection$_first, + modifications = _this._collection$_modifications; + for (; cell != null;) { + action.call$1(cell._element); + if (modifications !== _this._collection$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + cell = cell._collection$_next; + } + }, + add$1(_, element) { + var strings, nums, _this = this; + if (typeof element == "string" && element !== "__proto__") { + strings = _this._collection$_strings; + return _this._collection$_addHashTableEntry$2(strings == null ? _this._collection$_strings = A._LinkedHashSet__newHashTable() : strings, element); + } else if (typeof element == "number" && (element & 1073741823) === element) { + nums = _this._collection$_nums; + return _this._collection$_addHashTableEntry$2(nums == null ? _this._collection$_nums = A._LinkedHashSet__newHashTable() : nums, element); + } else + return _this._add$1(element); + }, + _add$1(element) { + var hash, bucket, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._LinkedHashSet__newHashTable(); + hash = _this._computeHashCode$1(element); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [_this._collection$_newLinkedCell$1(element)]; + else { + if (_this._findBucketIndex$2(bucket, element) >= 0) + return false; + bucket.push(_this._collection$_newLinkedCell$1(element)); + } + return true; + }, + remove$1(_, object) { + var _this = this; + if (typeof object == "string" && object !== "__proto__") + return _this._removeHashTableEntry$2(_this._collection$_strings, object); + else if (typeof object == "number" && (object & 1073741823) === object) + return _this._removeHashTableEntry$2(_this._collection$_nums, object); + else + return _this._remove$1(object); + }, + _remove$1(object) { + var hash, bucket, index, cell, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return false; + hash = _this._computeHashCode$1(object); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, object); + if (index < 0) + return false; + cell = bucket.splice(index, 1)[0]; + if (0 === bucket.length) + delete rest[hash]; + _this._unlinkCell$1(cell); + return true; + }, + _collection$_addHashTableEntry$2(table, element) { + if (table[element] != null) + return false; + table[element] = this._collection$_newLinkedCell$1(element); + return true; + }, + _removeHashTableEntry$2(table, element) { + var cell; + if (table == null) + return false; + cell = table[element]; + if (cell == null) + return false; + this._unlinkCell$1(cell); + delete table[element]; + return true; + }, + _collection$_modified$0() { + this._collection$_modifications = this._collection$_modifications + 1 & 1073741823; + }, + _collection$_newLinkedCell$1(element) { + var t1, _this = this, + cell = new A._LinkedHashSetCell(element); + if (_this._collection$_first == null) + _this._collection$_first = _this._collection$_last = cell; + else { + t1 = _this._collection$_last; + t1.toString; + cell._collection$_previous = t1; + _this._collection$_last = t1._collection$_next = cell; + } + ++_this._collection$_length; + _this._collection$_modified$0(); + return cell; + }, + _unlinkCell$1(cell) { + var _this = this, + previous = cell._collection$_previous, + next = cell._collection$_next; + if (previous == null) + _this._collection$_first = next; + else + previous._collection$_next = next; + if (next == null) + _this._collection$_last = previous; + else + next._collection$_previous = previous; + --_this._collection$_length; + _this._collection$_modified$0(); + }, + _computeHashCode$1(element) { + return J.get$hashCode$(element) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i]._element, element)) + return i; + return -1; + } + }; + A._LinkedHashSetCell.prototype = {}; + A._LinkedHashSetIterator.prototype = { + get$current() { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + cell = _this._collection$_cell, + t1 = _this._set; + if (_this._collection$_modifications !== t1._collection$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (cell == null) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = cell._element; + _this._collection$_cell = cell._collection$_next; + return true; + } + } + }; + A.ListBase.prototype = { + get$iterator(receiver) { + return new A.ListIterator(receiver, this.get$length(receiver), A.instanceType(receiver)._eval$1("ListIterator")); + }, + elementAt$1(receiver, index) { + return this.$index(receiver, index); + }, + get$isEmpty(receiver) { + return this.get$length(receiver) === 0; + }, + toString$0(receiver) { + return A.Iterable_iterableToFullString(receiver, "[", "]"); + } + }; + A.MapBase.prototype = { + forEach$1(_, action) { + var t1, t2, key, t3; + for (t1 = this.get$keys(), t1 = t1.get$iterator(t1), t2 = A._instanceType(this)._eval$1("MapBase.V"); t1.moveNext$0();) { + key = t1.get$current(); + t3 = this.$index(0, key); + action.call$2(key, t3 == null ? t2._as(t3) : t3); + } + }, + get$entries() { + return this.get$keys().map$1$1(0, new A.MapBase_entries_closure(this), A._instanceType(this)._eval$1("MapEntry")); + }, + removeWhere$1(_, test) { + var t2, key, t3, _i, _this = this, + t1 = A._instanceType(_this), + keysToRemove = A._setArrayType([], t1._eval$1("JSArray")); + 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); + if (test.call$2(key, t3 == null ? t1._as(t3) : t3)) + keysToRemove.push(key); + } + for (t1 = keysToRemove.length, _i = 0; _i < keysToRemove.length; keysToRemove.length === t1 || (0, A.throwConcurrentModificationError)(keysToRemove), ++_i) + _this.remove$1(0, keysToRemove[_i]); + }, + get$length(_) { + var t1 = this.get$keys(); + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this.get$keys(); + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this.get$keys(); + return t1.get$isNotEmpty(t1); + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + $isMap: 1 + }; + A.MapBase_entries_closure.prototype = { + call$1(key) { + var t1 = this.$this, + t2 = t1.$index(0, key); + if (t2 == null) + t2 = A._instanceType(t1)._eval$1("MapBase.V")._as(t2); + return new A.MapEntry(key, t2, A._instanceType(t1)._eval$1("MapEntry")); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("MapEntry(MapBase.K)"); + } + }; + 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); + t1._contents = (t1._contents += t2) + ": "; + t2 = A.S(v); + t1._contents += t2; + }, + $signature: 19 + }; + A.SetBase.prototype = { + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + addAll$1(_, elements) { + var t1; + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + this.add$1(0, t1.get$current()); + }, + removeAll$1(elements) { + var t1, _i; + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + this.remove$1(0, elements[_i]); + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + 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, "index")); + }, + $isEfficientLengthIterable: 1 + }; + A._SetBase.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._computeKeys$0().length; + }, + get$isEmpty(_) { + return this.get$length(0) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(0) > 0; + }, + get$keys() { + if (this._processed == null) { + var t1 = this._data; + return new A.LinkedHashMapKeysIterable(t1, A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>")); + } + return new A._JsonMapKeyIterable(this); + }, + containsKey$1(key) { + if (this._processed == null) + return this._data.containsKey$1(key); + if (typeof key != "string") + return false; + return Object.prototype.hasOwnProperty.call(this._original, key); + }, + remove$1(_, key) { + if (this._processed != null && !this.containsKey$1(key)) + return null; + return this._upgrade$0().remove$1(0, key); + }, + forEach$1(_, f) { + var keys, i, key, value, _this = this; + if (_this._processed == null) + return _this._data.forEach$1(0, f); + keys = _this._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)); + } + }, + _computeKeys$0() { + var keys = this._data; + if (keys == null) + keys = this._data = A._setArrayType(Object.keys(this._original), type$.JSArray_String); + return keys; + }, + _upgrade$0() { + var result, keys, i, t1, key, _this = this; + if (_this._processed == null) + return _this._data; + result = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.dynamic); + keys = _this._computeKeys$0(); + for (i = 0; t1 = keys.length, i < t1; ++i) { + key = keys[i]; + result.$indexSet(0, key, _this.$index(0, key)); + } + if (t1 === 0) + keys.push(""); + else + B.JSArray_methods.clear$0(keys); + _this._original = _this._processed = null; + return _this._data = result; + }, + _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._convert$_parent.get$length(0); + }, + elementAt$1(_, index) { + var t1 = this._convert$_parent; + return t1._processed == null ? t1.get$keys().elementAt$1(0, index) : t1._computeKeys$0()[index]; + }, + get$iterator(_) { + var t1 = this._convert$_parent; + if (t1._processed == null) { + t1 = t1.get$keys(); + t1 = t1.get$iterator(t1); + } else { + t1 = t1._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.JsonCodec.prototype = { + decode$2$reviver(source, reviver) { + var t1 = A._parseJson(source, this.get$decoder()._reviver); + return t1; + }, + get$decoder() { + return B.JsonDecoder_null; + } + }; + A.JsonDecoder.prototype = {}; + A._Enum.prototype = { + toString$0(_) { + return this._enumToString$0(); + } + }; + A.Error.prototype = { + get$stackTrace() { + return A.Primitives_extractStackTrace(this); + } + }; + 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 ? "" : ": " + 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 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 this.invalidValue; + }, + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + if (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.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.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 message = this.message, + report = "" !== message ? "FormatException: " + message : "FormatException", + source = this.source; + if (typeof source == "string") { + if (source.length > 78) + source = B.JSString_methods.substring$2(source, 0, 75) + "..."; + return report + "\n" + source; + } else + return report; + } + }; + A.Iterable.prototype = { + map$1$1(_, toElement, $T) { + return A.MappedIterable_MappedIterable(this, toElement, A._instanceType(this)._eval$1("Iterable.E"), $T); + }, + join$1(_, separator) { + var first, t1, + iterator = this.get$iterator(this); + if (!iterator.moveNext$0()) + return ""; + first = J.toString$0$(iterator.get$current()); + if (!iterator.moveNext$0()) + return first; + if (separator.length === 0) { + t1 = first; + do + t1 += J.toString$0$(iterator.get$current()); + while (iterator.moveNext$0()); + } else { + t1 = first; + do + t1 = t1 + separator + J.toString$0$(iterator.get$current()); + while (iterator.moveNext$0()); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$length(_) { + var count, + it = this.get$iterator(this); + for (count = 0; it.moveNext$0();) + ++count; + return count; + }, + get$isEmpty(_) { + return !this.get$iterator(this).moveNext$0(); + }, + get$isNotEmpty(_) { + return !this.get$isEmpty(this); + }, + 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, "index")); + }, + toString$0(_) { + return A.Iterable_iterableToShortString(this, "(", ")"); + } + }; + A.MapEntry.prototype = { + toString$0(_) { + return "MapEntry(" + A.S(this.key) + ": " + A.S(this.value) + ")"; + } + }; + 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) + "'"; + }, + get$runtimeType(_) { + return A.getRuntimeTypeOfDartObject(this); + }, + toString() { + return this.toString$0(this); + } + }; + A._StringStackTrace.prototype = { + toString$0(_) { + return ""; + }, + $isStackTrace: 1 + }; + A.StringBuffer.prototype = { + get$length(_) { + return this._contents.length; + }, + toString$0(_) { + var t1 = this._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.BrowserAppBinding.prototype = { + createRootRenderObject$0() { + var t2, + t1 = this.__BrowserAppBinding_attachBetween_A; + t1 === $ && A.throwUnnamedLateFieldNI(); + if (type$.Record_2_nullable_Object_and_nullable_Object._is(t1)) + return A.RootDomRenderObject_RootDomRenderObject$between(t1._0, t1._1); + else { + t1 = self.document; + t2 = this.__BrowserAppBinding_attachTarget_A; + t2 === $ && A.throwUnnamedLateFieldNI(); + t2 = t1.querySelector(t2); + t2.toString; + return A.RootDomRenderObject$(t2, null); + } + } + }; + A._BrowserAppBinding_AppBinding_ComponentsBinding.prototype = {}; + A.registerClients_closure.prototype = { + call$1($name) { + var t3, + t1 = this.builders, + t2 = t1.$index(0, $name); + if (t2 == null) + t2 = this.clients.$index(0, $name).call$0(); + type$.FutureOr_Component_Function_Map_String_dynamic._as(t2); + t3 = type$.Component_Function_Map_String_dynamic; + if (t3._is(t2)) { + t1.$indexSet(0, $name, t2); + return t2; + } else + return t2.then$1$1(new A.registerClients__closure($name, t1), t3); + }, + $signature: 20 + }; + A.registerClients__closure.prototype = { + call$1(b) { + this.builders.$indexSet(0, this.name, b); + return b; + }, + $signature: 21 + }; + A.loadClient_closure.prototype = { + call$0() { + return this.loader.call$0().then$1$1(new A.loadClient__closure(this.builder), type$.Component_Function_Map_String_dynamic); + }, + $signature: 22 + }; + A.loadClient__closure.prototype = { + call$1(_) { + return this.builder; + }, + $signature: 23 + }; + A.DomRenderObject.prototype = { + clearEvents$0() { + var t1 = this.events; + if (t1 != null) + t1.forEach$1(0, new A.DomRenderObject_clearEvents_closure()); + this.events = null; + }, + _createElement$2(tag, namespace) { + if (namespace != null && namespace !== "http://www.w3.org/1999/xhtml") + return self.document.createElementNS(namespace, tag); + return self.document.createElement(tag); + }, + updateElement$6(tag, id, classes, styles, attributes, events) { + var t1, t2, _i, e, i, old, t3, t4, t5, t6, prevEventTypes, dataEvents, _this = this, _null = null, + _s7_ = "Element", + attributesToRemove = A._Cell$(), + elem = A._Cell$(), + namespace = B.Map_rvfri.$index(0, tag); + if (namespace == null) { + t1 = _this.parent; + if (t1 == null) + t1 = _null; + else { + t1 = t1.node; + t1 = t1 == null ? _null : A.JSAnyUtilityExtension_instanceOfString(t1, _s7_); + } + t1 = t1 === true; + } else + t1 = false; + if (t1) { + t1 = _this.parent; + t1 = t1 == null ? _null : t1.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + namespace = t1.namespaceURI; + } + $label0$0: { + t1 = _this.node; + if (t1 == null) { + t1 = _this.parent.toHydrate; + t2 = t1.length; + if (t2 !== 0) + for (_i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + e = t1[_i]; + if (A.JSAnyUtilityExtension_instanceOfString(e, _s7_) && e.tagName.toLowerCase() === tag) { + elem._value = _this.node = e; + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + i = 0; + while (true) { + t1 = elem._value; + if (t1 === elem) + A.throwExpression(A.LateError$localNI("")); + if (!(i < t1.attributes.length)) + break; + t2 = attributesToRemove._value; + if (t2 === attributesToRemove) + A.throwExpression(A.LateError$localNI("")); + J.add$1$ax(t2, t1.attributes.item(i).name); + ++i; + } + B.JSArray_methods.remove$1(_this.parent.toHydrate, e); + t1 = A.NodeListIterable_toIterable(e.childNodes); + _this.toHydrate = A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + break $label0$0; + } + } + elem._value = _this.node = _this._createElement$2(tag, namespace); + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + } else { + if (A.JSAnyUtilityExtension_instanceOfString(t1, _s7_)) { + t1 = _this.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + t1 = t1.tagName.toLowerCase() !== tag; + } else + t1 = true; + if (t1) { + elem._value = _this._createElement$2(tag, namespace); + old = _this.node; + t1 = old.parentNode; + t1.toString; + t1.replaceChild(elem._readLocal$0(), old); + _this.node = elem._readLocal$0(); + if (old.childNodes.length > 0) + for (t1 = new A._SyncStarIterator(A.NodeListIterable_toIterable(old.childNodes)._outerHelper()); t1.moveNext$0();) { + t2 = t1._async$_current; + t3 = elem._value; + if (t3 === elem) + A.throwExpression(A.LateError$localNI("")); + t3.append(t2); + } + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + } else { + t1 = _this.node; + elem._value = t1 == null ? type$.JSObject._as(t1) : t1; + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + i = 0; + while (true) { + t1 = elem._value; + if (t1 === elem) + A.throwExpression(A.LateError$localNI("")); + if (!(i < t1.attributes.length)) + break; + t2 = attributesToRemove._value; + if (t2 === attributesToRemove) + A.throwExpression(A.LateError$localNI("")); + J.add$1$ax(t2, t1.attributes.item(i).name); + ++i; + } + } + } + } + A.AttributeOperation_clearOrSetAttribute(elem._readLocal$0(), "id", id); + t1 = elem._readLocal$0(); + A.AttributeOperation_clearOrSetAttribute(t1, "class", classes == null || classes.length === 0 ? _null : classes); + t1 = elem._readLocal$0(); + A.AttributeOperation_clearOrSetAttribute(t1, "style", styles == null || styles.get$isEmpty(styles) ? _null : styles.get$entries().map$1$1(0, new A.DomRenderObject_updateElement_closure(), type$.String).join$1(0, "; ")); + t1 = attributes == null; + if (!t1 && attributes.get$isNotEmpty(attributes)) + for (t2 = attributes.get$entries(), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(); + t4 = t3.key; + t5 = false; + if (J.$eq$(t4, "value")) { + t6 = elem._value; + if (t6 === elem) + A.throwExpression(A.LateError$localNI("")); + if (A.JSAnyUtilityExtension_instanceOfString(t6, "HTMLInputElement")) { + t5 = elem._value; + if (t5 === elem) + A.throwExpression(A.LateError$localNI("")); + t5 = !J.$eq$(t5.value, t3.value); + } + } + if (t5) { + t4 = elem._value; + if (t4 === elem) + A.throwExpression(A.LateError$localNI("")); + t4.value = t3.value; + continue; + } + t5 = elem._value; + if (t5 === elem) + A.throwExpression(A.LateError$localNI("")); + A.AttributeOperation_clearOrSetAttribute(t5, t4, t3.value); + } + t2 = attributesToRemove._readLocal$0(); + t3 = ["id", "class", "style"]; + t1 = t1 ? _null : attributes.get$keys(); + if (t1 != null) + B.JSArray_methods.addAll$1(t3, t1); + t2.removeAll$1(t3); + if (attributesToRemove._readLocal$0()._collection$_length !== 0) + for (t1 = attributesToRemove._readLocal$0(), t1 = A._LinkedHashSetIterator$(t1, t1._collection$_modifications, A._instanceType(t1)._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + t4 = elem._value; + if (t4 === elem) + A.throwExpression(A.LateError$localNI("")); + t4.removeAttribute(t3); + } + if (events != null && events.get$isNotEmpty(events)) { + t1 = _this.events; + if (t1 == null) + prevEventTypes = _null; + else { + t2 = A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>"); + prevEventTypes = A.LinkedHashSet_LinkedHashSet(t2._eval$1("Iterable.E")); + prevEventTypes.addAll$1(0, new A.LinkedHashMapKeysIterable(t1, t2)); + } + dataEvents = _this.events; + if (dataEvents == null) + dataEvents = _this.events = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.EventBinding); + events.forEach$1(0, new A.DomRenderObject_updateElement_closure0(prevEventTypes, dataEvents, elem)); + if (prevEventTypes != null) + prevEventTypes.forEach$1(0, new A.DomRenderObject_updateElement_closure1(dataEvents)); + } else + _this.clearEvents$0(); + }, + updateText$1(text) { + var t1, toHydrate, _i, e, elem, node, _this = this; + $label0$0: { + t1 = _this.node; + if (t1 == null) { + toHydrate = _this.parent.toHydrate; + t1 = toHydrate.length; + if (t1 !== 0) + for (_i = 0; _i < toHydrate.length; toHydrate.length === t1 || (0, A.throwConcurrentModificationError)(toHydrate), ++_i) { + e = toHydrate[_i]; + if (A.JSAnyUtilityExtension_instanceOfString(e, "Text")) { + _this.node = e; + if (!J.$eq$(e.textContent, text)) + e.textContent = text; + B.JSArray_methods.remove$1(toHydrate, e); + break $label0$0; + } + } + _this.node = new self.Text(text); + } else if (!A.JSAnyUtilityExtension_instanceOfString(t1, "Text")) { + elem = new self.Text(text); + t1 = _this.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + t1.replaceWith(elem); + _this.node = elem; + } else { + node = _this.node; + if (node == null) + node = type$.JSObject._as(node); + if (!J.$eq$(node.textContent, text)) + node.textContent = text; + } + } + }, + attach$2$after(child, after) { + var parentNode, childNode, afterNode, t1; + try { + child.parent = this; + parentNode = this.node; + childNode = child.node; + if (childNode == null) + return; + afterNode = after == null ? null : after.node; + if (J.$eq$(childNode.previousSibling, afterNode) && J.$eq$(childNode.parentNode, parentNode)) + return; + if (afterNode == null) { + t1 = parentNode; + t1.toString; + t1.insertBefore(childNode, parentNode.childNodes.item(0)); + } else + parentNode.insertBefore(childNode, afterNode.nextSibling); + } finally { + child.finalize$0(); + } + }, + finalize$0() { + var t1, t2, _i, node; + for (t1 = this.toHydrate, t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + node = t1[_i]; + node.parentNode.removeChild(node); + } + B.JSArray_methods.clear$0(this.toHydrate); + } + }; + A.DomRenderObject_clearEvents_closure.prototype = { + call$2(type, binding) { + binding.clear$0(0); + }, + $signature: 24 + }; + A.DomRenderObject_updateElement_closure.prototype = { + call$1(e) { + return A.S(e.key) + ": " + A.S(e.value); + }, + $signature: 38 + }; + A.DomRenderObject_updateElement_closure0.prototype = { + call$2(type, fn) { + var currentBinding, + t1 = this.prevEventTypes; + if (t1 != null) + t1.remove$1(0, type); + t1 = this.dataEvents; + currentBinding = t1.$index(0, type); + if (currentBinding != null) + currentBinding.fn = fn; + else + t1.$indexSet(0, type, A.EventBinding$(this.elem._readLocal$0(), type, fn)); + }, + $signature: 26 + }; + A.DomRenderObject_updateElement_closure1.prototype = { + call$1(type) { + var t1 = this.dataEvents.remove$1(0, type); + if (t1 != null) + t1.clear$0(0); + }, + $signature: 6 + }; + A.RootDomRenderObject.prototype = { + attach$2$after(child, after) { + var t1, t2; + if ((after == null ? null : after.node) != null) + t1 = after; + else { + t1 = new A.DomRenderObject(A._setArrayType([], type$.JSArray_JSObject)); + t2 = this.__RootDomRenderObject_beforeStart_F; + t2 === $ && A.throwUnnamedLateFieldNI(); + t1.node = t2; + } + this.super$DomRenderObject$attach(child, t1); + } + }; + A.EventBinding.prototype = { + EventBinding$3(element, type, fn) { + this.subscription = A._EventStreamSubscription$(element, this.type, new A.EventBinding_closure(this), false); + }, + clear$0(_) { + var t1 = this.subscription; + if (t1 != null) + t1.cancel$0(); + this.subscription = null; + } + }; + A.EventBinding_closure.prototype = { + call$1($event) { + this.$this.fn.call$1($event); + }, + $signature: 3 + }; + A.AppBinding.prototype = {}; + A._AppBinding_Object_SchedulerBinding.prototype = {}; + A.unescapeMarkerText_closure.prototype = { + call$1(match) { + var t1, + _0_0 = match.group$1(1); + $label0$0: { + if ("amp" === _0_0) { + t1 = "&"; + break $label0$0; + } + if ("lt" === _0_0) { + t1 = "<"; + break $label0$0; + } + if ("gt" === _0_0) { + t1 = ">"; + break $label0$0; + } + t1 = match.group$1(0); + t1.toString; + break $label0$0; + } + return t1; + }, + $signature: 28 + }; + A.SchedulerPhase.prototype = { + _enumToString$0() { + return "SchedulerPhase." + this._name; + } + }; + A.SchedulerBinding.prototype = { + scheduleBuild$1(buildCallback) { + A.scheduleMicrotask(new A.SchedulerBinding_scheduleBuild_closure(this, buildCallback)); + }, + completeInitialFrame$0() { + this._flushPostFrameCallbacks$0(); + }, + _flushPostFrameCallbacks$0() { + var _i, + t1 = this.SchedulerBinding__postFrameCallbacks, + localPostFrameCallbacks = A.List_List$of(t1, true, type$.void_Function); + B.JSArray_methods.clear$0(t1); + for (t1 = localPostFrameCallbacks.length, _i = 0; _i < t1; ++_i) + localPostFrameCallbacks[_i].call$0(); + } + }; + A.SchedulerBinding_scheduleBuild_closure.prototype = { + call$0() { + var t1 = this.$this; + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_1; + this.buildCallback.call$0(); + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_2; + t1._flushPostFrameCallbacks$0(); + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_0; + return null; + }, + $signature: 0 + }; + A.BuildOwner.prototype = { + scheduleBuildFor$1(element) { + var _this = this; + if (element._inDirtyList) { + _this._dirtyElementsNeedsResorting = true; + return; + } + if (!_this._scheduledBuild) { + element._binding.scheduleBuild$1(_this.get$performBuild()); + _this._scheduledBuild = true; + } + _this._dirtyElements.push(element); + element._inDirtyList = true; + }, + lockState$1(callback) { + return this.lockState$body$BuildOwner(callback); + }, + lockState$body$BuildOwner(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$handler = 1, $async$errorStack = [], $async$next = [], res; + var $async$lockState$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 2; + res = callback.call$0(); + $async$goto = res instanceof A._Future ? 5 : 6; + break; + case 5: + // then + $async$goto = 7; + return A._asyncAwait(res, $async$lockState$1); + case 7: + // returning from await. + case 6: + // join + $async$next.push(4); + // goto finally + $async$goto = 3; + break; + case 2: + // uncaught + $async$next = [1]; + case 3: + // finally + $async$handler = 1; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 4: + // after finally + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$lockState$1, $async$completer); + }, + performInitialBuild$2(element, completeBuild) { + return this.performInitialBuild$body$BuildOwner(element, completeBuild); + }, + performInitialBuild$body$BuildOwner(element, completeBuild) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$performInitialBuild$2 = 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 + $async$self._isFirstBuild = true; + element.super$Element$mount(null, null); + element.didMount$0(); + new A.BuildOwner_performInitialBuild_closure($async$self, completeBuild).call$0(); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$performInitialBuild$2, $async$completer); + }, + performBuild$0() { + var dirtyCount, index, element, e, element0, t1, exception, t2, _i, _this = this; + try { + t1 = _this._dirtyElements; + B.JSArray_methods.sort$1(t1, A.framework_Element__sort$closure()); + _this._dirtyElementsNeedsResorting = false; + dirtyCount = t1.length; + index = 0; + for (; index < dirtyCount;) { + element = t1[index]; + try { + element.rebuild$0(); + element.toString; + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.S(e); + A.printString("Error on rebuilding component: " + t1); + throw exception; + } + ++index; + if (!(dirtyCount < t1.length)) { + t2 = _this._dirtyElementsNeedsResorting; + t2.toString; + } else + t2 = true; + if (t2) { + B.JSArray_methods.sort$1(t1, A.framework_Element__sort$closure()); + t2 = _this._dirtyElementsNeedsResorting = false; + dirtyCount = t1.length; + while (true) { + if (!(index > 0 ? t1[index - 1]._dirty : t2)) + break; + --index; + } + } + } + } finally { + for (t1 = _this._dirtyElements, t2 = t1.length, _i = 0; _i < t2; ++_i) { + element0 = t1[_i]; + element0._inDirtyList = false; + } + B.JSArray_methods.clear$0(t1); + _this._dirtyElementsNeedsResorting = null; + _this.lockState$1(_this._inactiveElements.get$_unmountAll()); + _this._scheduledBuild = false; + } + } + }; + A.BuildOwner_performInitialBuild_closure.prototype = { + call$0() { + this.$this._isFirstBuild = false; + this.completeBuild.call$0(); + }, + $signature: 0 + }; + A.ComponentsBinding.prototype = { + attachRootComponent$1(app) { + return this.attachRootComponent$body$ComponentsBinding(app); + }, + attachRootComponent$body$ComponentsBinding(app) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, element, t1, buildOwner; + var $async$attachRootComponent$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 = $async$self.ComponentsBinding__rootElement; + buildOwner = t1 == null ? null : t1._owner; + if (buildOwner == null) + buildOwner = new A.BuildOwner(A._setArrayType([], type$.JSArray_Element), new A._InactiveElements(A.HashSet_HashSet(type$.Element))); + element = A._RootElement$(new A._Root(app, null, null)); + element._binding = $async$self; + element._owner = buildOwner; + element.RenderObjectElement__renderObject = $async$self.createRootRenderObject$0(); + $async$self.ComponentsBinding__rootElement = element; + buildOwner.performInitialBuild$2(element, $async$self.get$completeInitialFrame()); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$attachRootComponent$1, $async$completer); + } + }; + A._Root.prototype = { + createElement$0() { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A._RootElement(null, false, t1, t2, this, B._ElementLifecycle_0); + } + }; + A._RootElement.prototype = { + updateRenderObject$0() { + } + }; + A.Component.prototype = {}; + A._ElementLifecycle.prototype = { + _enumToString$0() { + return "_ElementLifecycle." + this._name; + } + }; + A.Element.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this === other; + }, + get$hashCode(_) { + return this._cachedHash; + }, + get$component() { + var t1 = this._component; + t1.toString; + return t1; + }, + updateChild$3(child, newComponent, prevSibling) { + var t1, newChild, oldComponent, _this = this; + if (newComponent == null) { + if (child != null) { + if (J.$eq$(_this._lastChild, child)) + _this.updateLastChild$1(prevSibling); + _this.deactivateChild$1(child); + } + return null; + } + if (child != null) + if (child._component === newComponent) { + t1 = J.$eq$(child._prevSibling, prevSibling); + if (!t1) + child.updatePrevSibling$1(prevSibling); + newChild = child; + } else { + t1 = child.get$component(); + t1 = A.getRuntimeTypeOfDartObject(t1) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t1.key, newComponent.key); + if (t1) { + t1 = J.$eq$(child._prevSibling, prevSibling); + if (!t1) + child.updatePrevSibling$1(prevSibling); + oldComponent = child.get$component(); + child.update$1(newComponent); + child.didUpdate$1(oldComponent); + newChild = child; + } else { + _this.deactivateChild$1(child); + newChild = _this.inflateComponent$2(newComponent, prevSibling); + } + } + else + newChild = _this.inflateComponent$2(newComponent, prevSibling); + if (J.$eq$(_this._lastChild, prevSibling)) + _this.updateLastChild$1(newChild); + return newChild; + }, + updateChildren$3$forgottenChildren(oldChildren, newComponents, forgottenChildren) { + var newChild, newChildrenBottom, oldChildrenBottom, t2, t3, newChildren, prevChild, newChildrenTop, oldChildrenTop, oldChild, newComponent, t4, retakeOldKeyedChildren, newKeyedChildren, newChildrenTopPeek, key, oldChildrenTopPeek, t5, _this = this, _null = null, + replaceWithNullIfForgotten = new A.Element_updateChildren_replaceWithNullIfForgotten(forgottenChildren), + t1 = J.getInterceptor$asx(oldChildren); + if (t1.get$length(oldChildren) <= 1 && newComponents.length <= 1) { + newChild = _this.updateChild$3(replaceWithNullIfForgotten.call$1(A.IterableExtensions_get_firstOrNull(oldChildren)), A.IterableExtensions_get_firstOrNull(newComponents), _null); + t1 = A._setArrayType([], type$.JSArray_Element); + if (newChild != null) + t1.push(newChild); + return t1; + } + newChildrenBottom = newComponents.length - 1; + oldChildrenBottom = t1.get$length(oldChildren) - 1; + t2 = t1.get$length(oldChildren); + t3 = newComponents.length; + newChildren = t2 === t3 ? oldChildren : A.List_List$filled(t3, _null, true, type$.nullable_Element); + t2 = J.getInterceptor$ax(newChildren); + prevChild = _null; + newChildrenTop = 0; + oldChildrenTop = 0; + while (true) { + if (!(oldChildrenTop <= oldChildrenBottom && newChildrenTop <= newChildrenBottom)) + break; + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + newComponent = newComponents[newChildrenTop]; + if (oldChild != null) { + t3 = oldChild.get$component(); + t3 = !(A.getRuntimeTypeOfDartObject(t3) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t3.key, newComponent.key)); + } else + t3 = true; + if (t3) + break; + t3 = _this.updateChild$3(oldChild, newComponent, prevChild); + t3.toString; + t2.$indexSet(newChildren, newChildrenTop, t3); + ++newChildrenTop; + ++oldChildrenTop; + prevChild = t3; + } + while (true) { + t3 = oldChildrenTop <= oldChildrenBottom; + if (!(t3 && newChildrenTop <= newChildrenBottom)) + break; + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenBottom)); + newComponent = newComponents[newChildrenBottom]; + if (oldChild != null) { + t4 = oldChild.get$component(); + t4 = !(A.getRuntimeTypeOfDartObject(t4) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t4.key, newComponent.key)); + } else + t4 = true; + if (t4) + break; + --oldChildrenBottom; + --newChildrenBottom; + } + retakeOldKeyedChildren = _null; + if (newChildrenTop <= newChildrenBottom && t3) { + t3 = type$.Key; + newKeyedChildren = A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.Component); + for (newChildrenTopPeek = newChildrenTop; newChildrenTopPeek <= newChildrenBottom;) { + newComponent = newComponents[newChildrenTopPeek]; + key = newComponent.key; + if (key != null) + newKeyedChildren.$indexSet(0, key, newComponent); + ++newChildrenTopPeek; + } + if (newKeyedChildren.__js_helper$_length !== 0) { + retakeOldKeyedChildren = A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.Element); + for (oldChildrenTopPeek = oldChildrenTop; oldChildrenTopPeek <= oldChildrenBottom;) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTopPeek)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key != null) { + newComponent = newKeyedChildren.$index(0, key); + if (newComponent != null) { + t3 = oldChild.get$component(); + t3 = A.getRuntimeTypeOfDartObject(t3) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t3.key, newComponent.key); + } else + t3 = false; + if (t3) + retakeOldKeyedChildren.$indexSet(0, key, oldChild); + } + } + ++oldChildrenTopPeek; + } + } + } + for (t3 = retakeOldKeyedChildren == null, t4 = !t3; newChildrenTop <= newChildrenBottom; prevChild = t5) { + if (oldChildrenTop <= oldChildrenBottom) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key == null || !t4 || !retakeOldKeyedChildren.containsKey$1(key)) { + oldChild._prevAncestorSibling = oldChild._prevSibling = oldChild._parent = null; + t5 = _this._owner._inactiveElements; + if (oldChild._lifecycleState === B._ElementLifecycle_1) { + oldChild.detachRenderObject$0(); + oldChild.deactivate$0(); + oldChild.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t5._framework$_elements.add$1(0, oldChild); + } + } + ++oldChildrenTop; + } + newComponent = newComponents[newChildrenTop]; + key = newComponent.key; + if (key != null) + oldChild = t3 ? _null : retakeOldKeyedChildren.$index(0, key); + else + oldChild = _null; + t5 = _this.updateChild$3(oldChild, newComponent, prevChild); + t5.toString; + t2.$indexSet(newChildren, newChildrenTop, t5); + ++newChildrenTop; + } + for (; oldChildrenTop <= oldChildrenBottom;) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key == null || !t4 || !retakeOldKeyedChildren.containsKey$1(key)) { + oldChild._prevAncestorSibling = oldChild._prevSibling = oldChild._parent = null; + t3 = _this._owner._inactiveElements; + if (oldChild._lifecycleState === B._ElementLifecycle_1) { + oldChild.detachRenderObject$0(); + oldChild.deactivate$0(); + oldChild.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t3._framework$_elements.add$1(0, oldChild); + } + } + ++oldChildrenTop; + } + newChildrenBottom = newComponents.length - 1; + oldChildrenBottom = t1.get$length(oldChildren) - 1; + while (true) { + if (!(oldChildrenTop <= oldChildrenBottom && newChildrenTop <= newChildrenBottom)) + break; + t3 = _this.updateChild$3(t1.$index(oldChildren, oldChildrenTop), newComponents[newChildrenTop], prevChild); + t3.toString; + t2.$indexSet(newChildren, newChildrenTop, t3); + ++newChildrenTop; + ++oldChildrenTop; + prevChild = t3; + } + return t2.cast$1$0(newChildren, type$.Element); + }, + mount$2($parent, prevSibling) { + var t1, t2, _this = this; + _this._parent = $parent; + t1 = type$.RenderObjectElement._is($parent); + if (t1) + t2 = $parent; + else + t2 = $parent == null ? null : $parent._parentRenderObjectElement; + _this._parentRenderObjectElement = t2; + _this._prevSibling = prevSibling; + if (prevSibling == null) + if (t1) + t1 = null; + else + t1 = $parent == null ? null : $parent._prevAncestorSibling; + else + t1 = prevSibling; + _this._prevAncestorSibling = t1; + _this._lifecycleState = B._ElementLifecycle_1; + t1 = $parent != null; + if (t1) { + t2 = $parent._depth; + t2.toString; + ++t2; + } else + t2 = 1; + _this._depth = t2; + if (t1) { + t1 = $parent._owner; + t1.toString; + _this._owner = t1; + t1 = $parent._binding; + t1.toString; + _this._binding = t1; + } + _this.get$component(); + _this._updateInheritance$0(); + _this._updateObservers$0(); + _this.attachNotificationTree$0(); + }, + didMount$0() { + }, + update$1(newComponent) { + if (this.shouldRebuild$1(newComponent)) + this._dirty = true; + this._component = newComponent; + }, + didUpdate$1(oldComponent) { + if (this._dirty) + this.rebuild$0(); + }, + inflateComponent$2(newComponent, prevSibling) { + var newChild = newComponent.createElement$0(); + newChild.mount$2(this, prevSibling); + newChild.didMount$0(); + return newChild; + }, + deactivateChild$1(child) { + var t1; + child._prevAncestorSibling = child._prevSibling = child._parent = null; + t1 = this._owner._inactiveElements; + if (child._lifecycleState === B._ElementLifecycle_1) { + child.detachRenderObject$0(); + child.deactivate$0(); + child.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t1._framework$_elements.add$1(0, child); + }, + deactivate$0() { + var t2, t3, _this = this, + t1 = _this._dependencies; + if (t1 != null && t1._collection$_length !== 0) + for (t2 = A._instanceType(t1), t1 = new A._HashSetIterator(t1, t1._computeElements$0(), t2._eval$1("_HashSetIterator<1>")), t2 = t2._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + (t3 == null ? t2._as(t3) : t3).deactivateDependent$1(_this); + } + _this._inheritedElements = null; + _this._lifecycleState = B._ElementLifecycle_2; + }, + unmount$0() { + var _this = this; + _this.get$component(); + _this._dependencies = _this._component = _this._parentRenderObjectElement = null; + _this._lifecycleState = B._ElementLifecycle_3; + }, + _updateInheritance$0() { + var t1 = this._parent; + this._inheritedElements = t1 == null ? null : t1._inheritedElements; + }, + _updateObservers$0() { + var t1 = this._parent; + this._observerElements = t1 == null ? null : t1._observerElements; + }, + attachNotificationTree$0() { + var t1 = this._parent; + this._notificationTree = t1 == null ? null : t1._notificationTree; + }, + markNeedsBuild$0() { + var _this = this; + if (_this._lifecycleState !== B._ElementLifecycle_1) + return; + if (_this._dirty) + return; + _this._dirty = true; + _this._owner.scheduleBuildFor$1(_this); + }, + rebuild$0() { + var _this = this; + if (_this._lifecycleState !== B._ElementLifecycle_1 || !_this._dirty) + return; + _this._owner.toString; + _this.performRebuild$0(); + new A.Element_rebuild_closure(_this).call$0(); + _this.attachRenderObject$0(); + }, + attachRenderObject$0() { + }, + detachRenderObject$0() { + this.visitChildren$1(new A.Element_detachRenderObject_closure()); + }, + updateLastChild$1(child) { + var t1, _this = this; + _this._lastChild = child; + _this._lastRenderObjectElement = child == null ? null : child.get$_lastRenderObjectElement(); + t1 = _this._parent; + if (J.$eq$(t1 == null ? null : t1._lastChild, _this)) { + t1 = _this._parent; + t1 = t1 == null ? null : t1.get$_lastRenderObjectElement(); + t1 = !J.$eq$(t1, _this.get$_lastRenderObjectElement()); + } else + t1 = false; + if (t1) + _this._parent.updateLastChild$1(_this); + }, + updatePrevSibling$1(prevSibling) { + this._prevSibling = prevSibling; + this._updateAncestorSiblingRecursively$1(false); + this._parentChanged = false; + }, + _didUpdateSlot$0() { + }, + _updateAncestorSiblingRecursively$1(didChangeAncestor) { + var t1, _this = this, + newAncestorSibling = _this._prevSibling; + if (newAncestorSibling == null) { + t1 = _this._parent; + if (type$.RenderObjectElement._is(t1)) + newAncestorSibling = null; + else { + t1 = t1 == null ? null : t1._prevAncestorSibling; + newAncestorSibling = t1; + } + } + if (didChangeAncestor || !J.$eq$(newAncestorSibling, _this._prevAncestorSibling)) { + _this._prevAncestorSibling = newAncestorSibling; + _this._didUpdateSlot$0(); + if (!type$.RenderObjectElement._is(_this)) + _this.visitChildren$1(new A.Element__updateAncestorSiblingRecursively_closure()); + } + }, + get$_lastRenderObjectElement() { + return this._lastRenderObjectElement; + } + }; + A.Element_updateChildren_replaceWithNullIfForgotten.prototype = { + call$1(child) { + var t1; + if (child != null) + t1 = this.forgottenChildren.contains$1(0, child); + else + t1 = false; + return t1 ? null : child; + }, + $signature: 29 + }; + A.Element_rebuild_closure.prototype = { + call$0() { + var t3, t4, + t1 = this.$this, + t2 = t1._dependencies; + if (t2 != null && t2._collection$_length !== 0) + for (t3 = A._instanceType(t2), t2 = new A._HashSetIterator(t2, t2._computeElements$0(), t3._eval$1("_HashSetIterator<1>")), t3 = t3._precomputed1; t2.moveNext$0();) { + t4 = t2._collection$_current; + (t4 == null ? t3._as(t4) : t4).didRebuildDependent$1(t1); + } + }, + $signature: 0 + }; + A.Element_detachRenderObject_closure.prototype = { + call$1(child) { + child.detachRenderObject$0(); + }, + $signature: 4 + }; + A.Element__updateAncestorSiblingRecursively_closure.prototype = { + call$1(e) { + return e._updateAncestorSiblingRecursively$1(true); + }, + $signature: 4 + }; + A._InactiveElements.prototype = { + _unmount$1(element) { + element.visitChildren$1(new A._InactiveElements__unmount_closure(this)); + element.unmount$0(); + }, + _unmountAll$0() { + var t2, t3, + t1 = this._framework$_elements, + elements = A.List_List$of(t1, true, A._instanceType(t1)._precomputed1); + B.JSArray_methods.sort$1(elements, A.framework_Element__sort$closure()); + t1.clear$0(0); + for (t1 = A._arrayInstanceType(elements)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(elements, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + this._unmount$1(t3 == null ? t1._as(t3) : t3); + } + } + }; + A._InactiveElements__unmount_closure.prototype = { + call$1(child) { + this.$this._unmount$1(child); + }, + $signature: 4 + }; + A.ProxyComponent.prototype = { + createElement$0() { + return A.ProxyElement$(this); + } + }; + A.ProxyElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return true; + }, + performRebuild$0() { + var comp, newComponents, t1, t2, _this = this; + _this._dirty = false; + comp = type$.ProxyComponent._as(_this.get$component()); + newComponents = comp.children; + if (newComponents == null) { + t1 = A._setArrayType([], type$.JSArray_Component); + t2 = comp.child; + if (t2 != null) + t1.push(t2); + newComponents = t1; + } + t1 = _this._children; + if (t1 == null) + t1 = A._setArrayType([], type$.JSArray_Element); + t2 = _this._forgottenChildren; + _this._children = _this.updateChildren$3$forgottenChildren(t1, newComponents, t2); + t2.clear$0(0); + }, + visitChildren$1(visitor) { + var t2, child, + t1 = this._children; + t1 = J.get$iterator$ax(t1 == null ? [] : t1); + t2 = this._forgottenChildren; + for (; t1.moveNext$0();) { + child = t1.get$current(); + if (!t2.contains$1(0, child)) + visitor.call$1(child); + } + } + }; + A.RenderObject.prototype = {}; + A.ProxyRenderObjectElement.prototype = { + didMount$0() { + var t1, renderObject, _this = this; + if (_this.RenderObjectElement__renderObject == null) { + t1 = _this._parentRenderObjectElement.RenderObjectElement__renderObject; + t1.toString; + renderObject = new A.DomRenderObject(A._setArrayType([], type$.JSArray_JSObject)); + renderObject.parent = t1; + _this.RenderObjectElement__renderObject = renderObject; + _this.updateRenderObject$0(); + } + _this.super$ProxyElement$didMount(); + }, + update$1(newComponent) { + if (this.shouldRerender$1(newComponent)) + this.RenderObjectElement__dirtyRender = true; + this.super$Element$update(newComponent); + }, + didUpdate$1(oldComponent) { + var _this = this; + if (_this.RenderObjectElement__dirtyRender) { + _this.RenderObjectElement__dirtyRender = false; + _this.updateRenderObject$0(); + } + _this.super$Element$didUpdate(oldComponent); + }, + _didUpdateSlot$0() { + this.super$Element$_didUpdateSlot(); + this.attachRenderObject$0(); + } + }; + A.RenderObjectElement.prototype = { + shouldRerender$1(newComponent) { + return true; + }, + attachRenderObject$0() { + var $parent, prevElem, after, t2, + t1 = this._parentRenderObjectElement; + if (t1 == null) + $parent = null; + else { + t1 = t1.RenderObjectElement__renderObject; + t1.toString; + $parent = t1; + } + if ($parent != null) { + prevElem = this._prevAncestorSibling; + while (true) { + t1 = prevElem == null; + if (!(!t1 && prevElem.get$_lastRenderObjectElement() == null)) + break; + prevElem = prevElem._prevAncestorSibling; + } + after = t1 ? null : prevElem.get$_lastRenderObjectElement(); + t1 = this.RenderObjectElement__renderObject; + t1.toString; + if (after == null) + t2 = null; + else { + t2 = after.RenderObjectElement__renderObject; + t2.toString; + } + $parent.attach$2$after(t1, t2); + } + }, + detachRenderObject$0() { + var $parent, t2, + t1 = this._parentRenderObjectElement; + if (t1 == null) + $parent = null; + else { + t1 = t1.RenderObjectElement__renderObject; + t1.toString; + $parent = t1; + } + if ($parent != null) { + t1 = this.RenderObjectElement__renderObject; + t2 = t1.node; + if (t2 != null) + t2.parentNode.removeChild(t2); + t1.parent = null; + } + }, + get$_lastRenderObjectElement() { + return this; + } + }; + A.EventStreamProvider.prototype = {}; + A._EventStreamSubscription.prototype = { + cancel$0() { + var t2, _this = this, + emptyFuture = A.Future_Future$value(null, type$.void), + t1 = _this._target; + if (t1 == null) + return emptyFuture; + t2 = _this._onData; + if (t2 != null) + t1.removeEventListener(_this._eventType, t2, false); + _this._onData = _this._target = null; + return emptyFuture; + } + }; + A._EventStreamSubscription_closure.prototype = { + call$1(e) { + return this.onData.call$1(e); + }, + $signature: 3 + }; + A.main_closure.prototype = { + call$1(p) { + A.checkDeferredIsLoaded("prefix0"); + return C.getComponentForParams(p); + }, + $signature: 31 + }; + (function aliases() { + var _ = J.LegacyJavaScriptObject.prototype; + _.super$LegacyJavaScriptObject$toString = _.toString$0; + _ = A.DomRenderObject.prototype; + _.super$DomRenderObject$attach = _.attach$2$after; + _ = A.ComponentsBinding.prototype; + _.super$ComponentsBinding$attachRootComponent = _.attachRootComponent$1; + _ = A.Element.prototype; + _.super$Element$mount = _.mount$2; + _.super$Element$didMount = _.didMount$0; + _.super$Element$update = _.update$1; + _.super$Element$didUpdate = _.didUpdate$1; + _.super$Element$deactivate = _.deactivate$0; + _.super$Element$unmount = _.unmount$0; + _.super$Element$_updateInheritance = _._updateInheritance$0; + _.super$Element$_didUpdateSlot = _._didUpdateSlot$0; + _ = A.ProxyElement.prototype; + _.super$ProxyElement$didMount = _.didMount$0; + })(); + (function installTearOffs() { + var _static_2 = hunkHelpers._static_2, + _static_1 = hunkHelpers._static_1, + _static_0 = hunkHelpers._static_0, + _instance = hunkHelpers.installInstanceTearOff, + _instance_0_u = hunkHelpers._instance_0u; + _static_2(J, "_interceptors_JSArray__compareAny$closure", "JSArray__compareAny", 35); + _static_1(A, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 5); + _static_1(A, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 5); + _static_1(A, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 5); + _static_0(A, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0); + _instance(A._Completer.prototype, "get$completeError", 0, 1, null, ["call$2", "call$1"], ["completeError$2", "completeError$1"], 17, 0, 0); + _instance_0_u(A.SchedulerBinding.prototype, "get$completeInitialFrame", "completeInitialFrame$0", 0); + _static_2(A, "framework_Element__sort$closure", "Element__sort", 37); + _static_1(A, "framework__InactiveElements__deactivateRecursively$closure", "_InactiveElements__deactivateRecursively", 4); + _instance_0_u(A.BuildOwner.prototype, "get$performBuild", "performBuild$0", 0); + _instance_0_u(A._InactiveElements.prototype, "get$_unmountAll", "_unmountAll$0", 0); + _static_0(A, "main_clients____loadLibrary_prefix0$closure", "__loadLibrary_prefix0", 25); + })(); + (function inheritance() { + var _mixin = hunkHelpers.mixin, + _mixinHard = hunkHelpers.mixinHard, + _inherit = hunkHelpers.inherit, + _inheritMany = hunkHelpers.inheritMany; + _inherit(A.Object, null); + _inheritMany(A.Object, [A.JS_CONST, J.Interceptor, J.ArrayIterator, A.Iterable, A.CastIterator, A.Error, A.SentinelValue, A.ListIterator, A.MappedIterator, A.WhereIterator, A.FixedLengthListMixin, A._Record, A.ConstantMap, A._KeysOrValuesOrElementsIterator, A.TypeErrorDecoder, A.NullThrownFromJavaScriptException, A.ExceptionAndStackTrace, A._StackTrace, A.Closure, A.MapBase, A.LinkedHashMapCell, A.LinkedHashMapKeyIterator, A.LinkedHashMapEntryIterator, A.JSSyntaxRegExp, A._MatchImplementation, A._AllMatchesIterator, A._Cell, A.Rti, A._FunctionParameters, A._Type, A._TimerImpl, A._AsyncAwaitCompleter, A._SyncStarIterator, A.AsyncError, A.DeferredLoadException, A._Completer, A._FutureListener, A._Future, A._AsyncCallbackEntry, A._StreamIterator, A._Zone, A.SetBase, A._HashSetIterator, A._LinkedHashSetCell, A._LinkedHashSetIterator, A.ListBase, A.Codec, A.Converter, A._Enum, A.StackOverflowError, A._Exception, A.FormatException, A.MapEntry, A.Null, A._StringStackTrace, A.StringBuffer, A._AppBinding_Object_SchedulerBinding, A.RenderObject, A.EventBinding, A.SchedulerBinding, A.BuildOwner, A.ComponentsBinding, A.Component, A.Element, A._InactiveElements, A.RenderObjectElement, 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.Iterable, [A._CastIterableBase, A.EfficientLengthIterable, A.MappedIterable, A.WhereIterable, A._KeysOrValues, A._SyncStarIterable]); + _inherit(A.__CastListBase__CastIterableBase_ListMixin, A._CastIterableBase); + _inherit(A._CastListBase, A.__CastListBase__CastIterableBase_ListMixin); + _inherit(A.CastList, A._CastListBase); + _inheritMany(A.Error, [A.LateError, A.TypeError, A.JsNoSuchMethodError, A.UnknownJsTypeError, A._CyclicInitializationError, A.RuntimeError, A.DeferredNotLoadedError, A._Error, A.AssertionError, A.ArgumentError, A.UnsupportedError, A.UnimplementedError, A.StateError, A.ConcurrentModificationError]); + _inheritMany(A.EfficientLengthIterable, [A.ListIterable, A.LinkedHashMapKeysIterable, A.LinkedHashMapEntriesIterable]); + _inherit(A.EfficientLengthMappedIterable, A.MappedIterable); + _inheritMany(A.ListIterable, [A.MappedListIterable, A.ReversedListIterable, A._JsonMapKeyIterable]); + _inheritMany(A._Record, [A._Record2, A._Record3]); + _inheritMany(A._Record2, [A._Record_2, A._Record_2_isActive_todo]); + _inherit(A._Record_3, A._Record3); + _inherit(A.ConstantStringMap, A.ConstantMap); + _inherit(A.NullError, A.TypeError); + _inheritMany(A.Closure, [A.Closure0Args, A.Closure2Args, A.TearOffClosure, A.loadDeferredLibrary_closure, A.loadDeferredLibrary_loadAndInitialize, A.loadDeferredLibrary_loadAndInitialize_closure, A.loadDeferredLibrary_closure0, A._loadAllHunks_closure, A._loadAllHunks_failure, A._loadAllHunks_failure_closure, A._loadAllHunks_failure_closure0, A._loadAllHunks_closure0, A._loadHunk_failure, A._loadHunk_closure, A._loadHunk_closure0, A._loadHunk_closure1, A._loadHunk_closure2, A.initHooks_closure, A.initHooks_closure1, A._AsyncRun__initializeScheduleImmediate_internalCallback, A._AsyncRun__initializeScheduleImmediate_closure, A._awaitOnObject_closure, A.Future_wait_closure, A._Future__propagateToListeners_handleWhenCompleteCallback_closure, A._RootZone_bindUnaryCallbackGuarded_closure, A.MapBase_entries_closure, A.registerClients_closure, A.registerClients__closure, A.loadClient__closure, A.DomRenderObject_updateElement_closure, A.DomRenderObject_updateElement_closure1, A.EventBinding_closure, A.unescapeMarkerText_closure, A.Element_updateChildren_replaceWithNullIfForgotten, A.Element_detachRenderObject_closure, A.Element__updateAncestorSiblingRecursively_closure, A._InactiveElements__unmount_closure, A._EventStreamSubscription_closure, A.main_closure]); + _inheritMany(A.TearOffClosure, [A.StaticClosure, A.BoundClosure]); + _inheritMany(A.Closure0Args, [A.loadDeferredLibrary_initializeSomeLoadedHunks, A.loadDeferredLibrary_finalizeLoad, A._loadAllHunks_success, A._loadHunk_success, A._AsyncRun__scheduleImmediateJsOverride_internalCallback, A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, A._TimerImpl_internalCallback, A._Future__addListener_closure, A._Future__prependListeners_closure, A._Future__chainCoreFuture_closure, A._Future__asyncCompleteWithValue_closure, A._Future__asyncCompleteErrorObject_closure, A._Future__propagateToListeners_handleWhenCompleteCallback, A._Future__propagateToListeners_handleValueCallback, A._Future__propagateToListeners_handleError, A._rootHandleError_closure, A._RootZone_bindCallbackGuarded_closure, A.loadClient_closure, A.SchedulerBinding_scheduleBuild_closure, A.BuildOwner_performInitialBuild_closure, A.Element_rebuild_closure]); + _inheritMany(A.MapBase, [A.JsLinkedHashMap, A._JsonMap]); + _inheritMany(A.Closure2Args, [A.JsLinkedHashMap_addAll_closure, A.initHooks_closure0, A._awaitOnObject_closure0, A._wrapJsFunctionForAsync_closure, A.Future_wait_handleError, A._Future__propagateToListeners_handleWhenCompleteCallback_closure0, A.MapBase_mapToString_closure, A.DomRenderObject_clearEvents_closure, A.DomRenderObject_updateElement_closure0]); + _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); + _inherit(A._AsyncCompleter, A._Completer); + _inherit(A._RootZone, A._Zone); + _inherit(A._SetBase, A.SetBase); + _inheritMany(A._SetBase, [A._HashSet, A._LinkedHashSet]); + _inherit(A.JsonCodec, A.Codec); + _inherit(A.JsonDecoder, A.Converter); + _inheritMany(A.ArgumentError, [A.RangeError, A.IndexError]); + _inherit(A.AppBinding, A._AppBinding_Object_SchedulerBinding); + _inherit(A._BrowserAppBinding_AppBinding_ComponentsBinding, A.AppBinding); + _inherit(A.BrowserAppBinding, A._BrowserAppBinding_AppBinding_ComponentsBinding); + _inherit(A.DomRenderObject, A.RenderObject); + _inherit(A.RootDomRenderObject, A.DomRenderObject); + _inheritMany(A._Enum, [A.SchedulerPhase, A._ElementLifecycle]); + _inherit(A.ProxyComponent, A.Component); + _inherit(A._Root, A.ProxyComponent); + _inherit(A.ProxyElement, A.Element); + _inherit(A.ProxyRenderObjectElement, A.ProxyElement); + _inherit(A._RootElement, A.ProxyRenderObjectElement); + _mixin(A.__CastListBase__CastIterableBase_ListMixin, A.ListBase); + _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._BrowserAppBinding_AppBinding_ComponentsBinding, A.ComponentsBinding); + _mixin(A._AppBinding_Object_SchedulerBinding, A.SchedulerBinding); + _mixinHard(A.ProxyRenderObjectElement, A.RenderObjectElement); + })(); + var init = { + deferredInitialized: Object.create(null), + isHunkLoaded: function(hash) { + return !!$__dart_deferred_initializers__[hash]; + }, + isHunkInitialized: function(hash) { + return !!init.deferredInitialized[hash]; + }, + eventLog: $__dart_deferred_initializers__.eventLog, + initializeLoadedHunk: function(hash) { + var hunk = $__dart_deferred_initializers__[hash]; + if (hunk == null) { + throw "DeferredLoading state error: code with hash '" + hash + "' was not loaded"; + } + initializeDeferredHunk(hunk); + init.deferredInitialized[hash] = true; + }, + deferredLibraryParts: { + prefix0: [0] + }, + deferredPartUris: ["main.clients.dart.js_1.part.js"], + deferredPartHashes: ["B7DERL8wi+bmR2ZOLSPQSArwk/c="], + 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: ["~()", "Null(@)", "~(@)", "~(JSObject)", "~(Element)", "~(~())", "~(String)", "Null()", "~(@,String,StackTrace?,List?,List?)", "@(@)", "@(@,String)", "@(String)", "Null(~())", "Future<@>(int)", "Null(@,StackTrace)", "~(int,@)", "~(Object,StackTrace)", "~(Object[StackTrace?])", "Null(Object,StackTrace)", "~(Object?,Object?)", "Component(Map)/(String)", "Component(Map)(Component(Map))", "Future)>()", "Component(Map)(~)", "~(String,EventBinding)", "Future<@>()", "~(String,~(JSObject))", "Null(Null)", "String(Match)", "Element?(Element?)", "Null(List<@>)", "Component(Map)", "~(@,@)", "Object?()", "bool(int,+isActive,todo(bool,String))", "int(@,@)", "~(@,String,StackTrace?)", "int(Element,Element)", "String(MapEntry)"], + interceptorsByTag: null, + leafTags: null, + arrayRti: Symbol("$ti"), + rttc: { + "2;": (t1, t2) => o => o instanceof A._Record_2 && t1._is(o._0) && t2._is(o._1), + "2;isActive,todo": (t1, t2) => o => o instanceof A._Record_2_isActive_todo && t1._is(o._0) && t2._is(o._1), + "3;": (t1, t2, t3) => o => o instanceof A._Record_3 && t1._is(o._0) && t2._is(o._1) && t3._is(o._2) + } + }; + 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"],"EfficientLengthIterable":["1"],"JSObject":[]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"EfficientLengthIterable":["1"],"JSObject":[]},"JSNumber":{"double":[]},"JSInt":{"double":[],"int":[],"TrustedGetRuntimeType":[]},"JSNumNotInt":{"double":[],"TrustedGetRuntimeType":[]},"JSString":{"String":[],"TrustedGetRuntimeType":[]},"_CastIterableBase":{"Iterable":["2"]},"_CastListBase":{"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"]},"CastList":{"_CastListBase":["1","2"],"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListBase.E":"2","Iterable.E":"2"},"LateError":{"Error":[]},"EfficientLengthIterable":{"Iterable":["1"]},"ListIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"MappedIterable":{"Iterable":["2"],"Iterable.E":"2"},"EfficientLengthMappedIterable":{"MappedIterable":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"MappedListIterable":{"ListIterable":["2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListIterable.E":"2","Iterable.E":"2"},"WhereIterable":{"Iterable":["1"],"Iterable.E":"1"},"ReversedListIterable":{"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"ListIterable.E":"1","Iterable.E":"1"},"ConstantMap":{"Map":["1","2"]},"ConstantStringMap":{"ConstantMap":["1","2"],"Map":["1","2"]},"_KeysOrValues":{"Iterable":["1"],"Iterable.E":"1"},"NullError":{"TypeError":[],"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"_CyclicInitializationError":{"Error":[]},"RuntimeError":{"Error":[]},"DeferredNotLoadedError":{"Error":[]},"JsLinkedHashMap":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"LinkedHashMapKeysIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"LinkedHashMapEntriesIterable":{"EfficientLengthIterable":["MapEntry<1,2>"],"Iterable":["MapEntry<1,2>"],"Iterable.E":"MapEntry<1,2>"},"_MatchImplementation":{"RegExpMatch":[],"Match":[]},"NativeByteBuffer":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedData":{"JSObject":[]},"NativeByteData":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedArray":{"JavaScriptIndexingBehavior":["1"],"JSObject":[]},"NativeTypedArrayOfDouble":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[]},"NativeTypedArrayOfInt":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[]},"NativeFloat32List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeFloat64List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeInt16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8ClampedList":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"_Type":{"Type":[]},"_Error":{"Error":[]},"_TypeError":{"TypeError":[],"Error":[]},"_SyncStarIterable":{"Iterable":["1"],"Iterable.E":"1"},"AsyncError":{"Error":[]},"_AsyncCompleter":{"_Completer":["1"]},"_Future":{"Future":["1"]},"_HashSet":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"_LinkedHashSet":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"MapBase":{"Map":["1","2"]},"SetBase":{"EfficientLengthIterable":["1"]},"_SetBase":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"_JsonMap":{"MapBase":["String","@"],"Map":["String","@"],"MapBase.V":"@","MapBase.K":"String"},"_JsonMapKeyIterable":{"ListIterable":["String"],"EfficientLengthIterable":["String"],"Iterable":["String"],"ListIterable.E":"String","Iterable.E":"String"},"List":{"EfficientLengthIterable":["1"]},"RegExpMatch":{"Match":[]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"StateError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"StackOverflowError":{"Error":[]},"_StringStackTrace":{"StackTrace":[]},"InheritedElement":{"Element":[]},"_Root":{"ProxyComponent":[],"Component":[]},"_RootElement":{"RenderObjectElement":[],"Element":[]},"ProxyComponent":{"Component":[]},"ProxyElement":{"Element":[]},"ProxyRenderObjectElement":{"RenderObjectElement":[],"Element":[]},"Int8List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint8List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint8ClampedList":{"List":["int"],"EfficientLengthIterable":["int"]},"Int16List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint16List":{"List":["int"],"EfficientLengthIterable":["int"]},"Int32List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint32List":{"List":["int"],"EfficientLengthIterable":["int"]},"Float32List":{"List":["double"],"EfficientLengthIterable":["double"]},"Float64List":{"List":["double"],"EfficientLengthIterable":["double"]}}')); + A._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"WhereIterator":1,"FixedLengthListMixin":1,"__CastListBase__CastIterableBase_ListMixin":2,"LinkedHashMapKeyIterator":1,"NativeTypedArray":1,"_SyncStarIterator":1,"_StreamIterator":1,"_SetBase":1,"Codec":2,"Converter":2,"_EventStreamSubscription":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 { + Component: findType("Component"), + Component_Function_Map_String_dynamic: findType("Component(Map)"), + EfficientLengthIterable_dynamic: findType("EfficientLengthIterable<@>"), + Element: findType("Element"), + Error: findType("Error"), + EventBinding: findType("EventBinding"), + Function: findType("Function"), + FutureOr_Component_Function_Map_String_dynamic: findType("Component(Map)/"), + FutureOr_Component_Function_Map_String_dynamic_Function: findType("Component(Map)/()"), + Future_dynamic: findType("Future<@>"), + Future_of_Component_Function_Map_String_dynamic: findType("Future)>"), + JSArray_Component: findType("JSArray"), + JSArray_Element: findType("JSArray"), + JSArray_Future_dynamic: findType("JSArray>"), + JSArray_JSObject: findType("JSArray"), + JSArray_Object: findType("JSArray"), + JSArray_Record_3_String_and_nullable_String_and_JSObject: findType("JSArray<+(String,String?,JSObject)>"), + JSArray_String: findType("JSArray"), + JSArray_dynamic: findType("JSArray<@>"), + JSArray_of_void_Function: findType("JSArray<~()>"), + JSNull: findType("JSNull"), + JSObject: findType("JSObject"), + JavaScriptFunction: findType("JavaScriptFunction"), + JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"), + Key: findType("Key"), + List_dynamic: findType("List<@>"), + Map_String_dynamic: findType("Map"), + Null: findType("Null"), + Object: findType("Object"), + ProxyComponent: findType("ProxyComponent"), + Record: findType("Record"), + Record_0: findType("+()"), + Record_2_nullable_Object_and_nullable_Object: findType("+(Object?,Object?)"), + RegExpMatch: findType("RegExpMatch"), + RenderObjectElement: findType("RenderObjectElement"), + StackTrace: findType("StackTrace"), + String: findType("String"), + TrustedGetRuntimeType: findType("TrustedGetRuntimeType"), + TypeError: findType("TypeError"), + UnknownJavaScriptObject: findType("UnknownJavaScriptObject"), + _AsyncCompleter_Null: findType("_AsyncCompleter"), + _Future_Null: findType("_Future"), + _Future_dynamic: findType("_Future<@>"), + _SyncStarIterable_JSObject: findType("_SyncStarIterable"), + bool: findType("bool"), + double: findType("double"), + dynamic: 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_Element: findType("Element?"), + nullable_Future_Null: findType("Future?"), + nullable_JSObject: findType("JSObject?"), + nullable_Object: findType("Object?"), + nullable_String: findType("String?"), + nullable_bool: findType("bool?"), + nullable_double: findType("double?"), + nullable_int: findType("int?"), + nullable_num: findType("num?"), + num: findType("num"), + void: findType("~"), + void_Function: findType("~()") + }; + })(); + (function constants() { + B.Interceptor_methods = J.Interceptor.prototype; + B.JSArray_methods = J.JSArray.prototype; + B.JSInt_methods = J.JSInt.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_SentinelValue = new A.SentinelValue(); + B.C__RootZone = new A._RootZone(); + B.C__StringStackTrace = new A._StringStackTrace(); + B.JsonDecoder_null = new A.JsonDecoder(null); + B.Object_svg_0_math_1 = {svg: 0, math: 1}; + B.Map_rvfri = new A.ConstantStringMap(B.Object_svg_0_math_1, ["http://www.w3.org/2000/svg", "http://www.w3.org/1998/Math/MathML"], A.findType("ConstantStringMap")); + B.SchedulerPhase_0 = new A.SchedulerPhase("idle"); + B.SchedulerPhase_1 = new A.SchedulerPhase("midFrameCallback"); + B.SchedulerPhase_2 = new A.SchedulerPhase("postFrameCallbacks"); + B.Type_ByteBuffer_rqD = A.typeLiteral("ByteBuffer"); + B.Type_ByteData_9dB = A.typeLiteral("ByteData"); + B.Type_Float32List_9Kz = A.typeLiteral("Float32List"); + B.Type_Float64List_9Kz = A.typeLiteral("Float64List"); + B.Type_Int16List_s5h = A.typeLiteral("Int16List"); + B.Type_Int32List_O8Z = A.typeLiteral("Int32List"); + B.Type_Int8List_rFV = A.typeLiteral("Int8List"); + B.Type_JSObject_ttY = A.typeLiteral("JSObject"); + B.Type_Object_A4p = A.typeLiteral("Object"); + B.Type_Uint16List_kmP = A.typeLiteral("Uint16List"); + B.Type_Uint32List_kmP = A.typeLiteral("Uint32List"); + B.Type_Uint8ClampedList_04U = A.typeLiteral("Uint8ClampedList"); + B.Type_Uint8List_8Eb = A.typeLiteral("Uint8List"); + B._ElementLifecycle_0 = new A._ElementLifecycle("initial"); + B._ElementLifecycle_1 = new A._ElementLifecycle("active"); + B._ElementLifecycle_2 = new A._ElementLifecycle("inactive"); + B._ElementLifecycle_3 = new A._ElementLifecycle("defunct"); + })(); + (function staticFields() { + $._JS_INTEROP_INTERCEPTOR_TAG = null; + $.toStringVisiting = A._setArrayType([], type$.JSArray_Object); + $.Primitives__identityHashCodeProperty = null; + $.BoundClosure__receiverFieldNameCache = null; + $.BoundClosure__interceptorFieldNameCache = null; + $._loadedLibraries = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + $.getTagFunction = null; + $.alternateTagFunction = null; + $.prototypeForTagFunction = null; + $.dispatchRecordsForInstanceTags = null; + $.interceptorsForUncacheableTags = null; + $.initNativeDispatchFlag = null; + $._Record__computedFieldKeys = A._setArrayType([], A.findType("JSArray?>")); + $._nextCallback = null; + $._lastCallback = null; + $._lastPriorityCallback = null; + $._isInCallbackLoop = false; + $.Zone__current = B.C__RootZone; + $.Element__nextHashCode = 1; + })(); + (function lazyInitializers() { + var _lazyFinal = hunkHelpers.lazyFinal, + _lazy = hunkHelpers.lazy; + _lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", () => A.getIsolateAffinityTag("_$dart_dartClosure")); + _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($, "_loadingLibraries", "$get$_loadingLibraries", () => A.LinkedHashMap_LinkedHashMap$_empty(type$.String, A.findType("Completer?"))); + _lazy($, "_cspNonce", "$get$_cspNonce", () => A._computeCspNonce()); + _lazy($, "_crossOrigin", "$get$_crossOrigin", () => A._computeCrossOrigin()); + _lazyFinal($, "thisScript", "$get$thisScript", () => A._computeThisScript()); + _lazyFinal($, "_thisScriptBaseUrl", "$get$_thisScriptBaseUrl", () => { + var script = $.$get$thisScript(); + return script.substring(0, script.lastIndexOf("/") + 1); + }); + _lazyFinal($, "_deferredLoadingTrustedTypesPolicy", "$get$_deferredLoadingTrustedTypesPolicy", () => A._computePolicy()); + _lazyFinal($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", () => A._AsyncRun__initializeScheduleImmediate()); + _lazyFinal($, "_hashSeed", "$get$_hashSeed", () => A.objectHashCode(B.Type_Object_A4p)); + _lazyFinal($, "_compStartRegex", "$get$_compStartRegex", () => A.RegExp_RegExp("^@(\\S+)(?:\\s+data=(.*))?$")); + _lazyFinal($, "_compEndRegex", "$get$_compEndRegex", () => A.RegExp_RegExp("^/@(\\S+)$")); + _lazyFinal($, "_escapeRegex", "$get$_escapeRegex", () => A.RegExp_RegExp("&(amp|lt|gt);")); + })(); + (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$1 = function(a) { + return this(a); + }; + Function.prototype.call$0 = function() { + return this(); + }; + Function.prototype.call$1 = function(a) { + return this(a); + }; + 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$5 = function(a, b, c, d, e) { + return this(a, b, c, d, e); + }; + Function.prototype.call$1$0 = function() { + return this(); + }; + 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([]); + } + }); +})(); + +//# sourceMappingURL=main.clients.dart.js.map diff --git a/resources/todomvc/dart2js-jaspr/main.clients.dart.js_1.part.js b/resources/todomvc/dart2js-jaspr/main.clients.dart.js_1.part.js new file mode 100644 index 000000000..5bd0e5447 --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/main.clients.dart.js_1.part.js @@ -0,0 +1,1284 @@ +// Generated by dart2js (, trust primitives, omit checks, lax runtime type, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.8.0-edge.4c8aedcb57fe678e6d30acfdc021aa9888576638. +((s, d, e) => { + s[d] = s[d] || {}; + s[d][e] = s[d][e] || []; + s[d][e].push({p: "main.clients.dart.js_1", e: "beginPart"}); +})(self, "$__dart_deferred_initializers__", "eventLog"); +$__dart_deferred_initializers__.current = function(hunkHelpers, init, holdersList, $) { + var J, B, D, + A = { + HashMap_HashMap($K, $V) { + return new A._HashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("_HashMap<1,2>")); + }, + _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, "", table); + delete table[""]; + return table; + }, + LinkedHashMap_LinkedHashMap($K, $V) { + return new B.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + HashMap_HashMap$from(other, $K, $V) { + var result = A.HashMap_HashMap($K, $V); + other.forEach$1(0, new A.HashMap_HashMap$from_closure(result, $K, $V)); + return result; + }, + LinkedHashMap_LinkedHashMap$of(other, $K, $V) { + var t1 = A.LinkedHashMap_LinkedHashMap($K, $V); + t1.addAll$1(0, other); + return t1; + }, + _HashMap: function _HashMap(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; + }, + HashMap_HashMap$from_closure: function HashMap_HashMap$from_closure(t0, t1, t2) { + this.result = t0; + this.K = t1; + this.V = t2; + }, + div(children, classes) { + var _null = null; + return new A.DomComponent("div", _null, classes, _null, _null, _null, _null, children, _null); + }, + ul(children, classes) { + var _null = null; + return new A.DomComponent("ul", _null, classes, _null, _null, _null, _null, children, _null); + }, + li(children, attributes, classes) { + var t1, t2, _null = null; + if (attributes == null) { + t1 = type$.String; + t1 = B.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + } else + t1 = attributes; + t2 = type$.String; + t2 = A.LinkedHashMap_LinkedHashMap$of(t1, t2, t2); + return new A.DomComponent("li", _null, classes, _null, t2, _null, _null, children, _null); + }, + button(children, classes, onClick, styles) { + var t3, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$of(B.LinkedHashMap_LinkedHashMap$_empty(t1, t1), t1, t1); + t1 = B.LinkedHashMap_LinkedHashMap$_empty(t1, type$.void_Function_JSObject); + t3 = type$.dynamic; + t1.addAll$1(0, A.events__events$closure().call$2$1$onClick(onClick, t3, t3)); + return new A.DomComponent("button", null, classes, styles, t2, t1, null, children, null); + }, + input(children, attributes, classes, id, key, onChange, type, value) { + var t3, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$of(attributes, t1, t1); + if (type != null) + t2.$indexSet(0, "type", type.value); + if (value != null) + t2.$indexSet(0, "value", value); + t1 = B.LinkedHashMap_LinkedHashMap$_empty(t1, type$.void_Function_JSObject); + t3 = type$.dynamic; + t1.addAll$1(0, A.events__events$closure().call$2$2$onChange$onInput(onChange, null, t3, t3)); + return new A.DomComponent("input", id, classes, null, t2, t1, null, children, key); + }, + label(children, attributes, classes) { + var t1, t2, _null = null; + if (attributes == null) { + t1 = type$.String; + t1 = B.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + } else + t1 = attributes; + t2 = type$.String; + t2 = A.LinkedHashMap_LinkedHashMap$of(t1, t2, t2); + return new A.DomComponent("label", _null, classes, _null, t2, _null, _null, children, _null); + }, + span(children, classes, events) { + var _null = null; + return new A.DomComponent("span", _null, classes, _null, _null, events, _null, children, _null); + }, + InputType: function InputType(t0, t1) { + this.value = t0; + this._name = t1; + }, + events(onChange, onClick, onInput, V1, V2) { + var t1 = B.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.void_Function_JSObject); + if (onClick != null) + t1.$indexSet(0, "click", new A.events_closure(onClick)); + if (onChange != null) + t1.$indexSet(0, "change", A._callWithValue("onChange", onChange, V2)); + return t1; + }, + _callWithValue($event, fn, $V) { + return new A._callWithValue_closure(fn, $V); + }, + _extension_0_toIterable(_this) { + return new B._SyncStarIterable(A._extension_0_toIterable$body(_this), type$._SyncStarIterable_JSObject); + }, + _extension_0_toIterable$body($async$_this) { + return function() { + var _this = $async$_this; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], i, t1; + return function $async$_extension_0_toIterable($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + i = 0; + case 2: + // for condition + if (!(i < _this.length)) { + // goto after for + $async$goto = 4; + break; + } + t1 = _this.item(i); + t1.toString; + $async$goto = 5; + return $async$iterator._async$_current = t1, 1; + case 5: + // after yield + case 3: + // for update + ++i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + events_closure: function events_closure(t0) { + this.onClick = t0; + }, + _callWithValue_closure: function _callWithValue_closure(t0, t1) { + this.fn = t0; + this.V = t1; + }, + _callWithValue__closure: function _callWithValue__closure(t0) { + this.target = t0; + }, + _callWithValue___closure: function _callWithValue___closure(t0) { + this.target = t0; + }, + Styles: function Styles() { + }, + StylesMixin: function StylesMixin() { + }, + _RawStyles: function _RawStyles(t0) { + this.styles = t0; + }, + _Styles_Object_StylesMixin: function _Styles_Object_StylesMixin() { + }, + BuildableElement: function BuildableElement() { + }, + DomComponent: function DomComponent(t0, t1, t2, t3, t4, t5, t6, t7, t8) { + var _ = this; + _.tag = t0; + _.id = t1; + _.classes = t2; + _.styles = t3; + _.attributes = t4; + _.events = t5; + _.child = t6; + _.children = t7; + _.key = t8; + }, + DomElement: function DomElement(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._wrappingElement = null; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._children = null; + _._forgottenChildren = t2; + _._notificationTree = _._parent = null; + _._cachedHash = t3; + _._depth = null; + _._component = t4; + _._owner = _._binding = null; + _._lifecycleState = t5; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + Text: function Text(t0, t1) { + this.text = t0; + this.key = t1; + }, + TextElement: function TextElement(t0, t1, t2, t3, t4) { + var _ = this; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._notificationTree = _._parent = null; + _._cachedHash = t2; + _._depth = null; + _._component = t3; + _._owner = _._binding = null; + _._lifecycleState = t4; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + Key: function Key() { + }, + LocalKey: function LocalKey() { + }, + ValueKey: function ValueKey(t0, t1) { + this.value = t0; + this.$ti = t1; + }, + LeafElement: function LeafElement() { + }, + LeafRenderObjectElement: function LeafRenderObjectElement() { + }, + StatefulComponent: function StatefulComponent() { + }, + State: function State() { + }, + StatefulElement: function StatefulElement(t0, t1, t2, t3, t4) { + var _ = this; + _._framework$_state = t0; + _._asyncInitState = null; + _._didChangeDependencies = false; + _._children = null; + _._forgottenChildren = t1; + _._notificationTree = _._parent = null; + _._cachedHash = t2; + _._depth = null; + _._component = t3; + _._owner = _._binding = null; + _._lifecycleState = t4; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + StatelessComponent: function StatelessComponent() { + }, + StatelessElement: function StatelessElement(t0, t1, t2, t3) { + var _ = this; + _._children = _._asyncFirstBuild = null; + _._forgottenChildren = t0; + _._notificationTree = _._parent = null; + _._cachedHash = t1; + _._depth = null; + _._component = t2; + _._owner = _._binding = null; + _._lifecycleState = t3; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + MapExtensions_get_keyValues(_this, $K, $V) { + var t1 = B._instanceType(_this)._eval$1("LinkedHashMapEntriesIterable<1,2>"); + return B.MappedIterable_MappedIterable(new B.LinkedHashMapEntriesIterable(_this, t1), new A.MapExtensions_get_keyValues_closure($K, $V), t1._eval$1("Iterable.E"), $K._eval$1("@<0>")._bind$1($V)._eval$1("+(1,2)")); + }, + TodoMVC: function TodoMVC(t0) { + this.key = t0; + }, + DisplayState: function DisplayState(t0) { + this._name = t0; + }, + TodoMVCState: function TodoMVCState(t0, t1) { + var _ = this; + _.todos = t0; + _.activeCount = _.dataIdCount = 0; + _.displayState = t1; + _._framework$_element = null; + }, + TodoMVCState_addTodo_closure: function TodoMVCState_addTodo_closure(t0, t1) { + this.$this = t0; + this.todo = t1; + }, + TodoMVCState_toggle_closure: function TodoMVCState_toggle_closure(t0, t1) { + this.$this = t0; + this.i = t1; + }, + TodoMVCState_toggleAll_closure: function TodoMVCState_toggleAll_closure(t0) { + this.$this = t0; + }, + TodoMVCState_destroy_closure: function TodoMVCState_destroy_closure(t0, t1) { + this.$this = t0; + this.i = t1; + }, + TodoMVCState_clearCompleted_closure: function TodoMVCState_clearCompleted_closure(t0) { + this.$this = t0; + }, + TodoMVCState_clearCompleted__closure: function TodoMVCState_clearCompleted__closure() { + }, + TodoMVCState_setDisplayState_closure: function TodoMVCState_setDisplayState_closure(t0, t1) { + this.$this = t0; + this.state = t1; + }, + TodoMVCState_build_closure: function TodoMVCState_build_closure(t0) { + this.$this = t0; + }, + TodoMVCState_build_closure0: function TodoMVCState_build_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + TodoMVCState_build_closure1: function TodoMVCState_build_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + TodoMVCState_build_closure2: function TodoMVCState_build_closure2(t0, t1) { + this._box_1 = t0; + this.$this = t1; + }, + NewTodo: function NewTodo(t0, t1) { + this.handler = t0; + this.key = t1; + }, + NewTodo_build_closure: function NewTodo_build_closure(t0) { + this.$this = t0; + }, + MapExtensions_get_keyValues_closure: function MapExtensions_get_keyValues_closure(t0, t1) { + this.K = t0; + this.V = t1; + }, + getComponentForParams(p) { + return new A.TodoMVC(null); + } + }, + C; + J = holdersList[1]; + B = holdersList[0]; + D = holdersList[2]; + A = hunkHelpers.updateHolder(holdersList[3], A); + C = holdersList[4]; + A._HashMap.prototype = { + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._collection$_length !== 0; + }, + get$keys() { + return new A._HashMapKeyIterable(this, B._instanceType(this)._eval$1("_HashMapKeyIterable<1>")); + }, + containsKey$1(key) { + var t1 = this._containsKey$1(key); + return t1; + }, + _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, _this = this; + 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 + _this._set$2(key, value); + }, + _set$2(key, value) { + var hash, bucket, index, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._HashMap__newHashTable(); + hash = _this._computeHashCode$1(key); + 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; + } + } + }, + remove$1(_, key) { + var _this = this; + if (typeof key == "string" && key !== "__proto__") + return _this._removeHashTableEntry$2(_this._collection$_strings, key); + else if (typeof key == "number" && (key & 1073741823) === key) + return _this._removeHashTableEntry$2(_this._collection$_nums, key); + else + return _this._remove$1(key); + }, + _remove$1(key) { + var hash, bucket, index, result, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return null; + hash = _this._computeHashCode$1(key); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, key); + if (index < 0) + return null; + --_this._collection$_length; + _this._collection$_keys = null; + result = bucket.splice(index, 2)[1]; + if (0 === bucket.length) + delete rest[hash]; + return result; + }, + forEach$1(_, action) { + var $length, t1, i, key, t2, _this = this, + keys = _this._collection$_computeKeys$0(); + for ($length = keys.length, t1 = B._instanceType(_this)._rest[1], i = 0; i < $length; ++i) { + key = keys[i]; + t2 = _this.$index(0, key); + action.call$2(key, t2 == null ? t1._as(t2) : t2); + if (keys !== _this._collection$_keys) + throw B.wrapException(B.ConcurrentModificationError$(_this)); + } + }, + _collection$_computeKeys$0() { + var strings, index, names, entries, i, nums, rest, bucket, $length, i0, _this = this, + result = _this._collection$_keys; + if (result != null) + return result; + result = B.List_List$filled(_this._collection$_length, null, false, type$.dynamic); + strings = _this._collection$_strings; + index = 0; + if (strings != null) { + names = Object.getOwnPropertyNames(strings); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = names[i]; + ++index; + } + } + 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) { + if (table[key] == null) { + ++this._collection$_length; + this._collection$_keys = null; + } + A._HashMap__setTableEntry(table, key, value); + }, + _removeHashTableEntry$2(table, key) { + var value; + if (table != null && table[key] != null) { + value = A._HashMap__getTableEntry(table, key); + delete table[key]; + --this._collection$_length; + this._collection$_keys = null; + return value; + } else + return null; + }, + _computeHashCode$1(key) { + return J.get$hashCode$(key) & 1073741823; + }, + _getBucket$2(table, key) { + return table[this._computeHashCode$1(key)]; + }, + _findBucketIndex$2(bucket, key) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; i += 2) + if (J.$eq$(bucket[i], 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$isNotEmpty(_) { + return this._collection$_map._collection$_length !== 0; + }, + get$iterator(_) { + var t1 = this._collection$_map; + return new A._HashMapKeyIterator(t1, t1._collection$_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 B.wrapException(B.ConcurrentModificationError$(t1)); + else if (offset >= keys.length) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = keys[offset]; + _this._offset = offset + 1; + return true; + } + } + }; + A.InputType.prototype = { + _enumToString$0() { + return "InputType." + this._name; + } + }; + A.Styles.prototype = {}; + A.StylesMixin.prototype = {}; + A._RawStyles.prototype = {}; + A._Styles_Object_StylesMixin.prototype = {}; + A.BuildableElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return true; + }, + performRebuild$0() { + var e, st, t1, exception, t2, _this = this, _null = null, built = null; + try { + t1 = _this.build$0(); + t1 = B._setArrayType(t1.slice(0), B._arrayInstanceType(t1)); + built = t1; + } catch (exception) { + e = B.unwrapException(exception); + st = B.getTraceFromException(exception); + built = B._setArrayType([new A.DomComponent("div", _null, _null, _null, _null, _null, new A.Text("Error on building component: " + B.S(e), _null), _null, _null)], type$.JSArray_Component); + B.print("Error: " + B.S(e) + " " + B.S(st)); + } finally { + _this._dirty = false; + } + t1 = _this._children; + if (t1 == null) + t1 = B._setArrayType([], type$.JSArray_Element); + t2 = _this._forgottenChildren; + _this._children = _this.updateChildren$3$forgottenChildren(t1, built, t2); + t2.clear$0(0); + }, + visitChildren$1(visitor) { + var t2, child, + t1 = this._children; + t1 = J.get$iterator$ax(t1 == null ? [] : t1); + t2 = this._forgottenChildren; + for (; t1.moveNext$0();) { + child = t1.get$current(); + if (!t2.contains$1(0, child)) + visitor.call$1(child); + } + } + }; + A.DomComponent.prototype = { + createElement$0() { + var t1 = B.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.DomElement(null, false, t1, t2, this, D._ElementLifecycle_0); + } + }; + A.DomElement.prototype = { + get$component() { + return type$.DomComponent._as(B.Element.prototype.get$component.call(this)); + }, + _updateInheritance$0() { + var t1, _this = this; + _this.super$Element$_updateInheritance(); + t1 = _this._inheritedElements; + if (t1 != null && t1.containsKey$1(C.Type__WrappingDomComponent_kh6)) { + t1 = _this._inheritedElements; + t1.toString; + _this._inheritedElements = A.HashMap_HashMap$from(t1, type$.Type, type$.InheritedElement); + } + t1 = _this._inheritedElements; + _this._wrappingElement = t1 == null ? null : t1.remove$1(0, C.Type__WrappingDomComponent_kh6); + }, + shouldRerender$1(newComponent) { + var _this = this, + t1 = type$.DomComponent; + return t1._as(B.Element.prototype.get$component.call(_this)).tag !== newComponent.tag || t1._as(B.Element.prototype.get$component.call(_this)).id != newComponent.id || t1._as(B.Element.prototype.get$component.call(_this)).classes != newComponent.classes || t1._as(B.Element.prototype.get$component.call(_this)).styles != newComponent.styles || t1._as(B.Element.prototype.get$component.call(_this)).attributes != newComponent.attributes || t1._as(B.Element.prototype.get$component.call(_this)).events != newComponent.events; + }, + updateRenderObject$0() { + var t2, t3, t4, t5, t6, _this = this, + t1 = _this.RenderObjectElement__renderObject; + t1.toString; + t2 = type$.DomComponent; + t3 = t2._as(B.Element.prototype.get$component.call(_this)); + t4 = t2._as(B.Element.prototype.get$component.call(_this)); + t5 = t2._as(B.Element.prototype.get$component.call(_this)); + t6 = t2._as(B.Element.prototype.get$component.call(_this)).styles; + t6 = t6 == null ? null : t6.styles; + t1.updateElement$6(t3.tag, t4.id, t5.classes, t6, t2._as(B.Element.prototype.get$component.call(_this)).attributes, t2._as(B.Element.prototype.get$component.call(_this)).events); + } + }; + A.Text.prototype = { + createElement$0() { + var t1 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t1; + return new A.TextElement(null, false, t1, this, D._ElementLifecycle_0); + } + }; + A.TextElement.prototype = {}; + A.Key.prototype = {}; + A.LocalKey.prototype = {}; + A.ValueKey.prototype = { + $eq(_, other) { + if (other == null) + return false; + return J.get$runtimeType$(other) === B.getRuntimeTypeOfDartObject(this) && this.$ti._is(other) && other.value === this.value; + }, + get$hashCode(_) { + return B.Object_hashAll([B.getRuntimeTypeOfDartObject(this), this.value]); + }, + toString$0(_) { + var t1 = this.$ti, + t2 = t1._precomputed1, + t3 = this.value, + valueString = B.createRuntimeType(t2) === C.Type_String_AXU ? "<'" + t3 + "'>" : "<" + t3 + ">"; + if (B.getRuntimeTypeOfDartObject(this) === B.createRuntimeType(t1)) + return "[" + valueString + "]"; + return "[" + B.createRuntimeType(t2).toString$0(0) + " " + valueString + "]"; + } + }; + A.LeafElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return false; + }, + performRebuild$0() { + this._dirty = false; + }, + visitChildren$1(visitor) { + } + }; + A.LeafRenderObjectElement.prototype = { + didMount$0() { + var t1, renderObject, _this = this; + if (_this.RenderObjectElement__renderObject == null) { + t1 = _this._parentRenderObjectElement.RenderObjectElement__renderObject; + t1.toString; + renderObject = new B.DomRenderObject(B._setArrayType([], type$.JSArray_JSObject)); + renderObject.parent = t1; + _this.RenderObjectElement__renderObject = renderObject; + t1 = _this._component; + t1.toString; + renderObject.updateText$1(type$.Text._as(t1).text); + } + _this.super$LeafElement$didMount(); + }, + update$1(newComponent) { + var t1 = this._component; + t1.toString; + if (type$.Text._as(t1).text !== newComponent.text) + this.RenderObjectElement__dirtyRender = true; + this.super$Element$update(newComponent); + }, + didUpdate$1(oldComponent) { + var t1, t2, _this = this; + if (_this.RenderObjectElement__dirtyRender) { + _this.RenderObjectElement__dirtyRender = false; + t1 = _this.RenderObjectElement__renderObject; + t1.toString; + t2 = _this._component; + t2.toString; + t1.updateText$1(type$.Text._as(t2).text); + } + _this.super$Element$didUpdate(oldComponent); + }, + _didUpdateSlot$0() { + this.super$Element$_didUpdateSlot(); + this.attachRenderObject$0(); + } + }; + A.StatefulComponent.prototype = { + createElement$0() { + var t1 = new A.TodoMVCState(B.LinkedHashMap_LinkedHashMap$_empty(type$.int, type$.Record_2_bool_isActive_and_String_todo), C.DisplayState_0), + t2 = B.HashSet_HashSet(type$.Element), + t3 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t3; + return t1._framework$_element = new A.StatefulElement(t1, t2, t3, this, D._ElementLifecycle_0); + } + }; + A.State.prototype = { + setState$1(fn) { + fn.call$0(); + this._framework$_element.markNeedsBuild$0(); + } + }; + A.StatefulElement.prototype = { + build$0() { + return this._framework$_state.build$1(this); + }, + didMount$0() { + var _this = this; + if (_this._owner._isFirstBuild) + _this._framework$_state.toString; + _this._initState$0(); + _this.super$BuildableElement$didMount(); + }, + _initState$0() { + try { + this._framework$_state.toString; + } finally { + } + this._framework$_state.toString; + }, + performRebuild$0() { + var _this = this; + _this._owner.toString; + if (_this._didChangeDependencies) { + _this._framework$_state.toString; + _this._didChangeDependencies = false; + } + _this.super$BuildableElement$performRebuild(); + }, + shouldRebuild$1(newComponent) { + this._framework$_state.toString; + return true; + }, + update$1(newComponent) { + this.super$Element$update(newComponent); + this._framework$_state.toString; + }, + didUpdate$1(oldComponent) { + try { + this._framework$_state.toString; + } finally { + } + this.super$Element$didUpdate(oldComponent); + }, + deactivate$0() { + this._framework$_state.toString; + this.super$Element$deactivate(); + }, + unmount$0() { + this.super$Element$unmount(); + this._framework$_state = this._framework$_state._framework$_element = null; + } + }; + A.StatelessComponent.prototype = { + createElement$0() { + var t1 = B.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.StatelessElement(t1, t2, this, D._ElementLifecycle_0); + } + }; + A.StatelessElement.prototype = { + get$component() { + return type$.StatelessComponent._as(B.Element.prototype.get$component.call(this)); + }, + didMount$0() { + if (this._owner._isFirstBuild) + this._binding.toString; + this.super$BuildableElement$didMount(); + }, + shouldRebuild$1(newComponent) { + type$.StatelessComponent._as(B.Element.prototype.get$component.call(this)); + return true; + }, + build$0() { + return type$.StatelessComponent._as(B.Element.prototype.get$component.call(this)).build$1(this); + }, + performRebuild$0() { + this._owner.toString; + this.super$BuildableElement$performRebuild(); + } + }; + A.TodoMVC.prototype = {}; + A.DisplayState.prototype = { + _enumToString$0() { + return "DisplayState." + this._name; + } + }; + A.TodoMVCState.prototype = { + addTodo$1(todo) { + this.setState$1(new A.TodoMVCState_addTodo_closure(this, todo)); + }, + toggle$1(i) { + this.setState$1(new A.TodoMVCState_toggle_closure(this, i)); + }, + toggleAll$0() { + this.setState$1(new A.TodoMVCState_toggleAll_closure(this)); + }, + destroy$1(i) { + this.setState$1(new A.TodoMVCState_destroy_closure(this, i)); + }, + clearCompleted$0() { + this.setState$1(new A.TodoMVCState_clearCompleted_closure(this)); + }, + setDisplayState$1(state) { + this.setState$1(new A.TodoMVCState_setDisplayState_closure(this, state)); + }, + build$1(context) { + var t8, t9, t10, t11, t12, t13, dataId, _0_2, isActive, t14, t15, t16, _i, state, _this = this, _null = null, _s5_ = "none;", _s6_ = "block;", + _s10_ = "toggle-all", + t1 = type$.String, + t2 = B.LinkedHashMap_LinkedHashMap$_literal(["data-testid", "header"], t1, t1), + t3 = type$.JSArray_Component, + t4 = B._setArrayType([new A.DomComponent("h1", _null, _null, _null, _null, _null, _null, B._setArrayType([new A.Text("todos", _null)], t3), _null), A.div(B._setArrayType([new A.NewTodo(_this.get$addTodo(), _null)], t3), "input-container")], t3), + t5 = _this.todos, + t6 = B.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length === 0 ? _s5_ : _s6_], t1, t1), + t7 = _this.activeCount > 0 ? B.LinkedHashMap_LinkedHashMap$_empty(t1, t1) : B.LinkedHashMap_LinkedHashMap$_literal(["checked", ""], t1, t1); + t7 = A.input(B._setArrayType([], t3), t7, _s10_, _s10_, _null, new A.TodoMVCState_build_closure(_this), C.InputType_checkbox_checkbox, _null); + t8 = B.LinkedHashMap_LinkedHashMap$_literal(["for", "toggle-all"], t1, t1); + t8 = A.div(B._setArrayType([t7, A.label(B._setArrayType([new A.Text("Mark all as complete", _null)], t3), t8, "toggle-all-label")], t3), "toggle-all-container"); + t7 = B._setArrayType([], t3); + for (t9 = A.MapExtensions_get_keyValues(t5, type$.int, type$.Record_2_bool_isActive_and_String_todo), t10 = B._instanceType(t9), t9 = new B.MappedIterator(J.get$iterator$ax(t9.__internal$_iterable), t9._f, t10._eval$1("MappedIterator<1,2>")), t10 = t10._rest[1], t11 = type$.ValueKey_String; t9.moveNext$0();) { + t12 = {}; + t13 = t9.__internal$_current; + if (t13 == null) + t13 = t10._as(t13); + t12.dataId = null; + dataId = t13._0; + t12.dataId = dataId; + _0_2 = t13._1; + isActive = _0_2._0; + if (!(isActive && _this.displayState !== C.DisplayState_2)) + t13 = !isActive && _this.displayState !== C.DisplayState_1; + else + t13 = true; + if (t13) { + t13 = isActive ? "" : "completed"; + t14 = "" + dataId; + t15 = B.LinkedHashMap_LinkedHashMap$_literal(["data-id", t14], t1, t1); + t16 = isActive ? B.LinkedHashMap_LinkedHashMap$_empty(t1, t1) : B.LinkedHashMap_LinkedHashMap$_literal(["checked", ""], t1, t1); + t7.push(A.li(B._setArrayType([A.div(B._setArrayType([A.input(B._setArrayType([], t3), t16, "toggle", _null, new A.ValueKey(t14 + "-" + isActive, t11), new A.TodoMVCState_build_closure0(t12, _this), C.InputType_checkbox_checkbox, _null), A.label(B._setArrayType([new A.Text(_0_2._1, _null)], t3), _null, _null), A.button(B._setArrayType([], t3), "destroy", new A.TodoMVCState_build_closure1(t12, _this), _null)], t3), "view")], t3), t15, t13)); + } + } + t7 = B._setArrayType([t8, A.ul(t7, "todo-list")], t3); + t8 = B.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length === 0 ? _s5_ : _s6_], t1, t1); + t9 = B._setArrayType([new A.Text("" + _this.activeCount, _null)], t3); + t10 = _this.activeCount === 1 ? "" : "s"; + t10 = A.span(B._setArrayType([new A.DomComponent("strong", _null, _null, _null, _null, _null, _null, t9, _null), new A.Text(" item" + t10 + " left", _null)], t3), "todo-count", _null); + t9 = B._setArrayType([], t3); + for (t11 = [C.Record2_All_DisplayState_0, C.Record2_Active_DisplayState_1, C.Record2_Completed_DisplayState_2], t12 = type$.void_Function_JSObject, _i = 0; _i < 3; ++_i) { + t13 = {}; + t14 = t11[_i]; + t13.state = null; + state = t14._1; + t13.state = state; + t15 = _this.displayState === state ? "selected" : ""; + t13 = B.LinkedHashMap_LinkedHashMap$_literal(["click", new A.TodoMVCState_build_closure2(t13, _this)], t1, t12); + t9.push(A.li(B._setArrayType([A.span(B._setArrayType([new A.Text(t14._0, _null)], t3), t15, t13)], t3), _null, _null)); + } + t9 = A.ul(t9, "filters"); + t1 = B.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length - _this.activeCount === 0 ? _s5_ : _s6_], t1, t1); + return B._setArrayType([new A.DomComponent("section", "root", "todoapp", _null, _null, _null, _null, B._setArrayType([new A.DomComponent("header", _null, "header", _null, t2, _null, _null, t4, _null), new A.DomComponent("main", _null, "main", new A._RawStyles(t6), _null, _null, _null, t7, _null), new A.DomComponent("footer", _null, "footer", new A._RawStyles(t8), _null, _null, _null, B._setArrayType([t10, t9, A.button(B._setArrayType([new A.Text("Clear completed", _null)], t3), "clear-completed", _this.get$clearCompleted(), new A._RawStyles(t1))], t3), _null)], t3), _null)], t3); + } + }; + A.NewTodo.prototype = { + build$1(context) { + var t2, + t1 = type$.String; + t1 = B.LinkedHashMap_LinkedHashMap$_literal(["placeholder", "What needs to be done?"], t1, t1); + t2 = type$.JSArray_Component; + return B._setArrayType([A.input(B._setArrayType([], t2), t1, "new-todo", null, null, new A.NewTodo_build_closure(this), null, "")], t2); + } + }; + var typesOffset = hunkHelpers.updateTypes(["bool(InputType)", "~(String)", "~()", "Map({onChange:~(1^)?,onClick:~()?,onInput:~(0^)?})"]); + A.HashMap_HashMap$from_closure.prototype = { + call$2(k, v) { + this.result.$indexSet(0, this.K._as(k), this.V._as(v)); + }, + $signature: 32 + }; + A.events_closure.prototype = { + call$1(_) { + return this.onClick.call$0(); + }, + $signature: 3 + }; + A._callWithValue_closure.prototype = { + call$1(e) { + var t1, t2, t3, t4, + target = e.target; + $label1$1: { + t1 = type$.JSObject._is(target); + if (t1 && B.JSAnyUtilityExtension_instanceOfString(target, "HTMLInputElement")) { + t1 = new A._callWithValue__closure(target).call$0(); + break $label1$1; + } + if (t1 && B.JSAnyUtilityExtension_instanceOfString(target, "HTMLTextAreaElement")) { + t1 = target.value; + break $label1$1; + } + if (t1 && B.JSAnyUtilityExtension_instanceOfString(target, "HTMLSelectElement")) { + t1 = B._setArrayType([], type$.JSArray_String); + for (t2 = new B._SyncStarIterator(A._extension_0_toIterable(target.selectedOptions)._outerHelper()); t2.moveNext$0();) { + t3 = t2._async$_current; + t4 = B.JSAnyUtilityExtension_instanceOfString(t3, "HTMLOptionElement"); + if (t4) + t1.push(t3.value); + } + break $label1$1; + } + t1 = null; + break $label1$1; + } + this.fn.call$1(this.V._as(t1)); + }, + $signature: 3 + }; + A._callWithValue__closure.prototype = { + call$0() { + var t1 = this.target, + type = B.IterableExtensions_get_firstOrNull(new B.WhereIterable(C.List_T5C, new A._callWithValue___closure(t1), type$.WhereIterable_InputType)); + $label0$0: { + if (C.InputType_checkbox_checkbox === type || C.InputType_radio_radio === type) { + t1 = t1.checked; + break $label0$0; + } + if (C.InputType_number_number === type) { + t1 = t1.valueAsNumber; + break $label0$0; + } + if (C.InputType_date_date === type || C.InputType_Ip0 === type) { + t1 = t1.valueAsDate; + break $label0$0; + } + if (C.InputType_file_file === type) { + t1 = t1.files; + break $label0$0; + } + t1 = t1.value; + break $label0$0; + } + return t1; + }, + $signature: 33 + }; + A._callWithValue___closure.prototype = { + call$1(v) { + return v._name === this.target.type; + }, + $signature: typesOffset + 0 + }; + A.TodoMVCState_addTodo_closure.prototype = { + call$0() { + var t1 = this.$this; + t1.todos.$indexSet(0, ++t1.dataIdCount, new B._Record_2_isActive_todo(true, this.todo)); + ++t1.activeCount; + }, + $signature: 0 + }; + A.TodoMVCState_toggle_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1.todos, + t3 = this.i, + _0_0 = t2.$index(0, t3), + isActive = _0_0._0; + t2.$indexSet(0, t3, new B._Record_2_isActive_todo(!isActive, _0_0._1)); + t2 = t1.activeCount; + if (isActive) + t1.activeCount = t2 - 1; + else + t1.activeCount = t2 + 1; + }, + $signature: 0 + }; + A.TodoMVCState_toggleAll_closure.prototype = { + call$0() { + var t1, t2, t3, t4, todo; + for (t1 = this.$this, t2 = t1.todos, t3 = new B.LinkedHashMapKeyIterator(t2, t2._modifications, t2._first); t3.moveNext$0();) { + t4 = t3.__js_helper$_current; + todo = t2.$index(0, t4)._1; + t2.$indexSet(0, t4, new B._Record_2_isActive_todo(t1.activeCount === 0, todo)); + } + t1.activeCount = t1.activeCount === 0 ? t2.__js_helper$_length : 0; + }, + $signature: 0 + }; + A.TodoMVCState_destroy_closure.prototype = { + call$0() { + var t1 = this.$this; + if (t1.todos.remove$1(0, this.i)._0) + --t1.activeCount; + }, + $signature: 0 + }; + A.TodoMVCState_clearCompleted_closure.prototype = { + call$0() { + this.$this.todos.removeWhere$1(0, new A.TodoMVCState_clearCompleted__closure()); + }, + $signature: 0 + }; + A.TodoMVCState_clearCompleted__closure.prototype = { + call$2(dataId, todo) { + return !todo._0; + }, + $signature: 34 + }; + A.TodoMVCState_setDisplayState_closure.prototype = { + call$0() { + this.$this.displayState = this.state; + }, + $signature: 0 + }; + A.TodoMVCState_build_closure.prototype = { + call$1(_) { + return this.$this.toggleAll$0(); + }, + $signature: 2 + }; + A.TodoMVCState_build_closure0.prototype = { + call$1(_) { + return this.$this.toggle$1(this._box_0.dataId); + }, + $signature: 2 + }; + A.TodoMVCState_build_closure1.prototype = { + call$0() { + return this.$this.destroy$1(this._box_0.dataId); + }, + $signature: 0 + }; + A.TodoMVCState_build_closure2.prototype = { + call$1(_) { + return this.$this.setDisplayState$1(this._box_1.state); + }, + $signature: 3 + }; + A.NewTodo_build_closure.prototype = { + call$1(str) { + return this.$this.handler.call$1(B._asString(str)); + }, + $signature: 2 + }; + A.MapExtensions_get_keyValues_closure.prototype = { + call$1(entry) { + return new B._Record_2(entry.key, entry.value); + }, + $signature() { + return this.K._eval$1("@<0>")._bind$1(this.V)._eval$1("+(1,2)(MapEntry<1,2>)"); + } + }; + (function aliases() { + var _ = A.BuildableElement.prototype; + _.super$BuildableElement$didMount = _.didMount$0; + _.super$BuildableElement$performRebuild = _.performRebuild$0; + _ = A.LeafElement.prototype; + _.super$LeafElement$didMount = _.didMount$0; + })(); + (function installTearOffs() { + var _static = hunkHelpers.installStaticTearOff, + _instance_1_u = hunkHelpers._instance_1u, + _instance_0_u = hunkHelpers._instance_0u; + _static(A, "events__events$closure", 0, null, ["call$2$3$onChange$onClick$onInput", "call$0", "call$2$0", "call$2$1$onClick", "call$2$2$onChange$onInput"], ["events", function() { + var t1 = type$.dynamic; + return A.events(null, null, null, t1, t1); + }, function(V1, V2) { + return A.events(null, null, null, V1, V2); + }, function(onClick, V1, V2) { + return A.events(null, onClick, null, V1, V2); + }, function(onChange, onInput, V1, V2) { + return A.events(onChange, null, onInput, V1, V2); + }], 3, 0); + var _; + _instance_1_u(_ = A.TodoMVCState.prototype, "get$addTodo", "addTodo$1", 1); + _instance_0_u(_, "get$clearCompleted", "clearCompleted$0", 2); + })(); + (function inheritance() { + var _mixin = hunkHelpers.mixin, + _mixinHard = hunkHelpers.mixinHard, + _inherit = hunkHelpers.inherit, + _inheritMany = hunkHelpers.inheritMany; + _inherit(A._HashMap, B.MapBase); + _inherit(A._HashMapKeyIterable, B.EfficientLengthIterable); + _inheritMany(B.Object, [A._HashMapKeyIterator, A._Styles_Object_StylesMixin, A.StylesMixin, A.Key, A.State]); + _inheritMany(B.Closure2Args, [A.HashMap_HashMap$from_closure, A.TodoMVCState_clearCompleted__closure]); + _inheritMany(B._Enum, [A.InputType, A.DisplayState]); + _inheritMany(B.Closure, [A.events_closure, A._callWithValue_closure, A._callWithValue___closure, A.TodoMVCState_build_closure, A.TodoMVCState_build_closure0, A.TodoMVCState_build_closure2, A.NewTodo_build_closure, A.MapExtensions_get_keyValues_closure]); + _inheritMany(B.Closure0Args, [A._callWithValue__closure, A.TodoMVCState_addTodo_closure, A.TodoMVCState_toggle_closure, A.TodoMVCState_toggleAll_closure, A.TodoMVCState_destroy_closure, A.TodoMVCState_clearCompleted_closure, A.TodoMVCState_setDisplayState_closure, A.TodoMVCState_build_closure1]); + _inherit(A.Styles, A._Styles_Object_StylesMixin); + _inherit(A._RawStyles, A.Styles); + _inheritMany(B.Element, [A.BuildableElement, A.LeafElement]); + _inherit(A.DomComponent, B.ProxyComponent); + _inherit(A.DomElement, B.ProxyRenderObjectElement); + _inheritMany(B.Component, [A.Text, A.StatefulComponent, A.StatelessComponent]); + _inherit(A.LeafRenderObjectElement, A.LeafElement); + _inherit(A.TextElement, A.LeafRenderObjectElement); + _inherit(A.LocalKey, A.Key); + _inherit(A.ValueKey, A.LocalKey); + _inheritMany(A.BuildableElement, [A.StatefulElement, A.StatelessElement]); + _inherit(A.TodoMVC, A.StatefulComponent); + _inherit(A.TodoMVCState, A.State); + _inherit(A.NewTodo, A.StatelessComponent); + _mixin(A._Styles_Object_StylesMixin, A.StylesMixin); + _mixinHard(A.LeafRenderObjectElement, B.RenderObjectElement); + })(); + B._Universe_addRules(init.typeUniverse, JSON.parse('{"_HashMap":{"MapBase":["1","2"],"Map":["1","2"],"MapBase.V":"2","MapBase.K":"1"},"_HashMapKeyIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"_WrappingDomComponent":{"DomComponent":[],"ProxyComponent":[],"Component":[]},"BuildableElement":{"Element":[]},"DomComponent":{"ProxyComponent":[],"Component":[]},"DomElement":{"RenderObjectElement":[],"Element":[]},"Text":{"Component":[]},"TextElement":{"RenderObjectElement":[],"Element":[]},"LeafElement":{"Element":[]},"LeafRenderObjectElement":{"RenderObjectElement":[],"Element":[]},"StatefulComponent":{"Component":[]},"StatefulElement":{"Element":[]},"StatelessComponent":{"Component":[]},"StatelessElement":{"Element":[]},"TodoMVC":{"Component":[]},"NewTodo":{"StatelessComponent":[],"Component":[]}}')); + B._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"StylesMixin":1,"State":1}')); + var type$ = (function rtii() { + var findType = B.findType; + return { + DomComponent: findType("DomComponent"), + Element: findType("Element"), + InheritedElement: findType("InheritedElement"), + JSArray_Component: findType("JSArray"), + JSArray_Element: findType("JSArray"), + JSArray_JSObject: findType("JSArray"), + JSArray_String: findType("JSArray"), + JSObject: findType("JSObject"), + Record_2_bool_isActive_and_String_todo: findType("+isActive,todo(bool,String)"), + StatelessComponent: findType("StatelessComponent"), + String: findType("String"), + Text: findType("Text"), + Type: findType("Type"), + ValueKey_String: findType("ValueKey"), + WhereIterable_InputType: findType("WhereIterable"), + _SyncStarIterable_JSObject: findType("_SyncStarIterable"), + dynamic: findType("@"), + int: findType("int"), + void_Function_JSObject: findType("~(JSObject)") + }; + })(); + (function constants() { + var makeConstList = hunkHelpers.makeConstList; + C.DisplayState_0 = new A.DisplayState("all"); + C.DisplayState_1 = new A.DisplayState("active"); + C.DisplayState_2 = new A.DisplayState("completed"); + C.InputType_Ip0 = new A.InputType("datetime-local", "dateTimeLocal"); + C.InputType_checkbox_checkbox = new A.InputType("checkbox", "checkbox"); + C.InputType_date_date = new A.InputType("date", "date"); + C.InputType_file_file = new A.InputType("file", "file"); + C.InputType_number_number = new A.InputType("number", "number"); + C.InputType_radio_radio = new A.InputType("radio", "radio"); + C.InputType_button_button = new A.InputType("button", "button"); + C.InputType_color_color = new A.InputType("color", "color"); + C.InputType_email_email = new A.InputType("email", "email"); + C.InputType_hidden_hidden = new A.InputType("hidden", "hidden"); + C.InputType_image_image = new A.InputType("image", "image"); + C.InputType_month_month = new A.InputType("month", "month"); + C.InputType_password_password = new A.InputType("password", "password"); + C.InputType_range_range = new A.InputType("range", "range"); + C.InputType_reset_reset = new A.InputType("reset", "reset"); + C.InputType_search_search = new A.InputType("search", "search"); + C.InputType_submit_submit = new A.InputType("submit", "submit"); + C.InputType_tel_tel = new A.InputType("tel", "tel"); + C.InputType_text_text = new A.InputType("text", "text"); + C.InputType_time_time = new A.InputType("time", "time"); + C.InputType_url_url = new A.InputType("url", "url"); + C.InputType_week_week = new A.InputType("week", "week"); + C.List_T5C = B._setArrayType(makeConstList([C.InputType_button_button, C.InputType_checkbox_checkbox, C.InputType_color_color, C.InputType_date_date, C.InputType_Ip0, C.InputType_email_email, C.InputType_file_file, C.InputType_hidden_hidden, C.InputType_image_image, C.InputType_month_month, C.InputType_number_number, C.InputType_password_password, C.InputType_radio_radio, C.InputType_range_range, C.InputType_reset_reset, C.InputType_search_search, C.InputType_submit_submit, C.InputType_tel_tel, C.InputType_text_text, C.InputType_time_time, C.InputType_url_url, C.InputType_week_week]), B.findType("JSArray")); + C.Record2_Active_DisplayState_1 = new B._Record_2("Active", C.DisplayState_1); + C.Record2_All_DisplayState_0 = new B._Record_2("All", C.DisplayState_0); + C.Record2_Completed_DisplayState_2 = new B._Record_2("Completed", C.DisplayState_2); + C.Type_String_AXU = B.typeLiteral("String"); + C.Type__WrappingDomComponent_kh6 = B.typeLiteral("_WrappingDomComponent"); + })(); +}; +; +((d, h) => { + d[h] = d.current; + d.eventLog.push({p: "main.clients.dart.js_1", e: "endPart", h: h}); +})($__dart_deferred_initializers__, "B7DERL8wi+bmR2ZOLSPQSArwk/c="); +; +//# sourceMappingURL=main.clients.dart.js_1.part.js.map diff --git a/resources/todomvc/dart2js-jaspr/main.dart.js b/resources/todomvc/dart2js-jaspr/main.dart.js new file mode 100644 index 000000000..e545915c8 --- /dev/null +++ b/resources/todomvc/dart2js-jaspr/main.dart.js @@ -0,0 +1,9559 @@ +// Generated by dart2js (, trust primitives, omit checks, lax runtime type, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.8.0-edge.4c8aedcb57fe678e6d30acfdc021aa9888576638. +// 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 an arbitrary argument +// string forwarded from the 'dart2js:load-priority' pragma option. +// 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 an +// arbitrary argument string forwarded from the 'dart2js:load-priority' +// pragma option. +// +// 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.$flags = 7; + 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) { + var t1 = A._setArrayType(allocation, $E._eval$1("JSArray<0>")); + t1.$flags = 1; + return t1; + }, + JSArray__compareAny(a, b) { + return J.compareTo$1$ns(a, b); + }, + 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$ns(receiver) { + if (typeof receiver == "number") + return J.JSNumber.prototype; + 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$isEmpty$asx(receiver) { + return J.getInterceptor$asx(receiver).get$isEmpty(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); + }, + $index$ax(receiver, a0) { + if (typeof a0 === "number") + if (Array.isArray(receiver) || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) + if (a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0]; + return J.getInterceptor$ax(receiver).$index(receiver, a0); + }, + $indexSet$ax(receiver, a0, a1) { + if (typeof a0 === "number") + if ((Array.isArray(receiver) || A.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) && !(receiver.$flags & 2) && a0 >>> 0 === a0 && a0 < receiver.length) + return receiver[a0] = a1; + return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); + }, + add$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).add$1(receiver, a0); + }, + compareTo$1$ns(receiver, a0) { + return J.getInterceptor$ns(receiver).compareTo$1(receiver, a0); + }, + elementAt$1$ax(receiver, a0) { + return J.getInterceptor$ax(receiver).elementAt$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() { + }, + LateError$fieldNI(fieldName) { + return new A.LateError("Field '" + fieldName + "' has not been initialized."); + }, + LateError$localNI(localName) { + return new A.LateError("Local '" + localName + "' has not been initialized."); + }, + SystemHash_combine(hash, value) { + hash = hash + value & 536870911; + hash = hash + ((hash & 524287) << 10) & 536870911; + return hash ^ hash >>> 6; + }, + SystemHash_finish(hash) { + hash = hash + ((hash & 67108863) << 3) & 536870911; + hash ^= hash >>> 11; + return hash + ((hash & 16383) << 15) & 536870911; + }, + 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; + }, + MappedIterable_MappedIterable(iterable, $function, $S, $T) { + if (type$.EfficientLengthIterable_dynamic._is(iterable)) + return new A.EfficientLengthMappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("EfficientLengthMappedIterable<1,2>")); + return new A.MappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("MappedIterable<1,2>")); + }, + _CastIterableBase: function _CastIterableBase() { + }, + CastIterator: function CastIterator(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + _CastListBase: function _CastListBase() { + }, + CastList: function CastList(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + LateError: function LateError(t0) { + this._message = t0; + }, + SentinelValue: function SentinelValue() { + }, + 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; + }, + MappedIterable: function MappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + EfficientLengthMappedIterable: function EfficientLengthMappedIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + MappedIterator: function MappedIterator(t0, t1, t2) { + var _ = this; + _.__internal$_current = null; + _._iterator = t0; + _._f = t1; + _.$ti = t2; + }, + WhereIterable: function WhereIterable(t0, t1, t2) { + this.__internal$_iterable = t0; + this._f = t1; + this.$ti = t2; + }, + WhereIterator: function WhereIterator(t0, t1) { + this._iterator = t0; + this._f = t1; + }, + FixedLengthListMixin: function FixedLengthListMixin() { + }, + ReversedListIterable: function ReversedListIterable(t0, t1) { + this._source = t0; + this.$ti = t1; + }, + __CastListBase__CastIterableBase_ListMixin: function __CastListBase__CastIterableBase_ListMixin() { + }, + 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_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 (object == null || 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); + if (object instanceof A._Record) + return object._toString$1(true); + return "Instance of '" + A.Primitives_objectTypeName(object) + "'"; + }, + Primitives_extractStackTrace(error) { + var jsError = error.$thrownJsError; + if (jsError == null) + return null; + return A.getTraceFromException(jsError); + }, + diagnoseIndexError(indexable, index) { + var $length, _s5_ = "index"; + if (!A._isInt(index)) + return new A.ArgumentError(true, index, _s5_, null); + $length = J.get$length$asx(indexable); + if (index < 0 || index >= $length) + return A.IndexError$withLength(index, $length, indexable, _s5_); + return new A.RangeError(null, null, true, index, _s5_, "Value not in range"); + }, + wrapException(ex) { + return A.initializeExceptionWrapper(ex, new Error()); + }, + initializeExceptionWrapper(ex, wrapper) { + 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, wrapper) { + throw A.initializeExceptionWrapper(ex, wrapper == null ? new Error() : wrapper); + }, + throwUnsupportedOperation(o, operation, verb) { + var wrapper; + if (operation == null) + operation = 0; + if (verb == null) + verb = 0; + wrapper = Error(); + A.throwExpression(A._diagnoseUnsupportedOperation(o, operation, verb), wrapper); + }, + _diagnoseUnsupportedOperation(o, encodedOperation, encodedVerb) { + var operation, table, tableLength, index, verb, object, flags, article, adjective; + if (typeof encodedOperation == "string") + operation = encodedOperation; + else { + table = "[]=;add;removeWhere;retainWhere;removeRange;setRange;setInt8;setInt16;setInt32;setUint8;setUint16;setUint32;setFloat32;setFloat64".split(";"); + tableLength = table.length; + index = encodedOperation; + if (index > tableLength) { + encodedVerb = index / tableLength | 0; + index %= tableLength; + } + operation = table[index]; + } + verb = typeof encodedVerb == "string" ? encodedVerb : "modify;remove from;add to".split(";")[encodedVerb]; + object = type$.List_dynamic._is(o) ? "list" : "ByteData"; + flags = o.$flags | 0; + article = "a "; + if ((flags & 4) !== 0) + adjective = "constant "; + else if ((flags & 2) !== 0) { + adjective = "unmodifiable "; + article = "an "; + } else + adjective = (flags & 1) !== 0 ? "fixed-length " : ""; + return new A.UnsupportedError("'" + operation + "': Cannot " + verb + " " + article + adjective + object); + }, + 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) { + if (ex == null) + return new A.NullThrownFromJavaScriptException(ex); + if (ex instanceof A.ExceptionAndStackTrace) + return A.saveStackTrace(ex, ex.dartException); + 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$(message, match)); + else { + match = notClosure.matchTypeError$1(message); + if (match != null) { + match.method = "call"; + return A.saveStackTrace(ex, A.JsNoSuchMethodError$(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) + 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); + }, + fillLiteralMap(keyValuePairs, result) { + var index, index0, index1, + $length = keyValuePairs.length; + for (index = 0; index < $length; index = index1) { + index0 = index + 1; + index1 = index0 + 1; + result.$indexSet(0, keyValuePairs[index], keyValuePairs[index0]); + } + return result; + }, + _invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) { + switch (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 names, i, $name, + template = new A.BoundClosure("receiver", "interceptor"), + t1 = Object.getOwnPropertyNames(template); + t1.$flags = 1; + names = t1; + 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 = $.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 = $.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; + }, + _Record_2: function _Record_2(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + _Record_2_isActive_todo: function _Record_2_isActive_todo(t0, t1) { + this._0 = t0; + this._1 = t1; + }, + ConstantMap: function ConstantMap() { + }, + ConstantStringMap: function ConstantStringMap(t0, t1, t2) { + this._jsIndex = t0; + this._values = t1; + this.$ti = t2; + }, + _KeysOrValues: function _KeysOrValues(t0, t1) { + this.__js_helper$_elements = t0; + this.$ti = t1; + }, + _KeysOrValuesOrElementsIterator: function _KeysOrValuesOrElementsIterator(t0, t1, t2) { + var _ = this; + _.__js_helper$_elements = t0; + _.__js_helper$_length = t1; + _.__js_helper$_index = 0; + _.__js_helper$_current = null; + _.$ti = 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; + }, + JsLinkedHashMap: function JsLinkedHashMap(t0) { + var _ = this; + _.__js_helper$_length = 0; + _._last = _._first = _.__js_helper$_rest = _.__js_helper$_nums = _.__js_helper$_strings = null; + _._modifications = 0; + _.$ti = t0; + }, + JsLinkedHashMap_addAll_closure: function JsLinkedHashMap_addAll_closure(t0) { + this.$this = t0; + }, + LinkedHashMapCell: function LinkedHashMapCell(t0, t1) { + var _ = this; + _.hashMapCellKey = t0; + _.hashMapCellValue = t1; + _._previous = _._next = null; + }, + LinkedHashMapKeysIterable: function LinkedHashMapKeysIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + LinkedHashMapKeyIterator: function LinkedHashMapKeyIterator(t0, t1, t2) { + var _ = this; + _._map = t0; + _._modifications = t1; + _._cell = t2; + _.__js_helper$_current = null; + }, + LinkedHashMapEntriesIterable: function LinkedHashMapEntriesIterable(t0, t1) { + this._map = t0; + this.$ti = t1; + }, + LinkedHashMapEntryIterator: function LinkedHashMapEntryIterator(t0, t1, t2, t3) { + var _ = this; + _._map = t0; + _._modifications = t1; + _._cell = t2; + _.__js_helper$_current = null; + _.$ti = t3; + }, + 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; + }, + _Record: function _Record() { + }, + _Record2: function _Record2() { + }, + throwLateFieldADI(fieldName) { + throw A.initializeExceptionWrapper(new A.LateError("Field '" + fieldName + "' has been assigned during initialization."), new Error()); + }, + throwUnnamedLateFieldNI() { + throw A.initializeExceptionWrapper(A.LateError$fieldNI(""), new Error()); + }, + _Cell$() { + var t1 = new A._Cell(); + return t1._value = t1; + }, + _Cell: function _Cell() { + this._value = null; + }, + _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; + if (object instanceof A._Record) + return object._getRti$0(); + 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; + }, + evaluateRtiForRecord(recordRecipe, valuesList) { + var bindings, i, + values = valuesList, + $length = values.length; + if ($length === 0) + return type$.Record_0; + bindings = A._Universe_evalInEnvironment(init.typeUniverse, A._structuralTypeOf(values[0]), "@<0>"); + for (i = 1; i < $length; ++i) + bindings = A._Universe_bind(init.typeUniverse, bindings, A._structuralTypeOf(values[i])); + return A._Universe_evalInEnvironment(init.typeUniverse, bindings, recordRecipe); + }, + 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; + } + if (testRti === type$.int) + asFn = A._asInt; + else if (testRti === type$.nullable_int) + asFn = A._asIntQ; + else if (testRti === type$.String) + asFn = A._asString; + else if (testRti === type$.nullable_String) + asFn = A._asStringQ; + else if (testRti === type$.bool) + asFn = A._asBool; + else if (testRti === type$.nullable_bool) + asFn = A._asBoolQ; + else if (testRti === type$.num) + asFn = A._asNum; + else if (testRti === type$.nullable_num) + asFn = A._asNumQ; + else if (testRti === type$.double) + asFn = A._asDouble; + else if (testRti === type$.nullable_double) + asFn = A._asDoubleQ; + testRti._as = asFn; + return testRti._as(object); + }, + _nullIs(testRti) { + var kind = testRti._kind, + t1 = true; + 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; + 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; + throw A.initializeExceptionWrapper(A._errorForAsCheck(object, testRti), new Error()); + }, + _generalNullableAsCheckImplementation(object) { + var testRti = this; + if (object == null) + return object; + else if (testRti._is(object)) + return object; + throw A.initializeExceptionWrapper(A._errorForAsCheck(object, testRti), new Error()); + }, + _errorForAsCheck(object, testRti) { + return new A._TypeError("TypeError: " + 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__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.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "Object"), new Error()); + }, + _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.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool"), new Error()); + }, + _asBoolS(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool"), new Error()); + }, + _asBoolQ(object) { + if (true === object) + return true; + if (false === object) + return false; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "bool?"), new Error()); + }, + _asDouble(object) { + if (typeof object == "number") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double"), new Error()); + }, + _asDoubleS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double"), new Error()); + }, + _asDoubleQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "double?"), new Error()); + }, + _isInt(object) { + return typeof object == "number" && Math.floor(object) === object; + }, + _asInt(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int"), new Error()); + }, + _asIntS(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int"), new Error()); + }, + _asIntQ(object) { + if (typeof object == "number" && Math.floor(object) === object) + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "int?"), new Error()); + }, + _isNum(object) { + return typeof object == "number"; + }, + _asNum(object) { + if (typeof object == "number") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num"), new Error()); + }, + _asNumS(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num"), new Error()); + }, + _asNumQ(object) { + if (typeof object == "number") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "num?"), new Error()); + }, + _isString(object) { + return typeof object == "string"; + }, + _asString(object) { + if (typeof object == "string") + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String"), new Error()); + }, + _asStringS(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String"), new Error()); + }, + _asStringQ(object) { + if (typeof object == "string") + return object; + if (object == null) + return object; + throw A.initializeExceptionWrapper(A._TypeError__TypeError$forType(object, "String?"), new Error()); + }, + _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, offset, i, t1, t2, typeParametersText, typeSep, boundRti, kind, t3, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ", outerContextLength = null; + if (bounds != null) { + boundsLength = bounds.length; + if (genericContext == null) + genericContext = A._setArrayType([], type$.JSArray_String); + else + outerContextLength = genericContext.length; + offset = genericContext.length; + for (i = boundsLength; i > 0; --i) + genericContext.push("T" + (offset + i)); + for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) { + typeParametersText = typeParametersText + typeSep + genericContext[genericContext.length - 1 - i]; + 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 = ""; + 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, + 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; + return genericContext[genericContext.length - 1 - 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; + t1 = true; + if (!A.isSoundTopType(baseType)) + if (!(baseType === type$.Null || baseType === type$.JSNull)) + if (baseKind !== 7) + t1 = baseKind === 8 && A.isNullable(baseType._primary); + 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 requiredPositional, returnType, parameters, + t1 = parser.u, + head = stack.pop(), + optionalPositional = null, named = null; + if (typeof head == "number") + switch (head) { + case -1: + optionalPositional = stack.pop(); + break; + case -2: + named = stack.pop(); + break; + default: + stack.push(head); + break; + } + else + stack.push(head); + 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 kind = t._kind, + t1 = true; + 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); + 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 t1, div, span; + if (self.scheduleImmediate != null) + return A.async__AsyncRun__scheduleImmediateJsOverride$closure(); + if (self.MutationObserver != null && self.document != null) { + t1 = {}; + 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(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithSetImmediate(callback) { + self.setImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(callback), 0)); + }, + _AsyncRun__scheduleImmediateWithTimer(callback) { + A._TimerImpl$(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) { + var t1, + value = object == null ? completer.$ti._precomputed1._as(object) : object; + if (!completer.isSync) + completer._future._asyncComplete$1(value); + else { + t1 = completer._future; + if (completer.$ti._eval$1("Future<1>")._is(value)) + t1._chainFuture$1(value); + else + t1._completeWithValue$1(value); + } + }, + _asyncRethrow(object, completer) { + var t1 = A.unwrapException(object), + st = A.getTraceFromException(object), + t2 = completer._future; + if (completer.isSync) + t2._completeErrorObject$1(new A.AsyncError(t1, st)); + else + t2._asyncCompleteErrorObject$1(new A.AsyncError(t1, st)); + }, + _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$1(new A._wrapJsFunctionForAsync_closure($protected)); + }, + _SyncStarIterator__terminatedBody(_1, _2, _3) { + return 0; + }, + AsyncError_defaultStackTrace(error) { + var stackTrace; + if (type$.Error._is(error)) { + stackTrace = error.get$stackTrace(); + if (stackTrace != null) + return stackTrace; + } + return B.C__StringStackTrace; + }, + _Future__chainCoreFuture(source, target, sync) { + var t2, ignoreError, listeners, _box_0 = {}, + t1 = _box_0.source = source; + for (; t2 = t1._state, (t2 & 4) !== 0;) { + t1 = t1._resultOrListeners; + _box_0.source = t1; + } + if (t1 === target) { + t2 = A.StackTrace_current(); + target._asyncCompleteErrorObject$1(new A.AsyncError(new A.ArgumentError(true, t1, null, "Cannot complete a future with itself"), t2)); + return; + } + ignoreError = target._state & 1; + t2 = t1._state = t2 | ignoreError; + if ((t2 & 24) === 0) { + listeners = target._resultOrListeners; + target._state = target._state & 1 | 4; + target._resultOrListeners = t1; + t1._prependListeners$1(listeners); + return; + } + if (!sync) + if (target._resultOrListeners == null) + t1 = (t2 & 16) === 0 || ignoreError !== 0; + else + t1 = false; + else + t1 = true; + if (t1) { + listeners = target._removeListeners$0(); + target._cloneResult$1(_box_0.source); + A._Future__propagateToListeners(target, listeners); + return; + } + target._state ^= 2; + A._rootScheduleMicrotask(null, null, target._zone, new A._Future__chainCoreFuture_closure(_box_0, target)); + }, + _Future__propagateToListeners(source, listeners) { + var _box_0, t2, t3, hasError, nextListener, nextListener0, sourceResult, t4, zone, oldZone, result, current, _box_1 = {}, + t1 = _box_1.source = source; + for (; true;) { + _box_0 = {}; + t2 = t1._state; + t3 = (t2 & 16) === 0; + hasError = !t3; + if (listeners == null) { + if (hasError && (t2 & 1) === 0) { + t1 = t1._resultOrListeners; + A._rootHandleError(t1.error, t1.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; + } + t2 = _box_1.source; + sourceResult = t2._resultOrListeners; + _box_0.listenerHasError = hasError; + _box_0.listenerValueOrError = sourceResult; + if (t3) { + t4 = t1.state; + t4 = (t4 & 1) !== 0 || (t4 & 15) === 8; + } else + t4 = true; + if (t4) { + zone = t1.result._zone; + if (hasError) { + t2 = t2._zone === zone; + t2 = !(t2 || t2); + } else + t2 = false; + if (t2) { + 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 (t3) { + 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) { + t2 = _box_0.listener.$ti; + t2 = t2._eval$1("Future<2>")._is(t1) || !t2._rest[1]._is(t1); + } else + t2 = false; + if (t2) { + result = _box_0.listener.result; + if ((t1._state & 24) !== 0) { + current = 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__chainCoreFuture(t1, result, true); + return; + } + } + result = _box_0.listener.result; + current = result._resultOrListeners; + result._resultOrListeners = null; + listeners = result._reverseListeners$1(current); + t1 = _box_0.listenerHasError; + t2 = _box_0.listenerValueOrError; + if (!t1) { + result._state = 8; + result._resultOrListeners = t2; + } else { + result._state = result._state & 1 | 16; + result._resultOrListeners = t2; + } + _box_1.source = result; + t1 = result; + } + }, + _registerErrorHandler(errorHandler, zone) { + if (type$.dynamic_Function_Object_StackTrace._is(errorHandler)) + return zone.registerBinaryCallback$1(errorHandler); + if (type$.dynamic_Function_Object._is(errorHandler)) + return 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, currentZone.bindCallbackGuarded$1(callback)); + }, + StreamIterator_StreamIterator(stream) { + A.checkNotNullable(stream, "stream", type$.Object); + return new A._StreamIterator(); + }, + _rootHandleError(error, stackTrace) { + A._schedulePriorityAsyncCallback(new A._rootHandleError_closure(error, stackTrace)); + }, + _rootRun($self, $parent, zone, f) { + 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) { + 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) { + 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) { + 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() { + }, + _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; + }, + _SyncStarIterator: function _SyncStarIterator(t0) { + var _ = this; + _._body = t0; + _._suspendedBodies = _._nestedIterator = _._datum = _._async$_current = null; + }, + _SyncStarIterable: function _SyncStarIterable(t0, t1) { + this._outerHelper = t0; + this.$ti = t1; + }, + AsyncError: function AsyncError(t0, t1) { + this.error = t0; + this.stackTrace = 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__chainCoreFuture_closure: function _Future__chainCoreFuture_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__asyncCompleteErrorObject_closure: function _Future__asyncCompleteErrorObject_closure(t0, t1) { + this.$this = t0; + this.error = t1; + }, + _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, t1) { + this.joinedResult = t0; + this.originalSource = t1; + }, + _Future__propagateToListeners_handleWhenCompleteCallback_closure0: function _Future__propagateToListeners_handleWhenCompleteCallback_closure0(t0) { + this.joinedResult = 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; + }, + _StreamIterator: function _StreamIterator() { + }, + _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_HashMap($K, $V) { + return new A._HashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("_HashMap<1,2>")); + }, + _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, "", table); + delete table[""]; + return table; + }, + LinkedHashMap_LinkedHashMap($K, $V) { + return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + LinkedHashMap_LinkedHashMap$_literal(keyValuePairs, $K, $V) { + return A.fillLiteralMap(keyValuePairs, new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>"))); + }, + LinkedHashMap_LinkedHashMap$_empty($K, $V) { + return new A.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>")); + }, + HashSet_HashSet($E) { + return new A._HashSet($E._eval$1("_HashSet<0>")); + }, + _HashSet__newHashTable() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + }, + LinkedHashSet_LinkedHashSet($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + LinkedHashSet_LinkedHashSet$_empty($E) { + return new A._LinkedHashSet($E._eval$1("_LinkedHashSet<0>")); + }, + _LinkedHashSet__newHashTable() { + var table = Object.create(null); + table[""] = table; + delete table[""]; + return table; + }, + _LinkedHashSetIterator$(_set, _modifications, $E) { + var t1 = new A._LinkedHashSetIterator(_set, _modifications, $E._eval$1("_LinkedHashSetIterator<0>")); + t1._collection$_cell = _set._collection$_first; + return t1; + }, + HashMap_HashMap$from(other, $K, $V) { + var result = A.HashMap_HashMap($K, $V); + other.forEach$1(0, new A.HashMap_HashMap$from_closure(result, $K, $V)); + return result; + }, + IterableExtensions_get_firstOrNull(_this) { + var iterator = J.get$iterator$ax(_this); + if (iterator.moveNext$0()) + return iterator.get$current(); + return null; + }, + LinkedHashMap_LinkedHashMap$of(other, $K, $V) { + var t1 = A.LinkedHashMap_LinkedHashMap($K, $V); + t1.addAll$1(0, other); + return t1; + }, + MapBase_mapToString(m) { + var result, t1; + if (A.isToStringVisiting(m)) + return "{...}"; + result = new A.StringBuffer(""); + try { + t1 = {}; + $.toStringVisiting.push(m); + result._contents += "{"; + t1.first = true; + m.forEach$1(0, new A.MapBase_mapToString_closure(t1, result)); + result._contents += "}"; + } finally { + $.toStringVisiting.pop(); + } + t1 = result._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _HashMap: function _HashMap(t0) { + var _ = this; + _._collection$_length = 0; + _._collection$_keys = _._collection$_rest = _._nums = _._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; + }, + _HashSet: function _HashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._elements = _._collection$_rest = _._nums = _._strings = null; + _.$ti = t0; + }, + _HashSetIterator: function _HashSetIterator(t0, t1, t2) { + var _ = this; + _._set = t0; + _._elements = t1; + _._offset = 0; + _._collection$_current = null; + _.$ti = t2; + }, + _LinkedHashSet: function _LinkedHashSet(t0) { + var _ = this; + _._collection$_length = 0; + _._collection$_last = _._collection$_first = _._collection$_rest = _._nums = _._strings = null; + _._collection$_modifications = 0; + _.$ti = t0; + }, + _LinkedHashSetCell: function _LinkedHashSetCell(t0) { + this._element = t0; + this._collection$_previous = this._collection$_next = null; + }, + _LinkedHashSetIterator: function _LinkedHashSetIterator(t0, t1, t2) { + var _ = this; + _._set = t0; + _._collection$_modifications = t1; + _._collection$_current = _._collection$_cell = null; + _.$ti = t2; + }, + HashMap_HashMap$from_closure: function HashMap_HashMap$from_closure(t0, t1, t2) { + this.result = t0; + this.K = t1; + this.V = t2; + }, + ListBase: function ListBase() { + }, + MapBase: function MapBase() { + }, + MapBase_entries_closure: function MapBase_entries_closure(t0) { + this.$this = t0; + }, + MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) { + this._box_0 = t0; + this.result = t1; + }, + SetBase: function SetBase() { + }, + _SetBase: function _SetBase() { + }, + Error__throw(error, stackTrace) { + error = A.initializeExceptionWrapper(error, new Error()); + error.stack = stackTrace.toString$0(0); + throw error; + }, + 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$from(elements, growable, $E) { + var t1, _i, + list = A._setArrayType([], $E._eval$1("JSArray<0>")); + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + list.push(elements[_i]); + list.$flags = 1; + return list; + }, + 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();) + list.push(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; + }, + StackTrace_current() { + return A.getTraceFromException(new Error()); + }, + 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); + }, + RangeError$range(invalidValue, minValue, maxValue, $name, message) { + return new A.RangeError(minValue, maxValue, true, invalidValue, $name, "Invalid value"); + }, + RangeError_checkNotNegative(value, $name) { + return value; + }, + IndexError$withLength(invalidValue, $length, indexable, $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); + }, + 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); + $.toStringVisiting.push(iterable); + try { + A._iterablePartsToStrings(iterable, parts); + } finally { + $.toStringVisiting.pop(); + } + t1 = A.StringBuffer__writeAll(leftDelimiter, 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); + $.toStringVisiting.push(iterable); + try { + t1 = buffer; + t1._contents = A.StringBuffer__writeAll(t1._contents, iterable, ", "); + } finally { + $.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()); + parts.push(next); + $length += next.length + 2; + ++count; + } + if (!it.moveNext$0()) { + if (count <= 5) + return; + ultimateString = parts.pop(); + penultimateString = parts.pop(); + } else { + penultimate = it.get$current(); + ++count; + if (!it.moveNext$0()) { + if (count <= 4) { + parts.push(A.S(penultimate)); + return; + } + ultimateString = A.S(penultimate); + 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; + $length -= parts.pop().length + 2; + --count; + } + parts.push("..."); + 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; + $length -= parts.pop().length + 2; + if (elision == null) { + $length += 5; + elision = "..."; + } + } + if (elision != null) + parts.push(elision); + parts.push(penultimateString); + parts.push(ultimateString); + }, + Object_hash(object1, object2, object3, object4) { + var t1; + if (B.C_SentinelValue === object3) { + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2)); + } + if (B.C_SentinelValue === object4) { + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + return A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3)); + } + t1 = B.JSInt_methods.get$hashCode(object1); + object2 = J.get$hashCode$(object2); + object3 = J.get$hashCode$(object3); + object4 = J.get$hashCode$(object4); + object4 = A.SystemHash_finish(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine(A.SystemHash_combine($.$get$_hashSeed(), t1), object2), object3), object4)); + return object4; + }, + Object_hashAll(objects) { + var t1, _i, + hash = $.$get$_hashSeed(); + for (t1 = objects.length, _i = 0; _i < objects.length; objects.length === t1 || (0, A.throwConcurrentModificationError)(objects), ++_i) + hash = A.SystemHash_combine(hash, J.get$hashCode$(objects[_i])); + return A.SystemHash_finish(hash); + }, + print(object) { + A.printString(object); + }, + _Enum: function _Enum() { + }, + 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; + }, + 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; + }, + StackOverflowError: function StackOverflowError() { + }, + _Exception: function _Exception(t0) { + this.message = t0; + }, + Iterable: function Iterable() { + }, + MapEntry: function MapEntry(t0, t1, t2) { + this.key = t0; + this.value = t1; + this.$ti = t2; + }, + Null: function Null() { + }, + Object: function Object() { + }, + _StringStackTrace: function _StringStackTrace() { + }, + StringBuffer: function StringBuffer(t0) { + this._contents = t0; + }, + BrowserAppBinding: function BrowserAppBinding(t0, t1, t2) { + var _ = this; + _.__BrowserAppBinding_attachBetween_A = _.__BrowserAppBinding_attachTarget_A = $; + _.ComponentsBinding__rootElement = t0; + _.SchedulerBinding__schedulerPhase = t1; + _.SchedulerBinding__postFrameCallbacks = t2; + }, + _BrowserAppBinding_AppBinding_ComponentsBinding: function _BrowserAppBinding_AppBinding_ComponentsBinding() { + }, + RootDomRenderObject$(container, nodes) { + var t2, + t1 = new A.RootDomRenderObject(container, A._setArrayType([], type$.JSArray_JSObject)); + t1.node = container; + t2 = nodes == null ? A.NodeListIterable_toIterable(container.childNodes) : nodes; + t2 = A.List_List$of(t2, true, type$.JSObject); + t1.toHydrate = t2; + t2 = A.IterableExtensions_get_firstOrNull(t2); + t1.__RootDomRenderObject_beforeStart_F = t2 == null ? null : t2.previousSibling; + return t1; + }, + EventBinding$(element, type, fn) { + var t1 = new A.EventBinding(type, fn); + t1.EventBinding$3(element, type, fn); + return t1; + }, + AttributeOperation_clearOrSetAttribute(_this, $name, value) { + if (value == null) { + if (!_this.hasAttribute($name)) + return; + _this.removeAttribute($name); + } else { + if (J.$eq$(_this.getAttribute($name), value)) + return; + _this.setAttribute($name, value); + } + }, + DomRenderObject: function DomRenderObject(t0) { + var _ = this; + _.node = null; + _.toHydrate = t0; + _.parent = _.events = null; + }, + DomRenderObject_clearEvents_closure: function DomRenderObject_clearEvents_closure() { + }, + DomRenderObject_updateElement_closure: function DomRenderObject_updateElement_closure() { + }, + DomRenderObject_updateElement_closure0: function DomRenderObject_updateElement_closure0(t0, t1, t2) { + this.prevEventTypes = t0; + this.dataEvents = t1; + this.elem = t2; + }, + DomRenderObject_updateElement_closure1: function DomRenderObject_updateElement_closure1(t0) { + this.dataEvents = t0; + }, + RootDomRenderObject: function RootDomRenderObject(t0, t1) { + var _ = this; + _.container = t0; + _.__RootDomRenderObject_beforeStart_F = $; + _.node = null; + _.toHydrate = t1; + _.parent = _.events = null; + }, + EventBinding: function EventBinding(t0, t1) { + this.type = t0; + this.fn = t1; + this.subscription = null; + }, + EventBinding_closure: function EventBinding_closure(t0) { + this.$this = t0; + }, + footer(children, classes, styles) { + var _null = null; + return new A.DomComponent("footer", _null, classes, styles, _null, _null, _null, children, _null); + }, + div(children, classes) { + var _null = null; + return new A.DomComponent("div", _null, classes, _null, _null, _null, _null, children, _null); + }, + ul(children, classes) { + var _null = null; + return new A.DomComponent("ul", _null, classes, _null, _null, _null, _null, children, _null); + }, + li(children, attributes, classes) { + var t1, t2, _null = null; + if (attributes == null) { + t1 = type$.String; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + } else + t1 = attributes; + t2 = type$.String; + t2 = A.LinkedHashMap_LinkedHashMap$of(t1, t2, t2); + return new A.DomComponent("li", _null, classes, _null, t2, _null, _null, children, _null); + }, + p(children) { + var _null = null; + return new A.DomComponent("p", _null, _null, _null, _null, _null, _null, children, _null); + }, + button(children, classes, onClick, styles) { + var t3, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$of(A.LinkedHashMap_LinkedHashMap$_empty(t1, t1), t1, t1); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.void_Function_JSObject); + t3 = type$.dynamic; + t1.addAll$1(0, A.events__events$closure().call$2$1$onClick(onClick, t3, t3)); + return new A.DomComponent("button", null, classes, styles, t2, t1, null, children, null); + }, + input(children, attributes, classes, id, key, onChange, type, value) { + var t3, + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$of(attributes, t1, t1); + if (type != null) + t2.$indexSet(0, "type", type.value); + if (value != null) + t2.$indexSet(0, "value", value); + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, type$.void_Function_JSObject); + t3 = type$.dynamic; + t1.addAll$1(0, A.events__events$closure().call$2$2$onChange$onInput(onChange, null, t3, t3)); + return new A.DomComponent("input", id, classes, null, t2, t1, null, children, key); + }, + label(children, attributes, classes) { + var t1, t2, _null = null; + if (attributes == null) { + t1 = type$.String; + t1 = A.LinkedHashMap_LinkedHashMap$_empty(t1, t1); + } else + t1 = attributes; + t2 = type$.String; + t2 = A.LinkedHashMap_LinkedHashMap$of(t1, t2, t2); + return new A.DomComponent("label", _null, classes, _null, t2, _null, _null, children, _null); + }, + span(children, classes, events) { + var _null = null; + return new A.DomComponent("span", _null, classes, _null, _null, events, _null, children, _null); + }, + InputType: function InputType(t0, t1) { + this.value = t0; + this._name = t1; + }, + AppBinding: function AppBinding() { + }, + _AppBinding_Object_SchedulerBinding: function _AppBinding_Object_SchedulerBinding() { + }, + events(onChange, onClick, onInput, V1, V2) { + var t1 = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.void_Function_JSObject); + if (onClick != null) + t1.$indexSet(0, "click", new A.events_closure(onClick)); + if (onChange != null) + t1.$indexSet(0, "change", A._callWithValue("onChange", onChange, V2)); + return t1; + }, + _callWithValue($event, fn, $V) { + return new A._callWithValue_closure(fn, $V); + }, + _extension_0_toIterable(_this) { + return new A._SyncStarIterable(A._extension_0_toIterable$body(_this), type$._SyncStarIterable_JSObject); + }, + _extension_0_toIterable$body($async$_this) { + return function() { + var _this = $async$_this; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], i, t1; + return function $async$_extension_0_toIterable($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + i = 0; + case 2: + // for condition + if (!(i < _this.length)) { + // goto after for + $async$goto = 4; + break; + } + t1 = _this.item(i); + t1.toString; + $async$goto = 5; + return $async$iterator._async$_current = t1, 1; + case 5: + // after yield + case 3: + // for update + ++i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + events_closure: function events_closure(t0) { + this.onClick = t0; + }, + _callWithValue_closure: function _callWithValue_closure(t0, t1) { + this.fn = t0; + this.V = t1; + }, + _callWithValue__closure: function _callWithValue__closure(t0) { + this.target = t0; + }, + _callWithValue___closure: function _callWithValue___closure(t0) { + this.target = t0; + }, + SchedulerPhase: function SchedulerPhase(t0) { + this._name = t0; + }, + SchedulerBinding: function SchedulerBinding() { + }, + SchedulerBinding_scheduleBuild_closure: function SchedulerBinding_scheduleBuild_closure(t0, t1) { + this.$this = t0; + this.buildCallback = t1; + }, + Styles: function Styles() { + }, + StylesMixin: function StylesMixin() { + }, + _RawStyles: function _RawStyles(t0) { + this.styles = t0; + }, + _Styles_Object_StylesMixin: function _Styles_Object_StylesMixin() { + }, + _RootElement$(component) { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A._RootElement(null, false, t1, t2, component, B._ElementLifecycle_0); + }, + Element__sort(a, b) { + var t2, + t1 = a._depth; + t1.toString; + t2 = b._depth; + t2.toString; + if (t1 < t2) + return -1; + else if (t2 < t1) + return 1; + else { + t1 = b._dirty; + if (t1 && !a._dirty) + return -1; + else if (a._dirty && !t1) + return 1; + } + return 0; + }, + _InactiveElements__deactivateRecursively(element) { + element.deactivate$0(); + element.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + }, + ProxyElement$(component) { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.ProxyElement(t1, t2, component, B._ElementLifecycle_0); + }, + BuildOwner: function BuildOwner(t0, t1) { + var _ = this; + _._dirtyElements = t0; + _._isFirstBuild = _._scheduledBuild = false; + _._inactiveElements = t1; + _._dirtyElementsNeedsResorting = null; + }, + BuildOwner_performInitialBuild_closure: function BuildOwner_performInitialBuild_closure(t0, t1) { + this.$this = t0; + this.completeBuild = t1; + }, + BuildableElement: function BuildableElement() { + }, + ComponentsBinding: function ComponentsBinding() { + }, + _Root: function _Root(t0, t1, t2) { + this.child = t0; + this.children = t1; + this.key = t2; + }, + _RootElement: function _RootElement(t0, t1, t2, t3, t4, t5) { + var _ = this; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._children = null; + _._forgottenChildren = t2; + _._notificationTree = _._parent = null; + _._cachedHash = t3; + _._depth = null; + _._component = t4; + _._owner = _._binding = null; + _._lifecycleState = t5; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + DomComponent: function DomComponent(t0, t1, t2, t3, t4, t5, t6, t7, t8) { + var _ = this; + _.tag = t0; + _.id = t1; + _.classes = t2; + _.styles = t3; + _.attributes = t4; + _.events = t5; + _.child = t6; + _.children = t7; + _.key = t8; + }, + DomElement: function DomElement(t0, t1, t2, t3, t4, t5) { + var _ = this; + _._wrappingElement = null; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._children = null; + _._forgottenChildren = t2; + _._notificationTree = _._parent = null; + _._cachedHash = t3; + _._depth = null; + _._component = t4; + _._owner = _._binding = null; + _._lifecycleState = t5; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + Text: function Text(t0, t1) { + this.text = t0; + this.key = t1; + }, + TextElement: function TextElement(t0, t1, t2, t3, t4) { + var _ = this; + _.RenderObjectElement__renderObject = t0; + _.RenderObjectElement__dirtyRender = t1; + _._notificationTree = _._parent = null; + _._cachedHash = t2; + _._depth = null; + _._component = t3; + _._owner = _._binding = null; + _._lifecycleState = t4; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + Component: function Component() { + }, + _ElementLifecycle: function _ElementLifecycle(t0) { + this._name = t0; + }, + Element: function Element() { + }, + Element_updateChildren_replaceWithNullIfForgotten: function Element_updateChildren_replaceWithNullIfForgotten(t0) { + this.forgottenChildren = t0; + }, + Element_rebuild_closure: function Element_rebuild_closure(t0) { + this.$this = t0; + }, + Element_detachRenderObject_closure: function Element_detachRenderObject_closure() { + }, + Element__updateAncestorSiblingRecursively_closure: function Element__updateAncestorSiblingRecursively_closure() { + }, + _InactiveElements: function _InactiveElements(t0) { + this._framework$_elements = t0; + }, + _InactiveElements__unmount_closure: function _InactiveElements__unmount_closure(t0) { + this.$this = t0; + }, + Key: function Key() { + }, + LocalKey: function LocalKey() { + }, + ValueKey: function ValueKey(t0, t1) { + this.value = t0; + this.$ti = t1; + }, + ProxyComponent: function ProxyComponent() { + }, + ProxyElement: function ProxyElement(t0, t1, t2, t3) { + var _ = this; + _._children = null; + _._forgottenChildren = t0; + _._notificationTree = _._parent = null; + _._cachedHash = t1; + _._depth = null; + _._component = t2; + _._owner = _._binding = null; + _._lifecycleState = t3; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + LeafElement: function LeafElement() { + }, + RenderObject: function RenderObject() { + }, + ProxyRenderObjectElement: function ProxyRenderObjectElement() { + }, + LeafRenderObjectElement: function LeafRenderObjectElement() { + }, + RenderObjectElement: function RenderObjectElement() { + }, + StatefulComponent: function StatefulComponent() { + }, + State: function State() { + }, + StatefulElement: function StatefulElement(t0, t1, t2, t3, t4) { + var _ = this; + _._framework$_state = t0; + _._asyncInitState = null; + _._didChangeDependencies = false; + _._children = null; + _._forgottenChildren = t1; + _._notificationTree = _._parent = null; + _._cachedHash = t2; + _._depth = null; + _._component = t3; + _._owner = _._binding = null; + _._lifecycleState = t4; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + StatelessComponent: function StatelessComponent() { + }, + StatelessElement: function StatelessElement(t0, t1, t2, t3) { + var _ = this; + _._children = _._asyncFirstBuild = null; + _._forgottenChildren = t0; + _._notificationTree = _._parent = null; + _._cachedHash = t1; + _._depth = null; + _._component = t2; + _._owner = _._binding = null; + _._lifecycleState = t3; + _._dependencies = _._inheritedElements = _._observerElements = null; + _._hadUnsatisfiedDependencies = false; + _._dirty = true; + _._inDirtyList = false; + _._lastRenderObjectElement = _._lastChild = _._prevAncestorSibling = _._prevSibling = _._parentRenderObjectElement = null; + _._parentChanged = false; + }, + App: function App(t0) { + this.key = t0; + }, + MapExtensions_get_keyValues(_this, $K, $V) { + var t1 = A._instanceType(_this)._eval$1("LinkedHashMapEntriesIterable<1,2>"); + return A.MappedIterable_MappedIterable(new A.LinkedHashMapEntriesIterable(_this, t1), new A.MapExtensions_get_keyValues_closure($K, $V), t1._eval$1("Iterable.E"), $K._eval$1("@<0>")._bind$1($V)._eval$1("+(1,2)")); + }, + TodoMVC: function TodoMVC(t0) { + this.key = t0; + }, + DisplayState: function DisplayState(t0) { + this._name = t0; + }, + TodoMVCState: function TodoMVCState(t0, t1) { + var _ = this; + _.todos = t0; + _.activeCount = _.dataIdCount = 0; + _.displayState = t1; + _._framework$_element = null; + }, + TodoMVCState_addTodo_closure: function TodoMVCState_addTodo_closure(t0, t1) { + this.$this = t0; + this.todo = t1; + }, + TodoMVCState_toggle_closure: function TodoMVCState_toggle_closure(t0, t1) { + this.$this = t0; + this.i = t1; + }, + TodoMVCState_toggleAll_closure: function TodoMVCState_toggleAll_closure(t0) { + this.$this = t0; + }, + TodoMVCState_destroy_closure: function TodoMVCState_destroy_closure(t0, t1) { + this.$this = t0; + this.i = t1; + }, + TodoMVCState_clearCompleted_closure: function TodoMVCState_clearCompleted_closure(t0) { + this.$this = t0; + }, + TodoMVCState_clearCompleted__closure: function TodoMVCState_clearCompleted__closure() { + }, + TodoMVCState_setDisplayState_closure: function TodoMVCState_setDisplayState_closure(t0, t1) { + this.$this = t0; + this.state = t1; + }, + TodoMVCState_build_closure: function TodoMVCState_build_closure(t0) { + this.$this = t0; + }, + TodoMVCState_build_closure0: function TodoMVCState_build_closure0(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + TodoMVCState_build_closure1: function TodoMVCState_build_closure1(t0, t1) { + this._box_0 = t0; + this.$this = t1; + }, + TodoMVCState_build_closure2: function TodoMVCState_build_closure2(t0, t1) { + this._box_1 = t0; + this.$this = t1; + }, + NewTodo: function NewTodo(t0, t1) { + this.handler = t0; + this.key = t1; + }, + NewTodo_build_closure: function NewTodo_build_closure(t0) { + this.$this = t0; + }, + MapExtensions_get_keyValues_closure: function MapExtensions_get_keyValues_closure(t0, t1) { + this.K = t0; + this.V = t1; + }, + _EventStreamSubscription$(_target, _eventType, onData, _useCapture) { + var result, + t1 = A._wrapZone(new A._EventStreamSubscription_closure(onData), type$.JSObject), + t2 = null; + if (t1 == null) + t1 = t2; + else { + if (typeof t1 == "function") + A.throwExpression(A.ArgumentError$("Attempting to rewrap a JS function.", null)); + result = function(_call, f) { + return function(arg1) { + return _call(f, arg1, arguments.length); + }; + }(A._callDartFunctionFast1, t1); + result[$.$get$DART_CLOSURE_PROPERTY_NAME()] = t1; + t1 = result; + } + if (t1 != null) + _target.addEventListener(_eventType, t1, false); + return new A._EventStreamSubscription(_target, _eventType, t1, false); + }, + _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; + }, + _EventStreamSubscription: function _EventStreamSubscription(t0, t1, t2, t3) { + var _ = this; + _._target = t0; + _._eventType = t1; + _._onData = t2; + _._useCapture = t3; + }, + _EventStreamSubscription_closure: function _EventStreamSubscription_closure(t0) { + this.onData = t0; + }, + printString(string) { + if (typeof dartPrint == "function") { + dartPrint(string); + return; + } + if (typeof console == "object" && typeof console.log != "undefined") { + console.log(string); + return; + } + if (typeof print == "function") { + print(string); + return; + } + throw "Unable to print message: " + String(string); + }, + JSAnyUtilityExtension_instanceOfString(_this, constructorName) { + var parts, $constructor, t1, t2, _i, part; + if (constructorName.length === 0) + return false; + parts = constructorName.split("."); + $constructor = type$.JSObject._as(self); + for (t1 = parts.length, t2 = type$.nullable_JSObject, _i = 0; _i < t1; ++_i) { + part = parts[_i]; + $constructor = t2._as($constructor[part]); + if ($constructor == null) + return false; + } + return _this instanceof type$.JavaScriptFunction._as($constructor); + }, + _callDartFunctionFast1(callback, arg1, $length) { + if ($length >= 1) + return callback.call$1(arg1); + return callback.call$0(); + }, + NodeListIterable_toIterable(_this) { + return new A._SyncStarIterable(A.NodeListIterable_toIterable$body(_this), type$._SyncStarIterable_JSObject); + }, + NodeListIterable_toIterable$body($async$_this) { + return function() { + var _this = $async$_this; + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], i, t1; + return function $async$NodeListIterable_toIterable($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + i = 0; + case 2: + // for condition + if (!(i < _this.length)) { + // goto after for + $async$goto = 4; + break; + } + t1 = _this.item(i); + t1.toString; + $async$goto = 5; + return $async$iterator._async$_current = t1, 1; + case 5: + // after yield + case 3: + // for update + ++i; + // goto for condition + $async$goto = 2; + break; + case 4: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + }, + main() { + var t1 = new A.BrowserAppBinding(null, B.SchedulerPhase_0, A._setArrayType([], type$.JSArray_of_void_Function)); + t1.__BrowserAppBinding_attachTarget_A = "body"; + t1.__BrowserAppBinding_attachBetween_A = null; + t1.super$ComponentsBinding$attachRootComponent(new A.App(null)); + } + }, + 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) + "'"; + }, + 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 + }; + J.JavaScriptObject.prototype = {$isJSObject: 1}; + J.LegacyJavaScriptObject.prototype = { + get$hashCode(receiver) { + return 0; + }, + get$runtimeType(receiver) { + return B.Type_JSObject_ttY; + }, + 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); + } + }; + 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 = { + cast$1$0(receiver, $R) { + return new A.CastList(receiver, A._arrayInstanceType(receiver)._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + remove$1(receiver, element) { + var i; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "remove", 1); + for (i = 0; i < receiver.length; ++i) + if (J.$eq$(receiver[i], element)) { + receiver.splice(i, 1); + return true; + } + return false; + }, + addAll$1(receiver, collection) { + var t1; + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "addAll", 2); + for (t1 = collection.get$iterator(collection); t1.moveNext$0();) + receiver.push(t1.get$current()); + }, + clear$0(receiver) { + receiver.$flags & 1 && A.throwUnsupportedOperation(receiver, "clear", "clear"); + receiver.length = 0; + }, + elementAt$1(receiver, index) { + return receiver[index]; + }, + sort$1(receiver, compare) { + var len, a, b, undefineds, i; + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver, "sort"); + len = receiver.length; + if (len < 2) + return; + if (compare == null) + compare = J._interceptors_JSArray__compareAny$closure(); + if (len === 2) { + a = receiver[0]; + b = receiver[1]; + if (compare.call$2(a, b) > 0) { + receiver[0] = b; + receiver[1] = a; + } + return; + } + undefineds = 0; + if (A._arrayInstanceType(receiver)._precomputed1._is(null)) + for (i = 0; i < receiver.length; ++i) + if (receiver[i] === void 0) { + receiver[i] = null; + ++undefineds; + } + receiver.sort(A.convertDartClosureToJS(compare, 2)); + if (undefineds > 0) + this._replaceSomeNullsWithUndefined$1(receiver, undefineds); + }, + _replaceSomeNullsWithUndefined$1(receiver, count) { + var i0, + i = receiver.length; + for (; i0 = i - 1, i > 0; i = i0) + if (receiver[i0] === null) { + receiver[i0] = void 0; + --count; + if (count === 0) + break; + } + }, + get$isEmpty(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) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + if (!(index >= 0 && index < receiver.length)) + throw A.wrapException(A.diagnoseIndexError(receiver, index)); + receiver[index] = value; + }, + get$runtimeType(receiver) { + return A.createRuntimeType(A._arrayInstanceType(receiver)); + }, + $isEfficientLengthIterable: 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) + throw A.wrapException(A.throwConcurrentModificationError(t1)); + t2 = _this._index; + if (t2 >= $length) { + _this._current = null; + return false; + } + _this._current = t1[t2]; + _this._index = t2 + 1; + return true; + } + }; + J.JSNumber.prototype = { + compareTo$1(receiver, b) { + var bIsNegative; + if (receiver < b) + return -1; + else if (receiver > b) + return 1; + else if (receiver === b) { + if (receiver === 0) { + bIsNegative = this.get$isNegative(b); + if (this.get$isNegative(receiver) === bIsNegative) + return 0; + if (this.get$isNegative(receiver)) + return -1; + return 1; + } + return 0; + } else if (isNaN(receiver)) { + if (isNaN(b)) + return 0; + return 1; + } else + return -1; + }, + get$isNegative(receiver) { + return receiver === 0 ? 1 / receiver < 0 : receiver < 0; + }, + 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; + }, + _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 + }; + 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 = { + compareTo$1(receiver, other) { + var t1; + if (receiver === other) + t1 = 0; + else + t1 = receiver < other ? -1 : 1; + return t1; + }, + 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, + $isString: 1 + }; + A._CastIterableBase.prototype = { + get$iterator(_) { + return new A.CastIterator(J.get$iterator$ax(this.get$_source()), A._instanceType(this)._eval$1("CastIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.get$_source()); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.get$_source()); + }, + elementAt$1(_, index) { + return A._instanceType(this)._rest[1]._as(J.elementAt$1$ax(this.get$_source(), index)); + }, + toString$0(_) { + return J.toString$0$(this.get$_source()); + } + }; + A.CastIterator.prototype = { + moveNext$0() { + return this._source.moveNext$0(); + }, + get$current() { + return this.$ti._rest[1]._as(this._source.get$current()); + } + }; + A._CastListBase.prototype = { + $index(_, index) { + return this.$ti._rest[1]._as(J.$index$ax(this._source, index)); + }, + $indexSet(_, index, value) { + J.$indexSet$ax(this._source, index, this.$ti._precomputed1._as(value)); + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.CastList.prototype = { + cast$1$0(_, $R) { + return new A.CastList(this._source, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("CastList<1,2>")); + }, + get$_source() { + return this._source; + } + }; + A.LateError.prototype = { + toString$0(_) { + return "LateInitializationError: " + this._message; + } + }; + A.SentinelValue.prototype = {}; + 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")); + }, + 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.__internal$_current = null; + return false; + } + _this.__internal$_current = t2.elementAt$1(t1, t3); + ++_this.__internal$_index; + return true; + } + }; + A.MappedIterable.prototype = { + get$iterator(_) { + return new A.MappedIterator(J.get$iterator$ax(this.__internal$_iterable), this._f, A._instanceType(this)._eval$1("MappedIterator<1,2>")); + }, + get$length(_) { + return J.get$length$asx(this.__internal$_iterable); + }, + get$isEmpty(_) { + return J.get$isEmpty$asx(this.__internal$_iterable); + }, + elementAt$1(_, index) { + return this._f.call$1(J.elementAt$1$ax(this.__internal$_iterable, index)); + } + }; + A.EfficientLengthMappedIterable.prototype = {$isEfficientLengthIterable: 1}; + A.MappedIterator.prototype = { + moveNext$0() { + var _this = this, + t1 = _this._iterator; + if (t1.moveNext$0()) { + _this.__internal$_current = _this._f.call$1(t1.get$current()); + return true; + } + _this.__internal$_current = null; + return false; + }, + get$current() { + var t1 = this.__internal$_current; + return t1 == null ? this.$ti._rest[1]._as(t1) : t1; + } + }; + A.WhereIterable.prototype = { + get$iterator(_) { + return new A.WhereIterator(J.get$iterator$ax(this.__internal$_iterable), this._f); + } + }; + A.WhereIterator.prototype = { + moveNext$0() { + var t1, t2; + for (t1 = this._iterator, t2 = this._f; t1.moveNext$0();) + if (t2.call$1(t1.get$current())) + return true; + return false; + }, + get$current() { + return this._iterator.get$current(); + } + }; + A.FixedLengthListMixin.prototype = {}; + A.ReversedListIterable.prototype = { + get$length(_) { + return J.get$length$asx(this._source); + }, + elementAt$1(_, index) { + var t1 = this._source, + t2 = J.getInterceptor$asx(t1); + return t2.elementAt$1(t1, t2.get$length(t1) - 1 - index); + } + }; + A.__CastListBase__CastIterableBase_ListMixin.prototype = {}; + A._Record_2.prototype = {$recipe: "+(1,2)", $shape: 1}; + A._Record_2_isActive_todo.prototype = {$recipe: "+isActive,todo(1,2)", $shape: 2}; + A.ConstantMap.prototype = { + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + get$isNotEmpty(_) { + return this.get$length(this) !== 0; + }, + toString$0(_) { + return A.MapBase_mapToString(this); + }, + get$entries() { + return new A._SyncStarIterable(this.entries$body$ConstantMap(), A._instanceType(this)._eval$1("_SyncStarIterable>")); + }, + entries$body$ConstantMap() { + var $async$self = this; + return function() { + var $async$goto = 0, $async$handler = 1, $async$errorStack = [], t1, t2, key; + return function $async$get$entries($async$iterator, $async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + t1 = $async$self.get$keys(), t1 = t1.get$iterator(t1), t2 = A._instanceType($async$self)._eval$1("MapEntry<1,2>"); + case 2: + // for condition + if (!t1.moveNext$0()) { + // goto after for + $async$goto = 3; + break; + } + key = t1.get$current(); + $async$goto = 4; + return $async$iterator._async$_current = new A.MapEntry(key, $async$self.$index(0, key), t2), 1; + case 4: + // after yield + // goto for condition + $async$goto = 2; + break; + case 3: + // after for + // implicit return + return 0; + case 1: + // rethrow + return $async$iterator._datum = $async$errorStack.at(-1), 3; + } + }; + }; + } + }; + 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; + }, + containsKey$1(key) { + if (typeof key != "string") + return false; + if ("__proto__" === key) + return false; + return this._jsIndex.hasOwnProperty(key); + }, + $index(_, key) { + if (!this.containsKey$1(key)) + return null; + return this._values[this._jsIndex[key]]; + }, + forEach$1(_, f) { + var t1, i, + keys = this.get$_keys(), + values = this._values; + for (t1 = keys.length, i = 0; i < t1; ++i) + f.call$2(keys[i], values[i]); + }, + get$keys() { + return new A._KeysOrValues(this.get$_keys(), this.$ti._eval$1("_KeysOrValues<1>")); + } + }; + A._KeysOrValues.prototype = { + get$length(_) { + return this.__js_helper$_elements.length; + }, + get$isEmpty(_) { + return 0 === this.__js_helper$_elements.length; + }, + get$iterator(_) { + var t1 = this.__js_helper$_elements; + return new A._KeysOrValuesOrElementsIterator(t1, t1.length, this.$ti._eval$1("_KeysOrValuesOrElementsIterator<1>")); + } + }; + A._KeysOrValuesOrElementsIterator.prototype = { + get$current() { + var t1 = this.__js_helper$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + t1 = _this.__js_helper$_index; + if (t1 >= _this.__js_helper$_length) { + _this.__js_helper$_current = null; + return false; + } + _this.__js_helper$_current = _this.__js_helper$_elements[t1]; + _this.__js_helper$_index = t1 + 1; + return true; + } + }; + 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) + "'"; + }, + get$runtimeType(_) { + var rti = A.closureFunctionType(this); + return A.createRuntimeType(rti == null ? A.instanceType(this) : rti); + }, + 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.JsLinkedHashMap.prototype = { + get$length(_) { + return this.__js_helper$_length; + }, + get$isEmpty(_) { + return this.__js_helper$_length === 0; + }, + get$isNotEmpty(_) { + return this.__js_helper$_length !== 0; + }, + get$keys() { + return new A.LinkedHashMapKeysIterable(this, A._instanceType(this)._eval$1("LinkedHashMapKeysIterable<1>")); + }, + get$entries() { + return new A.LinkedHashMapEntriesIterable(this, A._instanceType(this)._eval$1("LinkedHashMapEntriesIterable<1,2>")); + }, + containsKey$1(key) { + var t1 = this.internalContainsKey$1(key); + return t1; + }, + internalContainsKey$1(key) { + var rest = this.__js_helper$_rest; + if (rest == null) + return false; + return this.internalFindBucketIndex$2(rest[this.internalComputeHashCode$1(key)], key) >= 0; + }, + addAll$1(_, other) { + other.forEach$1(0, new A.JsLinkedHashMap_addAll_closure(this)); + }, + $index(_, key) { + var strings, cell, t1, nums, _null = null; + if (typeof key == "string") { + strings = this.__js_helper$_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.__js_helper$_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, _this = this; + if (typeof key == "string") { + strings = _this.__js_helper$_strings; + _this._addHashTableEntry$3(strings == null ? _this.__js_helper$_strings = _this._newHashTable$0() : strings, key, value); + } else if (typeof key == "number" && (key & 0x3fffffff) === key) { + nums = _this.__js_helper$_nums; + _this._addHashTableEntry$3(nums == null ? _this.__js_helper$_nums = _this._newHashTable$0() : nums, key, value); + } else + _this.internalSet$2(key, value); + }, + internalSet$2(key, value) { + var hash, bucket, index, _this = this, + 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)); + } + }, + remove$1(_, key) { + var _this = this; + if (typeof key == "string") + return _this._removeHashTableEntry$2(_this.__js_helper$_strings, key); + else if (typeof key == "number" && (key & 0x3fffffff) === key) + return _this._removeHashTableEntry$2(_this.__js_helper$_nums, key); + else + return _this.internalRemove$1(key); + }, + internalRemove$1(key) { + var hash, bucket, index, cell, _this = this, + rest = _this.__js_helper$_rest; + if (rest == null) + return null; + hash = _this.internalComputeHashCode$1(key); + bucket = rest[hash]; + index = _this.internalFindBucketIndex$2(bucket, key); + if (index < 0) + return null; + cell = bucket.splice(index, 1)[0]; + _this._unlinkCell$1(cell); + if (bucket.length === 0) + delete rest[hash]; + return cell.hashMapCellValue; + }, + forEach$1(_, action) { + var _this = this, + 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 = table[key]; + if (cell == null) + table[key] = this._newLinkedCell$2(key, value); + else + cell.hashMapCellValue = value; + }, + _removeHashTableEntry$2(table, key) { + var cell; + if (table == null) + return null; + cell = table[key]; + if (cell == null) + return null; + this._unlinkCell$1(cell); + delete table[key]; + return cell.hashMapCellValue; + }, + _modified$0() { + this._modifications = this._modifications + 1 & 1073741823; + }, + _newLinkedCell$2(key, value) { + var t1, _this = this, + cell = new A.LinkedHashMapCell(key, value); + if (_this._first == null) + _this._first = _this._last = cell; + else { + t1 = _this._last; + t1.toString; + cell._previous = t1; + _this._last = t1._next = cell; + } + ++_this.__js_helper$_length; + _this._modified$0(); + return cell; + }, + _unlinkCell$1(cell) { + var _this = this, + previous = cell._previous, + next = cell._next; + if (previous == null) + _this._first = next; + else + previous._next = next; + if (next == null) + _this._last = previous; + else + next._previous = previous; + --_this.__js_helper$_length; + _this._modified$0(); + }, + 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[""] = table; + delete table[""]; + return table; + } + }; + A.JsLinkedHashMap_addAll_closure.prototype = { + call$2(key, value) { + this.$this.$indexSet(0, key, value); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("~(1,2)"); + } + }; + A.LinkedHashMapCell.prototype = {}; + A.LinkedHashMapKeysIterable.prototype = { + get$length(_) { + return this._map.__js_helper$_length; + }, + get$isEmpty(_) { + return this._map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this._map; + return new A.LinkedHashMapKeyIterator(t1, t1._modifications, t1._first); + } + }; + 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.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = cell.hashMapCellKey; + _this._cell = cell._next; + return true; + } + } + }; + A.LinkedHashMapEntriesIterable.prototype = { + get$length(_) { + return this._map.__js_helper$_length; + }, + get$isEmpty(_) { + return this._map.__js_helper$_length === 0; + }, + get$iterator(_) { + var t1 = this._map; + return new A.LinkedHashMapEntryIterator(t1, t1._modifications, t1._first, this.$ti._eval$1("LinkedHashMapEntryIterator<1,2>")); + } + }; + A.LinkedHashMapEntryIterator.prototype = { + get$current() { + var t1 = this.__js_helper$_current; + t1.toString; + return t1; + }, + 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.__js_helper$_current = null; + return false; + } else { + _this.__js_helper$_current = new A.MapEntry(cell.hashMapCellKey, cell.hashMapCellValue, _this.$ti._eval$1("MapEntry<1,2>")); + _this._cell = cell._next; + return true; + } + } + }; + 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: 9 + }; + A.initHooks_closure1.prototype = { + call$1(tag) { + return this.prototypeForTag(tag); + }, + $signature: 10 + }; + A._Record.prototype = { + get$runtimeType(_) { + return A.createRuntimeType(this._getRti$0()); + }, + _getRti$0() { + return A.evaluateRtiForRecord(this.$recipe, this._getFieldValues$0()); + }, + toString$0(_) { + return this._toString$1(false); + }, + _toString$1(safe) { + var t2, separator, i, key, value, + keys = this._fieldKeys$0(), + values = this._getFieldValues$0(), + t1 = (safe ? "" + "Record " : "") + "("; + for (t2 = keys.length, separator = "", i = 0; i < t2; ++i, separator = ", ") { + t1 += separator; + key = keys[i]; + if (typeof key == "string") + t1 = t1 + key + ": "; + value = values[i]; + t1 = safe ? t1 + A.Primitives_safeToString(value) : t1 + A.S(value); + } + t1 += ")"; + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + _fieldKeys$0() { + var t1, + shapeTag = this.$shape; + for (; $._Record__computedFieldKeys.length <= shapeTag;) + $._Record__computedFieldKeys.push(null); + t1 = $._Record__computedFieldKeys[shapeTag]; + if (t1 == null) { + t1 = this._computeFieldKeys$0(); + $._Record__computedFieldKeys[shapeTag] = t1; + } + return t1; + }, + _computeFieldKeys$0() { + var i, names, last, + recipe = this.$recipe, + position = recipe.indexOf("("), + joinedNames = recipe.substring(1, position), + fields = recipe.substring(position), + arity = fields === "()" ? 0 : fields.replace(/[^,]/g, "").length + 1, + result = A._setArrayType(new Array(arity), type$.JSArray_Object); + for (i = 0; i < arity; ++i) + result[i] = i; + if (joinedNames !== "") { + names = joinedNames.split(","); + i = names.length; + for (last = arity; i > 0;) { + --last; + --i; + result[last] = names[i]; + } + } + result = A.List_List$from(result, false, type$.Object); + result.$flags = 3; + return result; + } + }; + A._Record2.prototype = { + _getFieldValues$0() { + return [this._0, this._1]; + }, + $eq(_, other) { + if (other == null) + return false; + return other instanceof A._Record2 && this.$shape === other.$shape && J.$eq$(this._0, other._0) && J.$eq$(this._1, other._1); + }, + get$hashCode(_) { + return A.Object_hash(this.$shape, this._0, this._1, B.C_SentinelValue); + } + }; + A._Cell.prototype = { + _readLocal$0() { + var t1 = this._value; + if (t1 === this) + throw A.wrapException(new A.LateError("Local '' has not been initialized.")); + return t1; + } + }; + A.NativeByteBuffer.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteBuffer_rqD; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeTypedData.prototype = {}; + A.NativeByteData.prototype = { + get$runtimeType(receiver) { + return B.Type_ByteData_9dB; + }, + $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]; + }, + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.NativeTypedArrayOfInt.prototype = { + $indexSet(receiver, index, value) { + receiver.$flags & 2 && A.throwUnsupportedOperation(receiver); + A._checkValidIndex(index, receiver, receiver.length); + receiver[index] = value; + }, + $isEfficientLengthIterable: 1, + $isList: 1 + }; + A.NativeFloat32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float32List_9Kz; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeFloat64List.prototype = { + get$runtimeType(receiver) { + return B.Type_Float64List_9Kz; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int16List_s5h; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int32List_O8Z; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeInt8List.prototype = { + get$runtimeType(receiver) { + return B.Type_Int8List_rFV; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint16List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint16List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint32List.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint32List_kmP; + }, + $index(receiver, index) { + A._checkValidIndex(index, receiver, receiver.length); + return receiver[index]; + }, + $isTrustedGetRuntimeType: 1 + }; + A.NativeUint8ClampedList.prototype = { + get$runtimeType(receiver) { + return B.Type_Uint8ClampedList_04U; + }, + 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_8Eb; + }, + 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); + }, + $isType: 1 + }; + A._Error.prototype = { + toString$0(_) { + return this.__rti$_message; + } + }; + A._TypeError.prototype = {$isTypeError: 1}; + A._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = { + call$1(__wc0_formal) { + var t1 = this._box_0, + f = t1.storedCallback; + t1.storedCallback = null; + f.call$0(); + }, + $signature: 5 + }; + A._AsyncRun__initializeScheduleImmediate_closure.prototype = { + call$1(callback) { + var t1, t2; + this._box_0.storedCallback = callback; + t1 = this.div; + t2 = this.span; + t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2); + }, + $signature: 11 + }; + A._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 6 + }; + A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 6 + }; + A._TimerImpl.prototype = { + _TimerImpl$2(milliseconds, callback) { + if (self.setTimeout != null) + self.setTimeout(A.convertDartClosureToJS(new A._TimerImpl_internalCallback(this, callback), 0), milliseconds); + else + throw A.wrapException(A.UnsupportedError$("`setTimeout()` not found.")); + } + }; + A._TimerImpl_internalCallback.prototype = { + call$0() { + this.callback.call$0(); + }, + $signature: 0 + }; + A._AsyncAwaitCompleter.prototype = {}; + A._awaitOnObject_closure.prototype = { + call$1(result) { + return this.bodyFunction.call$2(0, result); + }, + $signature: 2 + }; + A._awaitOnObject_closure0.prototype = { + call$2(error, stackTrace) { + this.bodyFunction.call$2(1, new A.ExceptionAndStackTrace(error, stackTrace)); + }, + $signature: 12 + }; + A._wrapJsFunctionForAsync_closure.prototype = { + call$2(errorCode, result) { + this.$protected(errorCode, result); + }, + $signature: 13 + }; + A._SyncStarIterator.prototype = { + get$current() { + return this._async$_current; + }, + _resumeBody$2(errorCode, errorValue) { + var body, t1, exception; + errorCode = errorCode; + errorValue = errorValue; + body = this._body; + for (; true;) + try { + t1 = body(this, errorCode, errorValue); + return t1; + } catch (exception) { + errorValue = exception; + errorCode = 1; + } + }, + moveNext$0() { + var nestedIterator, exception, value, suspendedBodies, _this = this, errorValue = null, errorCode = 0; + for (; true;) { + nestedIterator = _this._nestedIterator; + if (nestedIterator != null) + try { + if (nestedIterator.moveNext$0()) { + _this._async$_current = nestedIterator.get$current(); + return true; + } else + _this._nestedIterator = null; + } catch (exception) { + errorValue = exception; + errorCode = 1; + _this._nestedIterator = null; + } + value = _this._resumeBody$2(errorCode, errorValue); + if (1 === value) + return true; + if (0 === value) { + _this._async$_current = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._body = A._SyncStarIterator__terminatedBody; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 0; + errorValue = null; + continue; + } + if (2 === value) { + errorCode = 0; + errorValue = null; + continue; + } + if (3 === value) { + errorValue = _this._datum; + _this._datum = null; + suspendedBodies = _this._suspendedBodies; + if (suspendedBodies == null || suspendedBodies.length === 0) { + _this._async$_current = null; + _this._body = A._SyncStarIterator__terminatedBody; + throw errorValue; + return false; + } + _this._body = suspendedBodies.pop(); + errorCode = 1; + continue; + } + throw A.wrapException(A.StateError$("sync*")); + } + return false; + }, + _yieldStar$1(iterable) { + var t1, t2, _this = this; + if (iterable instanceof A._SyncStarIterable) { + t1 = iterable._outerHelper(); + t2 = _this._suspendedBodies; + if (t2 == null) + t2 = _this._suspendedBodies = []; + t2.push(_this._body); + _this._body = t1; + return 2; + } else { + _this._nestedIterator = J.get$iterator$ax(iterable); + return 2; + } + } + }; + A._SyncStarIterable.prototype = { + get$iterator(_) { + return new A._SyncStarIterator(this._outerHelper()); + } + }; + A.AsyncError.prototype = { + toString$0(_) { + return A.S(this.error); + }, + $isError: 1, + get$stackTrace() { + return this.stackTrace; + } + }; + A._FutureListener.prototype = { + matchesErrorTest$1(asyncError) { + if ((this.state & 15) !== 6) + return true; + return this.result._zone.runUnary$2(this.callback, asyncError.error); + }, + handleError$1(asyncError) { + var exception, + errorCallback = this.errorCallback, + result = null, + t1 = asyncError.error, + t2 = this.result._zone; + if (type$.dynamic_Function_Object_StackTrace._is(errorCallback)) + result = t2.runBinary$3(errorCallback, t1, asyncError.stackTrace); + else + result = t2.runUnary$2(errorCallback, t1); + try { + t1 = 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 = { + then$1$2$onError(f, onError, $R) { + var result, + currentZone = $.Zone__current; + if (currentZone === B.C__RootZone) { + if (!type$.dynamic_Function_Object_StackTrace._is(onError) && !type$.dynamic_Function_Object._is(onError)) + throw A.wrapException(A.ArgumentError$value(onError, "onError", string$.Error_)); + } else + onError = A._registerErrorHandler(onError, currentZone); + result = new A._Future(currentZone, $R._eval$1("_Future<0>")); + this._addListener$1(new A._FutureListener(result, 3, f, onError, this.$ti._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>"))); + return result; + }, + _thenAwait$1$2(f, onError, $E) { + var result = new A._Future($.Zone__current, $E._eval$1("_Future<0>")); + this._addListener$1(new A._FutureListener(result, 19, f, onError, this.$ti._eval$1("@<1>")._bind$1($E)._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 _this = this, + t1 = _this._state; + if (t1 <= 3) { + listener._nextListener = _this._resultOrListeners; + _this._resultOrListeners = listener; + } else { + if ((t1 & 4) !== 0) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._addListener$1(listener); + return; + } + _this._cloneResult$1(t1); + } + A._rootScheduleMicrotask(null, null, _this._zone, new A._Future__addListener_closure(_this, listener)); + } + }, + _prependListeners$1(listeners) { + var t1, existingListeners, next, cursor, next0, _this = this, _box_0 = {}; + _box_0.listeners = listeners; + if (listeners == null) + return; + t1 = _this._state; + if (t1 <= 3) { + existingListeners = _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) { + t1 = _this._resultOrListeners; + if ((t1._state & 24) === 0) { + t1._prependListeners$1(listeners); + return; + } + _this._cloneResult$1(t1); + } + _box_0.listeners = _this._reverseListeners$1(listeners); + A._rootScheduleMicrotask(null, null, _this._zone, new A._Future__prependListeners_closure(_box_0, _this)); + } + }, + _removeListeners$0() { + var current = 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; + }, + _completeWithValue$1(value) { + var _this = this, + listeners = _this._removeListeners$0(); + _this._state = 8; + _this._resultOrListeners = value; + A._Future__propagateToListeners(_this, listeners); + }, + _completeWithResultOf$1(source) { + var t1, listeners, _this = this; + if ((source._state & 16) !== 0) { + t1 = _this._zone === source._zone; + t1 = !(t1 || t1); + } else + t1 = false; + if (t1) + return; + listeners = _this._removeListeners$0(); + _this._cloneResult$1(source); + A._Future__propagateToListeners(_this, listeners); + }, + _completeErrorObject$1(error) { + var listeners = this._removeListeners$0(); + this._setErrorObject$1(error); + A._Future__propagateToListeners(this, listeners); + }, + _asyncComplete$1(value) { + if (this.$ti._eval$1("Future<1>")._is(value)) { + this._chainFuture$1(value); + return; + } + this._asyncCompleteWithValue$1(value); + }, + _asyncCompleteWithValue$1(value) { + this._state ^= 2; + A._rootScheduleMicrotask(null, null, this._zone, new A._Future__asyncCompleteWithValue_closure(this, value)); + }, + _chainFuture$1(value) { + A._Future__chainCoreFuture(value, this, false); + return; + }, + _asyncCompleteErrorObject$1(error) { + this._state ^= 2; + A._rootScheduleMicrotask(null, null, this._zone, new A._Future__asyncCompleteErrorObject_closure(this, error)); + }, + $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__chainCoreFuture_closure.prototype = { + call$0() { + A._Future__chainCoreFuture(this._box_0.source, this.target, true); + }, + $signature: 0 + }; + A._Future__asyncCompleteWithValue_closure.prototype = { + call$0() { + this.$this._completeWithValue$1(this.value); + }, + $signature: 0 + }; + A._Future__asyncCompleteErrorObject_closure.prototype = { + call$0() { + this.$this._completeErrorObject$1(this.error); + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback.prototype = { + call$0() { + var e, s, t1, exception, t2, t3, originalSource, joinedResult, _this = this, completeResult = null; + try { + t1 = _this._box_0.listener; + completeResult = t1.result._zone.run$1(t1.callback); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + if (_this.hasError && _this._box_1.source._resultOrListeners.error === e) { + t1 = _this._box_0; + t1.listenerValueOrError = _this._box_1.source._resultOrListeners; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + return; + } + if (completeResult instanceof A._Future && (completeResult._state & 24) !== 0) { + if ((completeResult._state & 16) !== 0) { + t1 = _this._box_0; + t1.listenerValueOrError = completeResult._resultOrListeners; + t1.listenerHasError = true; + } + return; + } + if (completeResult instanceof A._Future) { + originalSource = _this._box_1.source; + joinedResult = new A._Future(originalSource._zone, originalSource.$ti); + completeResult.then$1$2$onError(new A._Future__propagateToListeners_handleWhenCompleteCallback_closure(joinedResult, originalSource), new A._Future__propagateToListeners_handleWhenCompleteCallback_closure0(joinedResult), type$.void); + t1 = _this._box_0; + t1.listenerValueOrError = joinedResult; + t1.listenerHasError = false; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = { + call$1(__wc0_formal) { + this.joinedResult._completeWithResultOf$1(this.originalSource); + }, + $signature: 5 + }; + A._Future__propagateToListeners_handleWhenCompleteCallback_closure0.prototype = { + call$2(e, s) { + this.joinedResult._completeErrorObject$1(new A.AsyncError(e, s)); + }, + $signature: 14 + }; + A._Future__propagateToListeners_handleValueCallback.prototype = { + call$0() { + var e, s, t1, t2, exception, t3; + try { + t1 = this._box_0; + t2 = t1.listener; + t1.listenerValueOrError = t2.result._zone.runUnary$2(t2.callback, this.sourceResult); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t3.listenerHasError = true; + } + }, + $signature: 0 + }; + A._Future__propagateToListeners_handleError.prototype = { + call$0() { + var asyncError, e, s, t1, exception, t2, t3, _this = this; + try { + asyncError = _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 = _this._box_1.source._resultOrListeners; + if (t1.error === e) { + t2 = _this._box_0; + t2.listenerValueOrError = t1; + t1 = t2; + } else { + t1 = e; + t2 = s; + if (t2 == null) + t2 = A.AsyncError_defaultStackTrace(t1); + t3 = _this._box_0; + t3.listenerValueOrError = new A.AsyncError(t1, t2); + t1 = t3; + } + t1.listenerHasError = true; + } + }, + $signature: 0 + }; + A._AsyncCallbackEntry.prototype = {}; + A._StreamIterator.prototype = {}; + A._Zone.prototype = {}; + 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; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$0(); + return; + } + A._rootRun(null, null, this, f); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runUnaryGuarded$1$2(f, arg) { + var e, s, exception; + try { + if (B.C__RootZone === $.Zone__current) { + f.call$1(arg); + return; + } + A._rootRunUnary(null, null, this, f, arg); + } catch (exception) { + e = A.unwrapException(exception); + s = A.getTraceFromException(exception); + A._rootHandleError(e, s); + } + }, + runUnaryGuarded$2(f, arg) { + f.toString; + return this.runUnaryGuarded$1$2(f, arg, type$.dynamic); + }, + bindCallbackGuarded$1(f) { + return new A._RootZone_bindCallbackGuarded_closure(this, f); + }, + bindUnaryCallbackGuarded$1$1(f, $T) { + return new A._RootZone_bindUnaryCallbackGuarded_closure(this, f, $T); + }, + run$1$1(f) { + if ($.Zone__current === B.C__RootZone) + return f.call$0(); + return A._rootRun(null, null, this, f); + }, + run$1(f) { + f.toString; + return this.run$1$1(f, type$.dynamic); + }, + runUnary$2$2(f, arg) { + if ($.Zone__current === B.C__RootZone) + return f.call$1(arg); + return A._rootRunUnary(null, null, this, f, arg); + }, + runUnary$2(f, arg) { + var t1 = type$.dynamic; + f.toString; + return this.runUnary$2$2(f, arg, t1, t1); + }, + runBinary$3$3(f, arg1, arg2) { + if ($.Zone__current === B.C__RootZone) + return f.call$2(arg1, arg2); + return A._rootRunBinary(null, null, this, f, arg1, arg2); + }, + runBinary$3(f, arg1, arg2) { + var t1 = type$.dynamic; + f.toString; + return this.runBinary$3$3(f, arg1, arg2, t1, t1, t1); + }, + registerBinaryCallback$3$1(f) { + return f; + }, + registerBinaryCallback$1(f) { + var t1 = type$.dynamic; + f.toString; + return this.registerBinaryCallback$3$1(f, t1, t1, t1); + } + }; + A._RootZone_bindCallbackGuarded_closure.prototype = { + call$0() { + return this.$this.runGuarded$1(this.f); + }, + $signature: 0 + }; + A._RootZone_bindUnaryCallbackGuarded_closure.prototype = { + call$1(arg) { + return this.$this.runUnaryGuarded$2(this.f, arg); + }, + $signature() { + return this.T._eval$1("~(0)"); + } + }; + A._HashMap.prototype = { + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + get$isNotEmpty(_) { + return this._collection$_length !== 0; + }, + get$keys() { + return new A._HashMapKeyIterable(this, A._instanceType(this)._eval$1("_HashMapKeyIterable<1>")); + }, + containsKey$1(key) { + var t1 = this._containsKey$1(key); + return t1; + }, + _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._strings; + t1 = strings == null ? null : A._HashMap__getTableEntry(strings, key); + return t1; + } else if (typeof key == "number" && (key & 1073741823) === key) { + nums = this._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, _this = this; + if (typeof key == "string" && key !== "__proto__") { + strings = _this._strings; + _this._collection$_addHashTableEntry$3(strings == null ? _this._strings = A._HashMap__newHashTable() : strings, key, value); + } else if (typeof key == "number" && (key & 1073741823) === key) { + nums = _this._nums; + _this._collection$_addHashTableEntry$3(nums == null ? _this._nums = A._HashMap__newHashTable() : nums, key, value); + } else + _this._set$2(key, value); + }, + _set$2(key, value) { + var hash, bucket, index, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._HashMap__newHashTable(); + hash = _this._computeHashCode$1(key); + 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; + } + } + }, + remove$1(_, key) { + var _this = this; + if (typeof key == "string" && key !== "__proto__") + return _this._collection$_removeHashTableEntry$2(_this._strings, key); + else if (typeof key == "number" && (key & 1073741823) === key) + return _this._collection$_removeHashTableEntry$2(_this._nums, key); + else + return _this._remove$1(key); + }, + _remove$1(key) { + var hash, bucket, index, result, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return null; + hash = _this._computeHashCode$1(key); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, key); + if (index < 0) + return null; + --_this._collection$_length; + _this._collection$_keys = null; + result = bucket.splice(index, 2)[1]; + if (0 === bucket.length) + delete rest[hash]; + return result; + }, + forEach$1(_, action) { + var $length, t1, i, key, t2, _this = this, + keys = _this._computeKeys$0(); + for ($length = keys.length, t1 = A._instanceType(_this)._rest[1], i = 0; i < $length; ++i) { + key = keys[i]; + t2 = _this.$index(0, key); + action.call$2(key, t2 == null ? t1._as(t2) : t2); + if (keys !== _this._collection$_keys) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + } + }, + _computeKeys$0() { + var strings, index, names, entries, 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._strings; + index = 0; + if (strings != null) { + names = Object.getOwnPropertyNames(strings); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = names[i]; + ++index; + } + } + nums = _this._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) { + if (table[key] == null) { + ++this._collection$_length; + this._collection$_keys = null; + } + A._HashMap__setTableEntry(table, key, value); + }, + _collection$_removeHashTableEntry$2(table, key) { + var value; + if (table != null && table[key] != null) { + value = A._HashMap__getTableEntry(table, key); + delete table[key]; + --this._collection$_length; + this._collection$_keys = null; + return value; + } else + return null; + }, + _computeHashCode$1(key) { + return J.get$hashCode$(key) & 1073741823; + }, + _getBucket$2(table, key) { + return table[this._computeHashCode$1(key)]; + }, + _findBucketIndex$2(bucket, key) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; i += 2) + if (J.$eq$(bucket[i], 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$isNotEmpty(_) { + 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._collection$_current = null; + return false; + } else { + _this._collection$_current = keys[offset]; + _this._offset = offset + 1; + return true; + } + } + }; + A._HashSet.prototype = { + get$iterator(_) { + return new A._HashSetIterator(this, this._computeElements$0(), A._instanceType(this)._eval$1("_HashSetIterator<1>")); + }, + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + contains$1(_, object) { + var strings, nums; + if (typeof object == "string" && object !== "__proto__") { + strings = this._strings; + return strings == null ? false : strings[object] != null; + } else if (typeof object == "number" && (object & 1073741823) === object) { + nums = this._nums; + return nums == null ? false : nums[object] != null; + } else + return this._contains$1(object); + }, + _contains$1(object) { + var rest = this._collection$_rest; + if (rest == null) + return false; + return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; + }, + add$1(_, element) { + var strings, nums, _this = this; + if (typeof element == "string" && element !== "__proto__") { + strings = _this._strings; + return _this._collection$_addHashTableEntry$2(strings == null ? _this._strings = A._HashSet__newHashTable() : strings, element); + } else if (typeof element == "number" && (element & 1073741823) === element) { + nums = _this._nums; + return _this._collection$_addHashTableEntry$2(nums == null ? _this._nums = A._HashSet__newHashTable() : nums, element); + } else + return _this._add$1(element); + }, + _add$1(element) { + var hash, bucket, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._HashSet__newHashTable(); + hash = _this._computeHashCode$1(element); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [element]; + else { + if (_this._findBucketIndex$2(bucket, element) >= 0) + return false; + bucket.push(element); + } + ++_this._collection$_length; + _this._elements = null; + return true; + }, + remove$1(_, object) { + var _this = this; + if (typeof object == "string" && object !== "__proto__") + return _this._collection$_removeHashTableEntry$2(_this._strings, object); + else if (typeof object == "number" && (object & 1073741823) === object) + return _this._collection$_removeHashTableEntry$2(_this._nums, object); + else + return _this._remove$1(object); + }, + _remove$1(object) { + var hash, bucket, index, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return false; + hash = _this._computeHashCode$1(object); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, object); + if (index < 0) + return false; + --_this._collection$_length; + _this._elements = null; + bucket.splice(index, 1); + if (0 === bucket.length) + delete rest[hash]; + return true; + }, + clear$0(_) { + var _this = this; + if (_this._collection$_length > 0) { + _this._strings = _this._nums = _this._collection$_rest = _this._elements = null; + _this._collection$_length = 0; + } + }, + _computeElements$0() { + var strings, index, names, entries, i, nums, rest, bucket, $length, i0, _this = this, + result = _this._elements; + if (result != null) + return result; + result = A.List_List$filled(_this._collection$_length, null, false, type$.dynamic); + strings = _this._strings; + index = 0; + if (strings != null) { + names = Object.getOwnPropertyNames(strings); + entries = names.length; + for (i = 0; i < entries; ++i) { + result[index] = names[i]; + ++index; + } + } + nums = _this._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) { + result[index] = bucket[i0]; + ++index; + } + } + } + return _this._elements = result; + }, + _collection$_addHashTableEntry$2(table, element) { + if (table[element] != null) + return false; + table[element] = 0; + ++this._collection$_length; + this._elements = null; + return true; + }, + _collection$_removeHashTableEntry$2(table, element) { + if (table != null && table[element] != null) { + delete table[element]; + --this._collection$_length; + this._elements = null; + return true; + } else + return false; + }, + _computeHashCode$1(element) { + return J.get$hashCode$(element) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i], element)) + return i; + return -1; + } + }; + A._HashSetIterator.prototype = { + get$current() { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + elements = _this._elements, + offset = _this._offset, + t1 = _this._set; + if (elements !== t1._elements) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (offset >= elements.length) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = elements[offset]; + _this._offset = offset + 1; + return true; + } + } + }; + A._LinkedHashSet.prototype = { + get$iterator(_) { + var _this = this, + t1 = new A._LinkedHashSetIterator(_this, _this._collection$_modifications, A._instanceType(_this)._eval$1("_LinkedHashSetIterator<1>")); + t1._collection$_cell = _this._collection$_first; + return t1; + }, + get$length(_) { + return this._collection$_length; + }, + get$isEmpty(_) { + return this._collection$_length === 0; + }, + forEach$1(_, action) { + var _this = this, + cell = _this._collection$_first, + modifications = _this._collection$_modifications; + for (; cell != null;) { + action.call$1(cell._element); + if (modifications !== _this._collection$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(_this)); + cell = cell._collection$_next; + } + }, + add$1(_, element) { + var strings, nums, _this = this; + if (typeof element == "string" && element !== "__proto__") { + strings = _this._strings; + return _this._collection$_addHashTableEntry$2(strings == null ? _this._strings = A._LinkedHashSet__newHashTable() : strings, element); + } else if (typeof element == "number" && (element & 1073741823) === element) { + nums = _this._nums; + return _this._collection$_addHashTableEntry$2(nums == null ? _this._nums = A._LinkedHashSet__newHashTable() : nums, element); + } else + return _this._add$1(element); + }, + _add$1(element) { + var hash, bucket, _this = this, + rest = _this._collection$_rest; + if (rest == null) + rest = _this._collection$_rest = A._LinkedHashSet__newHashTable(); + hash = _this._computeHashCode$1(element); + bucket = rest[hash]; + if (bucket == null) + rest[hash] = [_this._collection$_newLinkedCell$1(element)]; + else { + if (_this._findBucketIndex$2(bucket, element) >= 0) + return false; + bucket.push(_this._collection$_newLinkedCell$1(element)); + } + return true; + }, + remove$1(_, object) { + var _this = this; + if (typeof object == "string" && object !== "__proto__") + return _this._collection$_removeHashTableEntry$2(_this._strings, object); + else if (typeof object == "number" && (object & 1073741823) === object) + return _this._collection$_removeHashTableEntry$2(_this._nums, object); + else + return _this._remove$1(object); + }, + _remove$1(object) { + var hash, bucket, index, cell, _this = this, + rest = _this._collection$_rest; + if (rest == null) + return false; + hash = _this._computeHashCode$1(object); + bucket = rest[hash]; + index = _this._findBucketIndex$2(bucket, object); + if (index < 0) + return false; + cell = bucket.splice(index, 1)[0]; + if (0 === bucket.length) + delete rest[hash]; + _this._collection$_unlinkCell$1(cell); + return true; + }, + _collection$_addHashTableEntry$2(table, element) { + if (table[element] != null) + return false; + table[element] = this._collection$_newLinkedCell$1(element); + return true; + }, + _collection$_removeHashTableEntry$2(table, element) { + var cell; + if (table == null) + return false; + cell = table[element]; + if (cell == null) + return false; + this._collection$_unlinkCell$1(cell); + delete table[element]; + return true; + }, + _collection$_modified$0() { + this._collection$_modifications = this._collection$_modifications + 1 & 1073741823; + }, + _collection$_newLinkedCell$1(element) { + var t1, _this = this, + cell = new A._LinkedHashSetCell(element); + if (_this._collection$_first == null) + _this._collection$_first = _this._collection$_last = cell; + else { + t1 = _this._collection$_last; + t1.toString; + cell._collection$_previous = t1; + _this._collection$_last = t1._collection$_next = cell; + } + ++_this._collection$_length; + _this._collection$_modified$0(); + return cell; + }, + _collection$_unlinkCell$1(cell) { + var _this = this, + previous = cell._collection$_previous, + next = cell._collection$_next; + if (previous == null) + _this._collection$_first = next; + else + previous._collection$_next = next; + if (next == null) + _this._collection$_last = previous; + else + next._collection$_previous = previous; + --_this._collection$_length; + _this._collection$_modified$0(); + }, + _computeHashCode$1(element) { + return J.get$hashCode$(element) & 1073741823; + }, + _findBucketIndex$2(bucket, element) { + var $length, i; + if (bucket == null) + return -1; + $length = bucket.length; + for (i = 0; i < $length; ++i) + if (J.$eq$(bucket[i]._element, element)) + return i; + return -1; + } + }; + A._LinkedHashSetCell.prototype = {}; + A._LinkedHashSetIterator.prototype = { + get$current() { + var t1 = this._collection$_current; + return t1 == null ? this.$ti._precomputed1._as(t1) : t1; + }, + moveNext$0() { + var _this = this, + cell = _this._collection$_cell, + t1 = _this._set; + if (_this._collection$_modifications !== t1._collection$_modifications) + throw A.wrapException(A.ConcurrentModificationError$(t1)); + else if (cell == null) { + _this._collection$_current = null; + return false; + } else { + _this._collection$_current = cell._element; + _this._collection$_cell = cell._collection$_next; + return true; + } + } + }; + A.HashMap_HashMap$from_closure.prototype = { + call$2(k, v) { + this.result.$indexSet(0, this.K._as(k), this.V._as(v)); + }, + $signature: 15 + }; + A.ListBase.prototype = { + get$iterator(receiver) { + return new A.ListIterator(receiver, this.get$length(receiver), A.instanceType(receiver)._eval$1("ListIterator")); + }, + elementAt$1(receiver, index) { + return this.$index(receiver, index); + }, + get$isEmpty(receiver) { + return this.get$length(receiver) === 0; + }, + toString$0(receiver) { + return A.Iterable_iterableToFullString(receiver, "[", "]"); + } + }; + A.MapBase.prototype = { + forEach$1(_, action) { + var t1, t2, key, t3; + for (t1 = this.get$keys(), t1 = t1.get$iterator(t1), t2 = A._instanceType(this)._rest[1]; t1.moveNext$0();) { + key = t1.get$current(); + t3 = this.$index(0, key); + action.call$2(key, t3 == null ? t2._as(t3) : t3); + } + }, + get$entries() { + var t1 = this.get$keys(); + return A.MappedIterable_MappedIterable(t1, new A.MapBase_entries_closure(this), A._instanceType(t1)._eval$1("Iterable.E"), A._instanceType(this)._eval$1("MapEntry<1,2>")); + }, + removeWhere$1(_, test) { + var t2, key, t3, _i, _this = this, + t1 = A._instanceType(_this), + keysToRemove = A._setArrayType([], t1._eval$1("JSArray<1>")); + for (t2 = _this.get$keys(), t2 = t2.get$iterator(t2), t1 = t1._rest[1]; t2.moveNext$0();) { + key = t2.get$current(); + t3 = _this.$index(0, key); + if (test.call$2(key, t3 == null ? t1._as(t3) : t3)) + keysToRemove.push(key); + } + for (t1 = keysToRemove.length, _i = 0; _i < keysToRemove.length; keysToRemove.length === t1 || (0, A.throwConcurrentModificationError)(keysToRemove), ++_i) + _this.remove$1(0, keysToRemove[_i]); + }, + get$length(_) { + var t1 = this.get$keys(); + return t1.get$length(t1); + }, + get$isEmpty(_) { + var t1 = this.get$keys(); + return t1.get$isEmpty(t1); + }, + get$isNotEmpty(_) { + var t1 = this.get$keys(); + return t1.get$isNotEmpty(t1); + }, + toString$0(_) { + return A.MapBase_mapToString(this); + } + }; + A.MapBase_entries_closure.prototype = { + call$1(key) { + var t1 = this.$this, + t2 = t1.$index(0, key); + if (t2 == null) + t2 = A._instanceType(t1)._rest[1]._as(t2); + return new A.MapEntry(key, t2, A._instanceType(t1)._eval$1("MapEntry<1,2>")); + }, + $signature() { + return A._instanceType(this.$this)._eval$1("MapEntry<1,2>(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); + t1._contents = (t1._contents += t2) + ": "; + t2 = A.S(v); + t1._contents += t2; + }, + $signature: 16 + }; + A.SetBase.prototype = { + get$isEmpty(_) { + return this.get$length(this) === 0; + }, + addAll$1(_, elements) { + var t1; + for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) + this.add$1(0, t1.get$current()); + }, + removeAll$1(elements) { + var t1, _i; + for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, A.throwConcurrentModificationError)(elements), ++_i) + this.remove$1(0, elements[_i]); + }, + toString$0(_) { + return A.Iterable_iterableToFullString(this, "{", "}"); + }, + 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, "index")); + }, + $isEfficientLengthIterable: 1 + }; + A._SetBase.prototype = {}; + A._Enum.prototype = { + toString$0(_) { + return this._enumToString$0(); + } + }; + A.Error.prototype = { + get$stackTrace() { + return A.Primitives_extractStackTrace(this); + } + }; + 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 ? "" : ": " + 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 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 this.invalidValue; + }, + get$_errorName() { + return "RangeError"; + }, + get$_errorExplanation() { + if (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.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.StackOverflowError.prototype = { + toString$0(_) { + return "Stack Overflow"; + }, + get$stackTrace() { + return null; + }, + $isError: 1 + }; + A._Exception.prototype = { + toString$0(_) { + return "Exception: " + this.message; + } + }; + A.Iterable.prototype = { + join$1(_, separator) { + var first, t1, + iterator = this.get$iterator(this); + if (!iterator.moveNext$0()) + return ""; + first = J.toString$0$(iterator.get$current()); + if (!iterator.moveNext$0()) + return first; + if (separator.length === 0) { + t1 = first; + do + t1 += J.toString$0$(iterator.get$current()); + while (iterator.moveNext$0()); + } else { + t1 = first; + do + t1 = t1 + separator + J.toString$0$(iterator.get$current()); + while (iterator.moveNext$0()); + } + return t1.charCodeAt(0) == 0 ? t1 : t1; + }, + get$length(_) { + var count, + it = this.get$iterator(this); + for (count = 0; it.moveNext$0();) + ++count; + return count; + }, + get$isEmpty(_) { + return !this.get$iterator(this).moveNext$0(); + }, + get$isNotEmpty(_) { + return !this.get$isEmpty(this); + }, + 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, "index")); + }, + toString$0(_) { + return A.Iterable_iterableToShortString(this, "(", ")"); + } + }; + A.MapEntry.prototype = { + toString$0(_) { + return "MapEntry(" + A.S(this.key) + ": " + A.S(this.value) + ")"; + } + }; + 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) + "'"; + }, + get$runtimeType(_) { + return A.getRuntimeTypeOfDartObject(this); + }, + toString() { + return this.toString$0(this); + } + }; + A._StringStackTrace.prototype = { + toString$0(_) { + return ""; + }, + $isStackTrace: 1 + }; + A.StringBuffer.prototype = { + get$length(_) { + return this._contents.length; + }, + toString$0(_) { + var t1 = this._contents; + return t1.charCodeAt(0) == 0 ? t1 : t1; + } + }; + A.BrowserAppBinding.prototype = { + createRootRenderObject$0() { + var t1, t2; + this.__BrowserAppBinding_attachBetween_A === $ && A.throwUnnamedLateFieldNI(); + t1 = self; + t1 = t1.document; + t2 = this.__BrowserAppBinding_attachTarget_A; + t2 === $ && A.throwUnnamedLateFieldNI(); + t2 = t1.querySelector(t2); + t2.toString; + return A.RootDomRenderObject$(t2, null); + } + }; + A._BrowserAppBinding_AppBinding_ComponentsBinding.prototype = {}; + A.DomRenderObject.prototype = { + clearEvents$0() { + var t1 = this.events; + if (t1 != null) + t1.forEach$1(0, new A.DomRenderObject_clearEvents_closure()); + this.events = null; + }, + _createElement$2(tag, namespace) { + if (namespace != null && namespace !== "http://www.w3.org/1999/xhtml") + return self.document.createElementNS(namespace, tag); + return self.document.createElement(tag); + }, + updateElement$6(tag, id, classes, styles, attributes, events) { + var t1, t2, _i, e, i, old, t3, t4, t5, t6, prevEventTypes, dataEvents, _this = this, _null = null, + _s7_ = "Element", + attributesToRemove = A._Cell$(), + elem = A._Cell$(), + namespace = B.Map_rvfri.$index(0, tag); + if (namespace == null) { + t1 = _this.parent; + if (t1 == null) + t1 = _null; + else { + t1 = t1.node; + t1 = t1 == null ? _null : A.JSAnyUtilityExtension_instanceOfString(t1, _s7_); + } + t1 = t1 === true; + } else + t1 = false; + if (t1) { + t1 = _this.parent; + t1 = t1 == null ? _null : t1.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + namespace = t1.namespaceURI; + } + $label0$0: { + t1 = _this.node; + if (t1 == null) { + t1 = _this.parent.toHydrate; + t2 = t1.length; + if (t2 !== 0) + for (_i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + e = t1[_i]; + if (A.JSAnyUtilityExtension_instanceOfString(e, _s7_) && e.tagName.toLowerCase() === tag) { + elem._value = _this.node = e; + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + i = 0; + while (true) { + t1 = elem._value; + if (t1 === elem) + A.throwExpression(A.LateError$localNI("")); + if (!(i < t1.attributes.length)) + break; + t2 = attributesToRemove._value; + if (t2 === attributesToRemove) + A.throwExpression(A.LateError$localNI("")); + J.add$1$ax(t2, t1.attributes.item(i).name); + ++i; + } + B.JSArray_methods.remove$1(_this.parent.toHydrate, e); + t1 = A.NodeListIterable_toIterable(e.childNodes); + _this.toHydrate = A.List_List$of(t1, true, t1.$ti._eval$1("Iterable.E")); + break $label0$0; + } + } + elem._value = _this.node = _this._createElement$2(tag, namespace); + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + } else { + if (A.JSAnyUtilityExtension_instanceOfString(t1, _s7_)) { + t1 = _this.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + t1 = t1.tagName.toLowerCase() !== tag; + } else + t1 = true; + if (t1) { + elem._value = _this._createElement$2(tag, namespace); + old = _this.node; + t1 = old.parentNode; + t1.toString; + t1.replaceChild(elem._readLocal$0(), old); + _this.node = elem._readLocal$0(); + if (old.childNodes.length > 0) + for (t1 = new A._SyncStarIterator(A.NodeListIterable_toIterable(old.childNodes)._outerHelper()); t1.moveNext$0();) { + t2 = t1._async$_current; + t3 = elem._value; + if (t3 === elem) + A.throwExpression(A.LateError$localNI("")); + t3.append(t2); + } + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + } else { + t1 = _this.node; + elem._value = t1 == null ? type$.JSObject._as(t1) : t1; + attributesToRemove._value = A.LinkedHashSet_LinkedHashSet$_empty(type$.String); + i = 0; + while (true) { + t1 = elem._value; + if (t1 === elem) + A.throwExpression(A.LateError$localNI("")); + if (!(i < t1.attributes.length)) + break; + t2 = attributesToRemove._value; + if (t2 === attributesToRemove) + A.throwExpression(A.LateError$localNI("")); + J.add$1$ax(t2, t1.attributes.item(i).name); + ++i; + } + } + } + } + A.AttributeOperation_clearOrSetAttribute(elem._readLocal$0(), "id", id); + t1 = elem._readLocal$0(); + A.AttributeOperation_clearOrSetAttribute(t1, "class", classes == null || classes.length === 0 ? _null : classes); + t1 = elem._readLocal$0(); + if (styles == null || styles.get$isEmpty(styles)) + t2 = _null; + else { + t2 = styles.get$entries(); + t2 = A.MappedIterable_MappedIterable(t2, new A.DomRenderObject_updateElement_closure(), A._instanceType(t2)._eval$1("Iterable.E"), type$.String).join$1(0, "; "); + } + A.AttributeOperation_clearOrSetAttribute(t1, "style", t2); + t1 = attributes == null; + if (!t1 && attributes.get$isNotEmpty(attributes)) + for (t2 = attributes.get$entries(), t2 = t2.get$iterator(t2); t2.moveNext$0();) { + t3 = t2.get$current(); + t4 = t3.key; + t5 = false; + if (J.$eq$(t4, "value")) { + t6 = elem._value; + if (t6 === elem) + A.throwExpression(A.LateError$localNI("")); + if (A.JSAnyUtilityExtension_instanceOfString(t6, "HTMLInputElement")) { + t5 = elem._value; + if (t5 === elem) + A.throwExpression(A.LateError$localNI("")); + t5 = !J.$eq$(t5.value, t3.value); + } + } + if (t5) { + t4 = elem._value; + if (t4 === elem) + A.throwExpression(A.LateError$localNI("")); + t4.value = t3.value; + continue; + } + t5 = elem._value; + if (t5 === elem) + A.throwExpression(A.LateError$localNI("")); + A.AttributeOperation_clearOrSetAttribute(t5, t4, t3.value); + } + t2 = attributesToRemove._readLocal$0(); + t3 = ["id", "class", "style"]; + t1 = t1 ? _null : attributes.get$keys(); + if (t1 != null) + B.JSArray_methods.addAll$1(t3, t1); + t2.removeAll$1(t3); + if (attributesToRemove._readLocal$0()._collection$_length !== 0) + for (t1 = attributesToRemove._readLocal$0(), t1 = A._LinkedHashSetIterator$(t1, t1._collection$_modifications, A._instanceType(t1)._precomputed1), t2 = t1.$ti._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + if (t3 == null) + t3 = t2._as(t3); + t4 = elem._value; + if (t4 === elem) + A.throwExpression(A.LateError$localNI("")); + t4.removeAttribute(t3); + } + if (events != null && events.get$isNotEmpty(events)) { + t1 = _this.events; + if (t1 == null) + prevEventTypes = _null; + else { + t2 = A._instanceType(t1)._eval$1("LinkedHashMapKeysIterable<1>"); + prevEventTypes = A.LinkedHashSet_LinkedHashSet(t2._eval$1("Iterable.E")); + prevEventTypes.addAll$1(0, new A.LinkedHashMapKeysIterable(t1, t2)); + } + dataEvents = _this.events; + if (dataEvents == null) + dataEvents = _this.events = A.LinkedHashMap_LinkedHashMap$_empty(type$.String, type$.EventBinding); + events.forEach$1(0, new A.DomRenderObject_updateElement_closure0(prevEventTypes, dataEvents, elem)); + if (prevEventTypes != null) + prevEventTypes.forEach$1(0, new A.DomRenderObject_updateElement_closure1(dataEvents)); + } else + _this.clearEvents$0(); + }, + updateText$1(text) { + var t1, toHydrate, _i, e, elem, node, _this = this; + $label0$0: { + t1 = _this.node; + if (t1 == null) { + toHydrate = _this.parent.toHydrate; + t1 = toHydrate.length; + if (t1 !== 0) + for (_i = 0; _i < toHydrate.length; toHydrate.length === t1 || (0, A.throwConcurrentModificationError)(toHydrate), ++_i) { + e = toHydrate[_i]; + if (A.JSAnyUtilityExtension_instanceOfString(e, "Text")) { + _this.node = e; + if (!J.$eq$(e.textContent, text)) + e.textContent = text; + B.JSArray_methods.remove$1(toHydrate, e); + break $label0$0; + } + } + _this.node = new self.Text(text); + } else if (!A.JSAnyUtilityExtension_instanceOfString(t1, "Text")) { + elem = new self.Text(text); + t1 = _this.node; + if (t1 == null) + t1 = type$.JSObject._as(t1); + t1.replaceWith(elem); + _this.node = elem; + } else { + node = _this.node; + if (node == null) + node = type$.JSObject._as(node); + if (!J.$eq$(node.textContent, text)) + node.textContent = text; + } + } + }, + attach$2$after(child, after) { + var parentNode, childNode, afterNode, t1; + try { + child.parent = this; + parentNode = this.node; + childNode = child.node; + if (childNode == null) + return; + afterNode = after == null ? null : after.node; + if (J.$eq$(childNode.previousSibling, afterNode) && J.$eq$(childNode.parentNode, parentNode)) + return; + if (afterNode == null) { + t1 = parentNode; + t1.toString; + t1.insertBefore(childNode, parentNode.childNodes.item(0)); + } else + parentNode.insertBefore(childNode, afterNode.nextSibling); + } finally { + child.finalize$0(); + } + }, + finalize$0() { + var t1, t2, _i, node; + for (t1 = this.toHydrate, t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, A.throwConcurrentModificationError)(t1), ++_i) { + node = t1[_i]; + node.parentNode.removeChild(node); + } + B.JSArray_methods.clear$0(this.toHydrate); + } + }; + A.DomRenderObject_clearEvents_closure.prototype = { + call$2(type, binding) { + binding.clear$0(0); + }, + $signature: 17 + }; + A.DomRenderObject_updateElement_closure.prototype = { + call$1(e) { + return A.S(e.key) + ": " + A.S(e.value); + }, + $signature: 18 + }; + A.DomRenderObject_updateElement_closure0.prototype = { + call$2(type, fn) { + var currentBinding, + t1 = this.prevEventTypes; + if (t1 != null) + t1.remove$1(0, type); + t1 = this.dataEvents; + currentBinding = t1.$index(0, type); + if (currentBinding != null) + currentBinding.fn = fn; + else + t1.$indexSet(0, type, A.EventBinding$(this.elem._readLocal$0(), type, fn)); + }, + $signature: 19 + }; + A.DomRenderObject_updateElement_closure1.prototype = { + call$1(type) { + var t1 = this.dataEvents.remove$1(0, type); + if (t1 != null) + t1.clear$0(0); + }, + $signature: 7 + }; + A.RootDomRenderObject.prototype = { + attach$2$after(child, after) { + var t1, t2; + if ((after == null ? null : after.node) != null) + t1 = after; + else { + t1 = new A.DomRenderObject(A._setArrayType([], type$.JSArray_JSObject)); + t2 = this.__RootDomRenderObject_beforeStart_F; + t2 === $ && A.throwUnnamedLateFieldNI(); + t1.node = t2; + } + this.super$DomRenderObject$attach(child, t1); + } + }; + A.EventBinding.prototype = { + EventBinding$3(element, type, fn) { + this.subscription = A._EventStreamSubscription$(element, this.type, new A.EventBinding_closure(this), false); + }, + clear$0(_) { + var t1 = this.subscription; + if (t1 != null) + t1.cancel$0(); + this.subscription = null; + } + }; + A.EventBinding_closure.prototype = { + call$1($event) { + this.$this.fn.call$1($event); + }, + $signature: 1 + }; + A.InputType.prototype = { + _enumToString$0() { + return "InputType." + this._name; + } + }; + A.AppBinding.prototype = {}; + A._AppBinding_Object_SchedulerBinding.prototype = {}; + A.events_closure.prototype = { + call$1(_) { + return this.onClick.call$0(); + }, + $signature: 1 + }; + A._callWithValue_closure.prototype = { + call$1(e) { + var t1, t2, t3, t4, + target = e.target; + $label1$1: { + t1 = type$.JSObject._is(target); + if (t1 && A.JSAnyUtilityExtension_instanceOfString(target, "HTMLInputElement")) { + t1 = new A._callWithValue__closure(target).call$0(); + break $label1$1; + } + if (t1 && A.JSAnyUtilityExtension_instanceOfString(target, "HTMLTextAreaElement")) { + t1 = target.value; + break $label1$1; + } + if (t1 && A.JSAnyUtilityExtension_instanceOfString(target, "HTMLSelectElement")) { + t1 = A._setArrayType([], type$.JSArray_String); + for (t2 = new A._SyncStarIterator(A._extension_0_toIterable(target.selectedOptions)._outerHelper()); t2.moveNext$0();) { + t3 = t2._async$_current; + t4 = A.JSAnyUtilityExtension_instanceOfString(t3, "HTMLOptionElement"); + if (t4) + t1.push(t3.value); + } + break $label1$1; + } + t1 = null; + break $label1$1; + } + this.fn.call$1(this.V._as(t1)); + }, + $signature: 1 + }; + A._callWithValue__closure.prototype = { + call$0() { + var t1 = this.target, + type = A.IterableExtensions_get_firstOrNull(new A.WhereIterable(B.List_T5C, new A._callWithValue___closure(t1), type$.WhereIterable_InputType)); + $label0$0: { + if (B.InputType_checkbox_checkbox === type || B.InputType_radio_radio === type) { + t1 = t1.checked; + break $label0$0; + } + if (B.InputType_number_number === type) { + t1 = t1.valueAsNumber; + break $label0$0; + } + if (B.InputType_date_date === type || B.InputType_Ip0 === type) { + t1 = t1.valueAsDate; + break $label0$0; + } + if (B.InputType_file_file === type) { + t1 = t1.files; + break $label0$0; + } + t1 = t1.value; + break $label0$0; + } + return t1; + }, + $signature: 20 + }; + A._callWithValue___closure.prototype = { + call$1(v) { + return v._name === this.target.type; + }, + $signature: 21 + }; + A.SchedulerPhase.prototype = { + _enumToString$0() { + return "SchedulerPhase." + this._name; + } + }; + A.SchedulerBinding.prototype = { + scheduleBuild$1(buildCallback) { + A.scheduleMicrotask(new A.SchedulerBinding_scheduleBuild_closure(this, buildCallback)); + }, + completeInitialFrame$0() { + this._flushPostFrameCallbacks$0(); + }, + _flushPostFrameCallbacks$0() { + var _i, + t1 = this.SchedulerBinding__postFrameCallbacks, + localPostFrameCallbacks = A.List_List$of(t1, true, type$.void_Function); + B.JSArray_methods.clear$0(t1); + for (t1 = localPostFrameCallbacks.length, _i = 0; _i < t1; ++_i) + localPostFrameCallbacks[_i].call$0(); + } + }; + A.SchedulerBinding_scheduleBuild_closure.prototype = { + call$0() { + var t1 = this.$this; + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_1; + this.buildCallback.call$0(); + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_2; + t1._flushPostFrameCallbacks$0(); + t1.SchedulerBinding__schedulerPhase = B.SchedulerPhase_0; + return null; + }, + $signature: 0 + }; + A.Styles.prototype = {}; + A.StylesMixin.prototype = {}; + A._RawStyles.prototype = {}; + A._Styles_Object_StylesMixin.prototype = {}; + A.BuildOwner.prototype = { + scheduleBuildFor$1(element) { + var _this = this; + if (element._inDirtyList) { + _this._dirtyElementsNeedsResorting = true; + return; + } + if (!_this._scheduledBuild) { + element._binding.scheduleBuild$1(_this.get$performBuild()); + _this._scheduledBuild = true; + } + _this._dirtyElements.push(element); + element._inDirtyList = true; + }, + lockState$1(callback) { + return this.lockState$body$BuildOwner(callback); + }, + lockState$body$BuildOwner(callback) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$handler = 1, $async$errorStack = [], $async$next = [], res; + var $async$lockState$1 = A._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { + if ($async$errorCode === 1) { + $async$errorStack.push($async$result); + $async$goto = $async$handler; + } + while (true) + switch ($async$goto) { + case 0: + // Function start + $async$handler = 2; + res = callback.call$0(); + $async$goto = res instanceof A._Future ? 5 : 6; + break; + case 5: + // then + $async$goto = 7; + return A._asyncAwait(res, $async$lockState$1); + case 7: + // returning from await. + case 6: + // join + $async$next.push(4); + // goto finally + $async$goto = 3; + break; + case 2: + // uncaught + $async$next = [1]; + case 3: + // finally + $async$handler = 1; + // goto the next finally handler + $async$goto = $async$next.pop(); + break; + case 4: + // after finally + // implicit return + return A._asyncReturn(null, $async$completer); + case 1: + // rethrow + return A._asyncRethrow($async$errorStack.at(-1), $async$completer); + } + }); + return A._asyncStartSync($async$lockState$1, $async$completer); + }, + performInitialBuild$2(element, completeBuild) { + return this.performInitialBuild$body$BuildOwner(element, completeBuild); + }, + performInitialBuild$body$BuildOwner(element, completeBuild) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this; + var $async$performInitialBuild$2 = 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 + $async$self._isFirstBuild = true; + element.super$Element$mount(null, null); + element.didMount$0(); + new A.BuildOwner_performInitialBuild_closure($async$self, completeBuild).call$0(); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$performInitialBuild$2, $async$completer); + }, + performBuild$0() { + var dirtyCount, index, element, e, element0, t1, exception, t2, _i, _this = this; + try { + t1 = _this._dirtyElements; + B.JSArray_methods.sort$1(t1, A.framework_Element__sort$closure()); + _this._dirtyElementsNeedsResorting = false; + dirtyCount = t1.length; + index = 0; + for (; index < dirtyCount;) { + element = t1[index]; + try { + element.rebuild$0(); + element.toString; + } catch (exception) { + e = A.unwrapException(exception); + t1 = A.S(e); + A.printString("Error on rebuilding component: " + t1); + throw exception; + } + ++index; + if (!(dirtyCount < t1.length)) { + t2 = _this._dirtyElementsNeedsResorting; + t2.toString; + } else + t2 = true; + if (t2) { + B.JSArray_methods.sort$1(t1, A.framework_Element__sort$closure()); + t2 = _this._dirtyElementsNeedsResorting = false; + dirtyCount = t1.length; + while (true) { + if (!(index > 0 ? t1[index - 1]._dirty : t2)) + break; + --index; + } + } + } + } finally { + for (t1 = _this._dirtyElements, t2 = t1.length, _i = 0; _i < t2; ++_i) { + element0 = t1[_i]; + element0._inDirtyList = false; + } + B.JSArray_methods.clear$0(t1); + _this._dirtyElementsNeedsResorting = null; + _this.lockState$1(_this._inactiveElements.get$_unmountAll()); + _this._scheduledBuild = false; + } + } + }; + A.BuildOwner_performInitialBuild_closure.prototype = { + call$0() { + this.$this._isFirstBuild = false; + this.completeBuild.call$0(); + }, + $signature: 0 + }; + A.BuildableElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return true; + }, + performRebuild$0() { + var e, st, t1, exception, t2, _this = this, _null = null, built = null; + try { + t1 = _this.build$0(); + t1 = A._setArrayType(t1.slice(0), A._arrayInstanceType(t1)); + built = t1; + } catch (exception) { + e = A.unwrapException(exception); + st = A.getTraceFromException(exception); + built = A._setArrayType([new A.DomComponent("div", _null, _null, _null, _null, _null, new A.Text("Error on building component: " + A.S(e), _null), _null, _null)], type$.JSArray_Component); + A.print("Error: " + A.S(e) + " " + A.S(st)); + } finally { + _this._dirty = false; + } + t1 = _this._children; + if (t1 == null) + t1 = A._setArrayType([], type$.JSArray_Element); + t2 = _this._forgottenChildren; + _this._children = _this.updateChildren$3$forgottenChildren(t1, built, t2); + t2.clear$0(0); + }, + visitChildren$1(visitor) { + var t2, child, + t1 = this._children; + t1 = J.get$iterator$ax(t1 == null ? [] : t1); + t2 = this._forgottenChildren; + for (; t1.moveNext$0();) { + child = t1.get$current(); + if (!t2.contains$1(0, child)) + visitor.call$1(child); + } + } + }; + A.ComponentsBinding.prototype = { + attachRootComponent$1(app) { + return this.attachRootComponent$body$ComponentsBinding(app); + }, + attachRootComponent$body$ComponentsBinding(app) { + var $async$goto = 0, + $async$completer = A._makeAsyncAwaitCompleter(type$.void), + $async$self = this, element, t1, buildOwner; + var $async$attachRootComponent$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 = $async$self.ComponentsBinding__rootElement; + buildOwner = t1 == null ? null : t1._owner; + if (buildOwner == null) + buildOwner = new A.BuildOwner(A._setArrayType([], type$.JSArray_Element), new A._InactiveElements(A.HashSet_HashSet(type$.Element))); + element = A._RootElement$(new A._Root(app, null, null)); + element._binding = $async$self; + element._owner = buildOwner; + element.RenderObjectElement__renderObject = $async$self.createRootRenderObject$0(); + $async$self.ComponentsBinding__rootElement = element; + buildOwner.performInitialBuild$2(element, $async$self.get$completeInitialFrame()); + // implicit return + return A._asyncReturn(null, $async$completer); + } + }); + return A._asyncStartSync($async$attachRootComponent$1, $async$completer); + } + }; + A._Root.prototype = { + createElement$0() { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A._RootElement(null, false, t1, t2, this, B._ElementLifecycle_0); + } + }; + A._RootElement.prototype = { + updateRenderObject$0() { + } + }; + A.DomComponent.prototype = { + createElement$0() { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.DomElement(null, false, t1, t2, this, B._ElementLifecycle_0); + } + }; + A.DomElement.prototype = { + get$component() { + return type$.DomComponent._as(A.Element.prototype.get$component.call(this)); + }, + _updateInheritance$0() { + var t1, _this = this; + _this.super$Element$_updateInheritance(); + t1 = _this._inheritedElements; + if (t1 != null && t1.containsKey$1(B.Type__WrappingDomComponent_kh6)) { + t1 = _this._inheritedElements; + t1.toString; + _this._inheritedElements = A.HashMap_HashMap$from(t1, type$.Type, type$.InheritedElement); + } + t1 = _this._inheritedElements; + _this._wrappingElement = t1 == null ? null : t1.remove$1(0, B.Type__WrappingDomComponent_kh6); + }, + shouldRerender$1(newComponent) { + var _this = this, + t1 = type$.DomComponent; + return t1._as(A.Element.prototype.get$component.call(_this)).tag !== newComponent.tag || t1._as(A.Element.prototype.get$component.call(_this)).id != newComponent.id || t1._as(A.Element.prototype.get$component.call(_this)).classes != newComponent.classes || t1._as(A.Element.prototype.get$component.call(_this)).styles != newComponent.styles || t1._as(A.Element.prototype.get$component.call(_this)).attributes != newComponent.attributes || t1._as(A.Element.prototype.get$component.call(_this)).events != newComponent.events; + }, + updateRenderObject$0() { + var t2, t3, t4, t5, t6, _this = this, + t1 = _this.RenderObjectElement__renderObject; + t1.toString; + t2 = type$.DomComponent; + t3 = t2._as(A.Element.prototype.get$component.call(_this)); + t4 = t2._as(A.Element.prototype.get$component.call(_this)); + t5 = t2._as(A.Element.prototype.get$component.call(_this)); + t6 = t2._as(A.Element.prototype.get$component.call(_this)).styles; + t6 = t6 == null ? null : t6.styles; + t1.updateElement$6(t3.tag, t4.id, t5.classes, t6, t2._as(A.Element.prototype.get$component.call(_this)).attributes, t2._as(A.Element.prototype.get$component.call(_this)).events); + } + }; + A.Text.prototype = { + createElement$0() { + var t1 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t1; + return new A.TextElement(null, false, t1, this, B._ElementLifecycle_0); + } + }; + A.TextElement.prototype = {}; + A.Component.prototype = {}; + A._ElementLifecycle.prototype = { + _enumToString$0() { + return "_ElementLifecycle." + this._name; + } + }; + A.Element.prototype = { + $eq(_, other) { + if (other == null) + return false; + return this === other; + }, + get$hashCode(_) { + return this._cachedHash; + }, + get$component() { + var t1 = this._component; + t1.toString; + return t1; + }, + updateChild$3(child, newComponent, prevSibling) { + var t1, newChild, oldComponent, _this = this; + if (newComponent == null) { + if (child != null) { + if (J.$eq$(_this._lastChild, child)) + _this.updateLastChild$1(prevSibling); + _this.deactivateChild$1(child); + } + return null; + } + if (child != null) + if (child._component === newComponent) { + t1 = J.$eq$(child._prevSibling, prevSibling); + if (!t1) + child.updatePrevSibling$1(prevSibling); + newChild = child; + } else { + t1 = child.get$component(); + t1 = A.getRuntimeTypeOfDartObject(t1) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t1.key, newComponent.key); + if (t1) { + t1 = J.$eq$(child._prevSibling, prevSibling); + if (!t1) + child.updatePrevSibling$1(prevSibling); + oldComponent = child.get$component(); + child.update$1(newComponent); + child.didUpdate$1(oldComponent); + newChild = child; + } else { + _this.deactivateChild$1(child); + newChild = _this.inflateComponent$2(newComponent, prevSibling); + } + } + else + newChild = _this.inflateComponent$2(newComponent, prevSibling); + if (J.$eq$(_this._lastChild, prevSibling)) + _this.updateLastChild$1(newChild); + return newChild; + }, + updateChildren$3$forgottenChildren(oldChildren, newComponents, forgottenChildren) { + var newChild, newChildrenBottom, oldChildrenBottom, t2, t3, newChildren, prevChild, newChildrenTop, oldChildrenTop, oldChild, newComponent, t4, retakeOldKeyedChildren, newKeyedChildren, newChildrenTopPeek, key, oldChildrenTopPeek, t5, _this = this, _null = null, + replaceWithNullIfForgotten = new A.Element_updateChildren_replaceWithNullIfForgotten(forgottenChildren), + t1 = J.getInterceptor$asx(oldChildren); + if (t1.get$length(oldChildren) <= 1 && newComponents.length <= 1) { + newChild = _this.updateChild$3(replaceWithNullIfForgotten.call$1(A.IterableExtensions_get_firstOrNull(oldChildren)), A.IterableExtensions_get_firstOrNull(newComponents), _null); + t1 = A._setArrayType([], type$.JSArray_Element); + if (newChild != null) + t1.push(newChild); + return t1; + } + newChildrenBottom = newComponents.length - 1; + oldChildrenBottom = t1.get$length(oldChildren) - 1; + t2 = t1.get$length(oldChildren); + t3 = newComponents.length; + newChildren = t2 === t3 ? oldChildren : A.List_List$filled(t3, _null, true, type$.nullable_Element); + t2 = J.getInterceptor$ax(newChildren); + prevChild = _null; + newChildrenTop = 0; + oldChildrenTop = 0; + while (true) { + if (!(oldChildrenTop <= oldChildrenBottom && newChildrenTop <= newChildrenBottom)) + break; + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + newComponent = newComponents[newChildrenTop]; + if (oldChild != null) { + t3 = oldChild.get$component(); + t3 = !(A.getRuntimeTypeOfDartObject(t3) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t3.key, newComponent.key)); + } else + t3 = true; + if (t3) + break; + t3 = _this.updateChild$3(oldChild, newComponent, prevChild); + t3.toString; + t2.$indexSet(newChildren, newChildrenTop, t3); + ++newChildrenTop; + ++oldChildrenTop; + prevChild = t3; + } + while (true) { + t3 = oldChildrenTop <= oldChildrenBottom; + if (!(t3 && newChildrenTop <= newChildrenBottom)) + break; + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenBottom)); + newComponent = newComponents[newChildrenBottom]; + if (oldChild != null) { + t4 = oldChild.get$component(); + t4 = !(A.getRuntimeTypeOfDartObject(t4) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t4.key, newComponent.key)); + } else + t4 = true; + if (t4) + break; + --oldChildrenBottom; + --newChildrenBottom; + } + retakeOldKeyedChildren = _null; + if (newChildrenTop <= newChildrenBottom && t3) { + t3 = type$.Key; + newKeyedChildren = A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.Component); + for (newChildrenTopPeek = newChildrenTop; newChildrenTopPeek <= newChildrenBottom;) { + newComponent = newComponents[newChildrenTopPeek]; + key = newComponent.key; + if (key != null) + newKeyedChildren.$indexSet(0, key, newComponent); + ++newChildrenTopPeek; + } + if (newKeyedChildren.__js_helper$_length !== 0) { + retakeOldKeyedChildren = A.LinkedHashMap_LinkedHashMap$_empty(t3, type$.Element); + for (oldChildrenTopPeek = oldChildrenTop; oldChildrenTopPeek <= oldChildrenBottom;) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTopPeek)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key != null) { + newComponent = newKeyedChildren.$index(0, key); + if (newComponent != null) { + t3 = oldChild.get$component(); + t3 = A.getRuntimeTypeOfDartObject(t3) === A.getRuntimeTypeOfDartObject(newComponent) && J.$eq$(t3.key, newComponent.key); + } else + t3 = false; + if (t3) + retakeOldKeyedChildren.$indexSet(0, key, oldChild); + } + } + ++oldChildrenTopPeek; + } + } + } + for (t3 = retakeOldKeyedChildren == null, t4 = !t3; newChildrenTop <= newChildrenBottom; prevChild = t5) { + if (oldChildrenTop <= oldChildrenBottom) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key == null || !t4 || !retakeOldKeyedChildren.containsKey$1(key)) { + oldChild._prevAncestorSibling = oldChild._prevSibling = oldChild._parent = null; + t5 = _this._owner._inactiveElements; + if (oldChild._lifecycleState === B._ElementLifecycle_1) { + oldChild.detachRenderObject$0(); + oldChild.deactivate$0(); + oldChild.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t5._framework$_elements.add$1(0, oldChild); + } + } + ++oldChildrenTop; + } + newComponent = newComponents[newChildrenTop]; + key = newComponent.key; + if (key != null) + oldChild = t3 ? _null : retakeOldKeyedChildren.$index(0, key); + else + oldChild = _null; + t5 = _this.updateChild$3(oldChild, newComponent, prevChild); + t5.toString; + t2.$indexSet(newChildren, newChildrenTop, t5); + ++newChildrenTop; + } + for (; oldChildrenTop <= oldChildrenBottom;) { + oldChild = replaceWithNullIfForgotten.call$1(t1.$index(oldChildren, oldChildrenTop)); + if (oldChild != null) { + key = oldChild.get$component().key; + if (key == null || !t4 || !retakeOldKeyedChildren.containsKey$1(key)) { + oldChild._prevAncestorSibling = oldChild._prevSibling = oldChild._parent = null; + t3 = _this._owner._inactiveElements; + if (oldChild._lifecycleState === B._ElementLifecycle_1) { + oldChild.detachRenderObject$0(); + oldChild.deactivate$0(); + oldChild.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t3._framework$_elements.add$1(0, oldChild); + } + } + ++oldChildrenTop; + } + newChildrenBottom = newComponents.length - 1; + oldChildrenBottom = t1.get$length(oldChildren) - 1; + while (true) { + if (!(oldChildrenTop <= oldChildrenBottom && newChildrenTop <= newChildrenBottom)) + break; + t3 = _this.updateChild$3(t1.$index(oldChildren, oldChildrenTop), newComponents[newChildrenTop], prevChild); + t3.toString; + t2.$indexSet(newChildren, newChildrenTop, t3); + ++newChildrenTop; + ++oldChildrenTop; + prevChild = t3; + } + return t2.cast$1$0(newChildren, type$.Element); + }, + mount$2($parent, prevSibling) { + var t1, t2, _this = this; + _this._parent = $parent; + t1 = type$.RenderObjectElement._is($parent); + if (t1) + t2 = $parent; + else + t2 = $parent == null ? null : $parent._parentRenderObjectElement; + _this._parentRenderObjectElement = t2; + _this._prevSibling = prevSibling; + if (prevSibling == null) + if (t1) + t1 = null; + else + t1 = $parent == null ? null : $parent._prevAncestorSibling; + else + t1 = prevSibling; + _this._prevAncestorSibling = t1; + _this._lifecycleState = B._ElementLifecycle_1; + t1 = $parent != null; + if (t1) { + t2 = $parent._depth; + t2.toString; + ++t2; + } else + t2 = 1; + _this._depth = t2; + if (t1) { + t1 = $parent._owner; + t1.toString; + _this._owner = t1; + t1 = $parent._binding; + t1.toString; + _this._binding = t1; + } + _this.get$component(); + _this._updateInheritance$0(); + _this._updateObservers$0(); + _this.attachNotificationTree$0(); + }, + didMount$0() { + }, + update$1(newComponent) { + if (this.shouldRebuild$1(newComponent)) + this._dirty = true; + this._component = newComponent; + }, + didUpdate$1(oldComponent) { + if (this._dirty) + this.rebuild$0(); + }, + inflateComponent$2(newComponent, prevSibling) { + var newChild = newComponent.createElement$0(); + newChild.mount$2(this, prevSibling); + newChild.didMount$0(); + return newChild; + }, + deactivateChild$1(child) { + var t1; + child._prevAncestorSibling = child._prevSibling = child._parent = null; + t1 = this._owner._inactiveElements; + if (child._lifecycleState === B._ElementLifecycle_1) { + child.detachRenderObject$0(); + child.deactivate$0(); + child.visitChildren$1(A.framework__InactiveElements__deactivateRecursively$closure()); + } + t1._framework$_elements.add$1(0, child); + }, + deactivate$0() { + var t2, t3, _this = this, + t1 = _this._dependencies; + if (t1 != null && t1._collection$_length !== 0) + for (t2 = A._instanceType(t1), t1 = new A._HashSetIterator(t1, t1._computeElements$0(), t2._eval$1("_HashSetIterator<1>")), t2 = t2._precomputed1; t1.moveNext$0();) { + t3 = t1._collection$_current; + (t3 == null ? t2._as(t3) : t3).deactivateDependent$1(_this); + } + _this._inheritedElements = null; + _this._lifecycleState = B._ElementLifecycle_2; + }, + unmount$0() { + var _this = this; + _this.get$component(); + _this._dependencies = _this._component = _this._parentRenderObjectElement = null; + _this._lifecycleState = B._ElementLifecycle_3; + }, + _updateInheritance$0() { + var t1 = this._parent; + this._inheritedElements = t1 == null ? null : t1._inheritedElements; + }, + _updateObservers$0() { + var t1 = this._parent; + this._observerElements = t1 == null ? null : t1._observerElements; + }, + attachNotificationTree$0() { + var t1 = this._parent; + this._notificationTree = t1 == null ? null : t1._notificationTree; + }, + markNeedsBuild$0() { + var _this = this; + if (_this._lifecycleState !== B._ElementLifecycle_1) + return; + if (_this._dirty) + return; + _this._dirty = true; + _this._owner.scheduleBuildFor$1(_this); + }, + rebuild$0() { + var _this = this; + if (_this._lifecycleState !== B._ElementLifecycle_1 || !_this._dirty) + return; + _this._owner.toString; + _this.performRebuild$0(); + new A.Element_rebuild_closure(_this).call$0(); + _this.attachRenderObject$0(); + }, + attachRenderObject$0() { + }, + detachRenderObject$0() { + this.visitChildren$1(new A.Element_detachRenderObject_closure()); + }, + updateLastChild$1(child) { + var t1, _this = this; + _this._lastChild = child; + _this._lastRenderObjectElement = child == null ? null : child.get$_lastRenderObjectElement(); + t1 = _this._parent; + if (J.$eq$(t1 == null ? null : t1._lastChild, _this)) { + t1 = _this._parent; + t1 = t1 == null ? null : t1.get$_lastRenderObjectElement(); + t1 = !J.$eq$(t1, _this.get$_lastRenderObjectElement()); + } else + t1 = false; + if (t1) + _this._parent.updateLastChild$1(_this); + }, + updatePrevSibling$1(prevSibling) { + this._prevSibling = prevSibling; + this._updateAncestorSiblingRecursively$1(false); + this._parentChanged = false; + }, + _didUpdateSlot$0() { + }, + _updateAncestorSiblingRecursively$1(didChangeAncestor) { + var t1, _this = this, + newAncestorSibling = _this._prevSibling; + if (newAncestorSibling == null) { + t1 = _this._parent; + if (type$.RenderObjectElement._is(t1)) + newAncestorSibling = null; + else { + t1 = t1 == null ? null : t1._prevAncestorSibling; + newAncestorSibling = t1; + } + } + if (didChangeAncestor || !J.$eq$(newAncestorSibling, _this._prevAncestorSibling)) { + _this._prevAncestorSibling = newAncestorSibling; + _this._didUpdateSlot$0(); + if (!type$.RenderObjectElement._is(_this)) + _this.visitChildren$1(new A.Element__updateAncestorSiblingRecursively_closure()); + } + }, + get$_lastRenderObjectElement() { + return this._lastRenderObjectElement; + } + }; + A.Element_updateChildren_replaceWithNullIfForgotten.prototype = { + call$1(child) { + var t1; + if (child != null) + t1 = this.forgottenChildren.contains$1(0, child); + else + t1 = false; + return t1 ? null : child; + }, + $signature: 22 + }; + A.Element_rebuild_closure.prototype = { + call$0() { + var t3, t4, + t1 = this.$this, + t2 = t1._dependencies; + if (t2 != null && t2._collection$_length !== 0) + for (t3 = A._instanceType(t2), t2 = new A._HashSetIterator(t2, t2._computeElements$0(), t3._eval$1("_HashSetIterator<1>")), t3 = t3._precomputed1; t2.moveNext$0();) { + t4 = t2._collection$_current; + (t4 == null ? t3._as(t4) : t4).didRebuildDependent$1(t1); + } + }, + $signature: 0 + }; + A.Element_detachRenderObject_closure.prototype = { + call$1(child) { + child.detachRenderObject$0(); + }, + $signature: 3 + }; + A.Element__updateAncestorSiblingRecursively_closure.prototype = { + call$1(e) { + return e._updateAncestorSiblingRecursively$1(true); + }, + $signature: 3 + }; + A._InactiveElements.prototype = { + _unmount$1(element) { + element.visitChildren$1(new A._InactiveElements__unmount_closure(this)); + element.unmount$0(); + }, + _unmountAll$0() { + var t2, t3, + t1 = this._framework$_elements, + elements = A.List_List$of(t1, true, A._instanceType(t1)._precomputed1); + B.JSArray_methods.sort$1(elements, A.framework_Element__sort$closure()); + t1.clear$0(0); + for (t1 = A._arrayInstanceType(elements)._eval$1("ReversedListIterable<1>"), t2 = new A.ReversedListIterable(elements, t1), t2 = new A.ListIterator(t2, t2.get$length(0), t1._eval$1("ListIterator")), t1 = t1._eval$1("ListIterable.E"); t2.moveNext$0();) { + t3 = t2.__internal$_current; + this._unmount$1(t3 == null ? t1._as(t3) : t3); + } + } + }; + A._InactiveElements__unmount_closure.prototype = { + call$1(child) { + this.$this._unmount$1(child); + }, + $signature: 3 + }; + A.Key.prototype = {}; + A.LocalKey.prototype = {}; + A.ValueKey.prototype = { + $eq(_, other) { + if (other == null) + return false; + return J.get$runtimeType$(other) === A.getRuntimeTypeOfDartObject(this) && this.$ti._is(other) && other.value === this.value; + }, + get$hashCode(_) { + return A.Object_hashAll([A.getRuntimeTypeOfDartObject(this), this.value]); + }, + toString$0(_) { + var t1 = this.$ti, + t2 = t1._precomputed1, + t3 = this.value, + valueString = A.createRuntimeType(t2) === B.Type_String_AXU ? "<'" + t3 + "'>" : "<" + t3 + ">"; + if (A.getRuntimeTypeOfDartObject(this) === A.createRuntimeType(t1)) + return "[" + valueString + "]"; + return "[" + A.createRuntimeType(t2).toString$0(0) + " " + valueString + "]"; + } + }; + A.ProxyComponent.prototype = { + createElement$0() { + return A.ProxyElement$(this); + } + }; + A.ProxyElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return true; + }, + performRebuild$0() { + var comp, newComponents, t1, t2, _this = this; + _this._dirty = false; + comp = type$.ProxyComponent._as(_this.get$component()); + newComponents = comp.children; + if (newComponents == null) { + t1 = A._setArrayType([], type$.JSArray_Component); + t2 = comp.child; + if (t2 != null) + t1.push(t2); + newComponents = t1; + } + t1 = _this._children; + if (t1 == null) + t1 = A._setArrayType([], type$.JSArray_Element); + t2 = _this._forgottenChildren; + _this._children = _this.updateChildren$3$forgottenChildren(t1, newComponents, t2); + t2.clear$0(0); + }, + visitChildren$1(visitor) { + var t2, child, + t1 = this._children; + t1 = J.get$iterator$ax(t1 == null ? [] : t1); + t2 = this._forgottenChildren; + for (; t1.moveNext$0();) { + child = t1.get$current(); + if (!t2.contains$1(0, child)) + visitor.call$1(child); + } + } + }; + A.LeafElement.prototype = { + mount$2($parent, prevSibling) { + this.super$Element$mount($parent, prevSibling); + }, + didMount$0() { + this.rebuild$0(); + this.super$Element$didMount(); + }, + shouldRebuild$1(newComponent) { + return false; + }, + performRebuild$0() { + this._dirty = false; + }, + visitChildren$1(visitor) { + } + }; + A.RenderObject.prototype = {}; + A.ProxyRenderObjectElement.prototype = { + didMount$0() { + var t1, renderObject, _this = this; + if (_this.RenderObjectElement__renderObject == null) { + t1 = _this._parentRenderObjectElement.RenderObjectElement__renderObject; + t1.toString; + renderObject = new A.DomRenderObject(A._setArrayType([], type$.JSArray_JSObject)); + renderObject.parent = t1; + _this.RenderObjectElement__renderObject = renderObject; + _this.updateRenderObject$0(); + } + _this.super$ProxyElement$didMount(); + }, + update$1(newComponent) { + if (this.shouldRerender$1(newComponent)) + this.RenderObjectElement__dirtyRender = true; + this.super$Element$update(newComponent); + }, + didUpdate$1(oldComponent) { + var _this = this; + if (_this.RenderObjectElement__dirtyRender) { + _this.RenderObjectElement__dirtyRender = false; + _this.updateRenderObject$0(); + } + _this.super$Element$didUpdate(oldComponent); + }, + _didUpdateSlot$0() { + this.super$Element$_didUpdateSlot(); + this.attachRenderObject$0(); + } + }; + A.LeafRenderObjectElement.prototype = { + didMount$0() { + var t1, renderObject, _this = this; + if (_this.RenderObjectElement__renderObject == null) { + t1 = _this._parentRenderObjectElement.RenderObjectElement__renderObject; + t1.toString; + renderObject = new A.DomRenderObject(A._setArrayType([], type$.JSArray_JSObject)); + renderObject.parent = t1; + _this.RenderObjectElement__renderObject = renderObject; + t1 = _this._component; + t1.toString; + renderObject.updateText$1(type$.Text._as(t1).text); + } + _this.super$LeafElement$didMount(); + }, + update$1(newComponent) { + var t1 = this._component; + t1.toString; + if (type$.Text._as(t1).text !== newComponent.text) + this.RenderObjectElement__dirtyRender = true; + this.super$Element$update(newComponent); + }, + didUpdate$1(oldComponent) { + var t1, t2, _this = this; + if (_this.RenderObjectElement__dirtyRender) { + _this.RenderObjectElement__dirtyRender = false; + t1 = _this.RenderObjectElement__renderObject; + t1.toString; + t2 = _this._component; + t2.toString; + t1.updateText$1(type$.Text._as(t2).text); + } + _this.super$Element$didUpdate(oldComponent); + }, + _didUpdateSlot$0() { + this.super$Element$_didUpdateSlot(); + this.attachRenderObject$0(); + } + }; + A.RenderObjectElement.prototype = { + shouldRerender$1(newComponent) { + return true; + }, + attachRenderObject$0() { + var $parent, prevElem, after, t2, + t1 = this._parentRenderObjectElement; + if (t1 == null) + $parent = null; + else { + t1 = t1.RenderObjectElement__renderObject; + t1.toString; + $parent = t1; + } + if ($parent != null) { + prevElem = this._prevAncestorSibling; + while (true) { + t1 = prevElem == null; + if (!(!t1 && prevElem.get$_lastRenderObjectElement() == null)) + break; + prevElem = prevElem._prevAncestorSibling; + } + after = t1 ? null : prevElem.get$_lastRenderObjectElement(); + t1 = this.RenderObjectElement__renderObject; + t1.toString; + if (after == null) + t2 = null; + else { + t2 = after.RenderObjectElement__renderObject; + t2.toString; + } + $parent.attach$2$after(t1, t2); + } + }, + detachRenderObject$0() { + var $parent, t2, + t1 = this._parentRenderObjectElement; + if (t1 == null) + $parent = null; + else { + t1 = t1.RenderObjectElement__renderObject; + t1.toString; + $parent = t1; + } + if ($parent != null) { + t1 = this.RenderObjectElement__renderObject; + t2 = t1.node; + if (t2 != null) + t2.parentNode.removeChild(t2); + t1.parent = null; + } + }, + get$_lastRenderObjectElement() { + return this; + } + }; + A.StatefulComponent.prototype = { + createElement$0() { + var t1 = new A.TodoMVCState(A.LinkedHashMap_LinkedHashMap$_empty(type$.int, type$.Record_2_bool_isActive_and_String_todo), B.DisplayState_0), + t2 = A.HashSet_HashSet(type$.Element), + t3 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t3; + return t1._framework$_element = new A.StatefulElement(t1, t2, t3, this, B._ElementLifecycle_0); + } + }; + A.State.prototype = { + setState$1(fn) { + fn.call$0(); + this._framework$_element.markNeedsBuild$0(); + } + }; + A.StatefulElement.prototype = { + build$0() { + return this._framework$_state.build$1(this); + }, + didMount$0() { + var _this = this; + if (_this._owner._isFirstBuild) + _this._framework$_state.toString; + _this._initState$0(); + _this.super$BuildableElement$didMount(); + }, + _initState$0() { + try { + this._framework$_state.toString; + } finally { + } + this._framework$_state.toString; + }, + performRebuild$0() { + var _this = this; + _this._owner.toString; + if (_this._didChangeDependencies) { + _this._framework$_state.toString; + _this._didChangeDependencies = false; + } + _this.super$BuildableElement$performRebuild(); + }, + shouldRebuild$1(newComponent) { + this._framework$_state.toString; + return true; + }, + update$1(newComponent) { + this.super$Element$update(newComponent); + this._framework$_state.toString; + }, + didUpdate$1(oldComponent) { + try { + this._framework$_state.toString; + } finally { + } + this.super$Element$didUpdate(oldComponent); + }, + deactivate$0() { + this._framework$_state.toString; + this.super$Element$deactivate(); + }, + unmount$0() { + this.super$Element$unmount(); + this._framework$_state = this._framework$_state._framework$_element = null; + } + }; + A.StatelessComponent.prototype = { + createElement$0() { + var t1 = A.HashSet_HashSet(type$.Element), + t2 = ($.Element__nextHashCode + 1) % 16777215; + $.Element__nextHashCode = t2; + return new A.StatelessElement(t1, t2, this, B._ElementLifecycle_0); + } + }; + A.StatelessElement.prototype = { + get$component() { + return type$.StatelessComponent._as(A.Element.prototype.get$component.call(this)); + }, + didMount$0() { + if (this._owner._isFirstBuild) + this._binding.toString; + this.super$BuildableElement$didMount(); + }, + shouldRebuild$1(newComponent) { + type$.StatelessComponent._as(A.Element.prototype.get$component.call(this)); + return true; + }, + build$0() { + return type$.StatelessComponent._as(A.Element.prototype.get$component.call(this)).build$1(this); + }, + performRebuild$0() { + this._owner.toString; + this.super$BuildableElement$performRebuild(); + } + }; + A.App.prototype = { + build$1(context) { + var _null = null, + t1 = type$.JSArray_Component, + t2 = A.p(A._setArrayType([new A.Text("Double-click to edit a todo", _null)], t1)), + t3 = A.p(A._setArrayType([new A.Text("Created by the Dart team", _null)], t1)), + t4 = A._setArrayType([new A.Text("TodoMVC", _null)], t1), + t5 = type$.String; + t5 = A.LinkedHashMap_LinkedHashMap$of(A.LinkedHashMap_LinkedHashMap$_empty(t5, t5), t5, t5); + t5.$indexSet(0, "href", "http://todomvc.com"); + return A._setArrayType([new A.TodoMVC(_null), A.footer(A._setArrayType([t2, t3, A.p(A._setArrayType([new A.Text("Part of ", _null), new A.DomComponent("a", _null, _null, _null, t5, _null, _null, t4, _null)], t1))], t1), "info", _null)], t1); + } + }; + A.TodoMVC.prototype = {}; + A.DisplayState.prototype = { + _enumToString$0() { + return "DisplayState." + this._name; + } + }; + A.TodoMVCState.prototype = { + addTodo$1(todo) { + this.setState$1(new A.TodoMVCState_addTodo_closure(this, todo)); + }, + toggle$1(i) { + this.setState$1(new A.TodoMVCState_toggle_closure(this, i)); + }, + toggleAll$0() { + this.setState$1(new A.TodoMVCState_toggleAll_closure(this)); + }, + destroy$1(i) { + this.setState$1(new A.TodoMVCState_destroy_closure(this, i)); + }, + clearCompleted$0() { + this.setState$1(new A.TodoMVCState_clearCompleted_closure(this)); + }, + setDisplayState$1(state) { + this.setState$1(new A.TodoMVCState_setDisplayState_closure(this, state)); + }, + build$1(context) { + var t8, t9, t10, t11, t12, t13, dataId, _0_2, isActive, t14, t15, t16, _i, state, _this = this, _null = null, _s5_ = "none;", _s6_ = "block;", + _s10_ = "toggle-all", + t1 = type$.String, + t2 = A.LinkedHashMap_LinkedHashMap$_literal(["data-testid", "header"], t1, t1), + t3 = type$.JSArray_Component, + t4 = A._setArrayType([new A.DomComponent("h1", _null, _null, _null, _null, _null, _null, A._setArrayType([new A.Text("todos", _null)], t3), _null), A.div(A._setArrayType([new A.NewTodo(_this.get$addTodo(), _null)], t3), "input-container")], t3), + t5 = _this.todos, + t6 = A.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length === 0 ? _s5_ : _s6_], t1, t1), + t7 = _this.activeCount > 0 ? A.LinkedHashMap_LinkedHashMap$_empty(t1, t1) : A.LinkedHashMap_LinkedHashMap$_literal(["checked", ""], t1, t1); + t7 = A.input(A._setArrayType([], t3), t7, _s10_, _s10_, _null, new A.TodoMVCState_build_closure(_this), B.InputType_checkbox_checkbox, _null); + t8 = A.LinkedHashMap_LinkedHashMap$_literal(["for", "toggle-all"], t1, t1); + t8 = A.div(A._setArrayType([t7, A.label(A._setArrayType([new A.Text("Mark all as complete", _null)], t3), t8, "toggle-all-label")], t3), "toggle-all-container"); + t7 = A._setArrayType([], t3); + for (t9 = A.MapExtensions_get_keyValues(t5, type$.int, type$.Record_2_bool_isActive_and_String_todo), t10 = A._instanceType(t9), t9 = new A.MappedIterator(J.get$iterator$ax(t9.__internal$_iterable), t9._f, t10._eval$1("MappedIterator<1,2>")), t10 = t10._rest[1], t11 = type$.ValueKey_String; t9.moveNext$0();) { + t12 = {}; + t13 = t9.__internal$_current; + if (t13 == null) + t13 = t10._as(t13); + t12.dataId = null; + dataId = t13._0; + t12.dataId = dataId; + _0_2 = t13._1; + isActive = _0_2._0; + if (!(isActive && _this.displayState !== B.DisplayState_2)) + t13 = !isActive && _this.displayState !== B.DisplayState_1; + else + t13 = true; + if (t13) { + t13 = isActive ? "" : "completed"; + t14 = "" + dataId; + t15 = A.LinkedHashMap_LinkedHashMap$_literal(["data-id", t14], t1, t1); + t16 = isActive ? A.LinkedHashMap_LinkedHashMap$_empty(t1, t1) : A.LinkedHashMap_LinkedHashMap$_literal(["checked", ""], t1, t1); + t7.push(A.li(A._setArrayType([A.div(A._setArrayType([A.input(A._setArrayType([], t3), t16, "toggle", _null, new A.ValueKey(t14 + "-" + isActive, t11), new A.TodoMVCState_build_closure0(t12, _this), B.InputType_checkbox_checkbox, _null), A.label(A._setArrayType([new A.Text(_0_2._1, _null)], t3), _null, _null), A.button(A._setArrayType([], t3), "destroy", new A.TodoMVCState_build_closure1(t12, _this), _null)], t3), "view")], t3), t15, t13)); + } + } + t7 = A._setArrayType([t8, A.ul(t7, "todo-list")], t3); + t8 = A.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length === 0 ? _s5_ : _s6_], t1, t1); + t9 = A._setArrayType([new A.Text("" + _this.activeCount, _null)], t3); + t10 = _this.activeCount === 1 ? "" : "s"; + t10 = A.span(A._setArrayType([new A.DomComponent("strong", _null, _null, _null, _null, _null, _null, t9, _null), new A.Text(" item" + t10 + " left", _null)], t3), "todo-count", _null); + t9 = A._setArrayType([], t3); + for (t11 = [B.Record2_All_DisplayState_0, B.Record2_Active_DisplayState_1, B.Record2_Completed_DisplayState_2], t12 = type$.void_Function_JSObject, _i = 0; _i < 3; ++_i) { + t13 = {}; + t14 = t11[_i]; + t13.state = null; + state = t14._1; + t13.state = state; + t15 = _this.displayState === state ? "selected" : ""; + t13 = A.LinkedHashMap_LinkedHashMap$_literal(["click", new A.TodoMVCState_build_closure2(t13, _this)], t1, t12); + t9.push(A.li(A._setArrayType([A.span(A._setArrayType([new A.Text(t14._0, _null)], t3), t15, t13)], t3), _null, _null)); + } + t9 = A.ul(t9, "filters"); + t1 = A.LinkedHashMap_LinkedHashMap$_literal(["display", t5.__js_helper$_length - _this.activeCount === 0 ? _s5_ : _s6_], t1, t1); + return A._setArrayType([new A.DomComponent("section", "root", "todoapp", _null, _null, _null, _null, A._setArrayType([new A.DomComponent("header", _null, "header", _null, t2, _null, _null, t4, _null), new A.DomComponent("main", _null, "main", new A._RawStyles(t6), _null, _null, _null, t7, _null), A.footer(A._setArrayType([t10, t9, A.button(A._setArrayType([new A.Text("Clear completed", _null)], t3), "clear-completed", _this.get$clearCompleted(), new A._RawStyles(t1))], t3), "footer", new A._RawStyles(t8))], t3), _null)], t3); + } + }; + A.TodoMVCState_addTodo_closure.prototype = { + call$0() { + var t1 = this.$this; + t1.todos.$indexSet(0, ++t1.dataIdCount, new A._Record_2_isActive_todo(true, this.todo)); + ++t1.activeCount; + }, + $signature: 0 + }; + A.TodoMVCState_toggle_closure.prototype = { + call$0() { + var t1 = this.$this, + t2 = t1.todos, + t3 = this.i, + _0_0 = t2.$index(0, t3), + isActive = _0_0._0; + t2.$indexSet(0, t3, new A._Record_2_isActive_todo(!isActive, _0_0._1)); + t2 = t1.activeCount; + if (isActive) + t1.activeCount = t2 - 1; + else + t1.activeCount = t2 + 1; + }, + $signature: 0 + }; + A.TodoMVCState_toggleAll_closure.prototype = { + call$0() { + var t1, t2, t3, t4, todo; + for (t1 = this.$this, t2 = t1.todos, t3 = new A.LinkedHashMapKeyIterator(t2, t2._modifications, t2._first); t3.moveNext$0();) { + t4 = t3.__js_helper$_current; + todo = t2.$index(0, t4)._1; + t2.$indexSet(0, t4, new A._Record_2_isActive_todo(t1.activeCount === 0, todo)); + } + t1.activeCount = t1.activeCount === 0 ? t2.__js_helper$_length : 0; + }, + $signature: 0 + }; + A.TodoMVCState_destroy_closure.prototype = { + call$0() { + var t1 = this.$this; + if (t1.todos.remove$1(0, this.i)._0) + --t1.activeCount; + }, + $signature: 0 + }; + A.TodoMVCState_clearCompleted_closure.prototype = { + call$0() { + this.$this.todos.removeWhere$1(0, new A.TodoMVCState_clearCompleted__closure()); + }, + $signature: 0 + }; + A.TodoMVCState_clearCompleted__closure.prototype = { + call$2(dataId, todo) { + return !todo._0; + }, + $signature: 23 + }; + A.TodoMVCState_setDisplayState_closure.prototype = { + call$0() { + this.$this.displayState = this.state; + }, + $signature: 0 + }; + A.TodoMVCState_build_closure.prototype = { + call$1(_) { + return this.$this.toggleAll$0(); + }, + $signature: 2 + }; + A.TodoMVCState_build_closure0.prototype = { + call$1(_) { + return this.$this.toggle$1(this._box_0.dataId); + }, + $signature: 2 + }; + A.TodoMVCState_build_closure1.prototype = { + call$0() { + return this.$this.destroy$1(this._box_0.dataId); + }, + $signature: 0 + }; + A.TodoMVCState_build_closure2.prototype = { + call$1(_) { + return this.$this.setDisplayState$1(this._box_1.state); + }, + $signature: 1 + }; + A.NewTodo.prototype = { + build$1(context) { + var t2, + t1 = type$.String; + t1 = A.LinkedHashMap_LinkedHashMap$_literal(["placeholder", "What needs to be done?"], t1, t1); + t2 = type$.JSArray_Component; + return A._setArrayType([A.input(A._setArrayType([], t2), t1, "new-todo", null, null, new A.NewTodo_build_closure(this), null, "")], t2); + } + }; + A.NewTodo_build_closure.prototype = { + call$1(str) { + return this.$this.handler.call$1(A._asString(str)); + }, + $signature: 2 + }; + A.MapExtensions_get_keyValues_closure.prototype = { + call$1(entry) { + return new A._Record_2(entry.key, entry.value); + }, + $signature() { + return this.K._eval$1("@<0>")._bind$1(this.V)._eval$1("+(1,2)(MapEntry<1,2>)"); + } + }; + A.EventStreamProvider.prototype = {}; + A._EventStreamSubscription.prototype = { + cancel$0() { + var t1, t2, _this = this, + emptyFuture = new A._Future($.Zone__current, type$._Future_void); + emptyFuture._asyncComplete$1(null); + t1 = _this._target; + if (t1 == null) + return emptyFuture; + t2 = _this._onData; + if (t2 != null) + t1.removeEventListener(_this._eventType, t2, false); + _this._onData = _this._target = null; + return emptyFuture; + } + }; + A._EventStreamSubscription_closure.prototype = { + call$1(e) { + return this.onData.call$1(e); + }, + $signature: 1 + }; + (function aliases() { + var _ = J.LegacyJavaScriptObject.prototype; + _.super$LegacyJavaScriptObject$toString = _.toString$0; + _ = A.DomRenderObject.prototype; + _.super$DomRenderObject$attach = _.attach$2$after; + _ = A.BuildableElement.prototype; + _.super$BuildableElement$didMount = _.didMount$0; + _.super$BuildableElement$performRebuild = _.performRebuild$0; + _ = A.ComponentsBinding.prototype; + _.super$ComponentsBinding$attachRootComponent = _.attachRootComponent$1; + _ = A.Element.prototype; + _.super$Element$mount = _.mount$2; + _.super$Element$didMount = _.didMount$0; + _.super$Element$update = _.update$1; + _.super$Element$didUpdate = _.didUpdate$1; + _.super$Element$deactivate = _.deactivate$0; + _.super$Element$unmount = _.unmount$0; + _.super$Element$_updateInheritance = _._updateInheritance$0; + _.super$Element$_didUpdateSlot = _._didUpdateSlot$0; + _ = A.ProxyElement.prototype; + _.super$ProxyElement$didMount = _.didMount$0; + _ = A.LeafElement.prototype; + _.super$LeafElement$didMount = _.didMount$0; + })(); + (function installTearOffs() { + var _static_2 = hunkHelpers._static_2, + _static_1 = hunkHelpers._static_1, + _static_0 = hunkHelpers._static_0, + _static = hunkHelpers.installStaticTearOff, + _instance_0_u = hunkHelpers._instance_0u, + _instance_1_u = hunkHelpers._instance_1u; + _static_2(J, "_interceptors_JSArray__compareAny$closure", "JSArray__compareAny", 24); + _static_1(A, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 4); + _static_1(A, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 4); + _static_1(A, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 4); + _static_0(A, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0); + _static(A, "events__events$closure", 0, null, ["call$2$3$onChange$onClick$onInput", "call$0", "call$2$0", "call$2$1$onClick", "call$2$2$onChange$onInput"], ["events", function() { + var t1 = type$.dynamic; + return A.events(null, null, null, t1, t1); + }, function(V1, V2) { + return A.events(null, null, null, V1, V2); + }, function(onClick, V1, V2) { + return A.events(null, onClick, null, V1, V2); + }, function(onChange, onInput, V1, V2) { + return A.events(onChange, null, onInput, V1, V2); + }], 25, 0); + _instance_0_u(A.SchedulerBinding.prototype, "get$completeInitialFrame", "completeInitialFrame$0", 0); + _static_2(A, "framework_Element__sort$closure", "Element__sort", 26); + _static_1(A, "framework__InactiveElements__deactivateRecursively$closure", "_InactiveElements__deactivateRecursively", 3); + _instance_0_u(A.BuildOwner.prototype, "get$performBuild", "performBuild$0", 0); + _instance_0_u(A._InactiveElements.prototype, "get$_unmountAll", "_unmountAll$0", 0); + var _; + _instance_1_u(_ = A.TodoMVCState.prototype, "get$addTodo", "addTodo$1", 7); + _instance_0_u(_, "get$clearCompleted", "clearCompleted$0", 0); + })(); + (function inheritance() { + var _mixin = hunkHelpers.mixin, + _mixinHard = hunkHelpers.mixinHard, + _inherit = hunkHelpers.inherit, + _inheritMany = hunkHelpers.inheritMany; + _inherit(A.Object, null); + _inheritMany(A.Object, [A.JS_CONST, J.Interceptor, J.ArrayIterator, A.Iterable, A.CastIterator, A.Error, A.SentinelValue, A.ListIterator, A.MappedIterator, A.WhereIterator, A.FixedLengthListMixin, A._Record, A.ConstantMap, A._KeysOrValuesOrElementsIterator, A.TypeErrorDecoder, A.NullThrownFromJavaScriptException, A.ExceptionAndStackTrace, A._StackTrace, A.Closure, A.MapBase, A.LinkedHashMapCell, A.LinkedHashMapKeyIterator, A.LinkedHashMapEntryIterator, A._Cell, A.Rti, A._FunctionParameters, A._Type, A._TimerImpl, A._AsyncAwaitCompleter, A._SyncStarIterator, A.AsyncError, A._FutureListener, A._Future, A._AsyncCallbackEntry, A._StreamIterator, A._Zone, A._HashMapKeyIterator, A.SetBase, A._HashSetIterator, A._LinkedHashSetCell, A._LinkedHashSetIterator, A.ListBase, A._Enum, A.StackOverflowError, A._Exception, A.MapEntry, A.Null, A._StringStackTrace, A.StringBuffer, A._AppBinding_Object_SchedulerBinding, A.RenderObject, A.EventBinding, A.SchedulerBinding, A._Styles_Object_StylesMixin, A.StylesMixin, A.BuildOwner, A.Element, A.ComponentsBinding, A.Component, A._InactiveElements, A.Key, A.RenderObjectElement, A.State, 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.Iterable, [A._CastIterableBase, A.EfficientLengthIterable, A.MappedIterable, A.WhereIterable, A._KeysOrValues, A._SyncStarIterable]); + _inherit(A.__CastListBase__CastIterableBase_ListMixin, A._CastIterableBase); + _inherit(A._CastListBase, A.__CastListBase__CastIterableBase_ListMixin); + _inherit(A.CastList, A._CastListBase); + _inheritMany(A.Error, [A.LateError, A.TypeError, A.JsNoSuchMethodError, A.UnknownJsTypeError, A._CyclicInitializationError, A.RuntimeError, A._Error, A.AssertionError, A.ArgumentError, A.UnsupportedError, A.UnimplementedError, A.StateError, A.ConcurrentModificationError]); + _inheritMany(A.EfficientLengthIterable, [A.ListIterable, A.LinkedHashMapKeysIterable, A.LinkedHashMapEntriesIterable, A._HashMapKeyIterable]); + _inherit(A.EfficientLengthMappedIterable, A.MappedIterable); + _inherit(A.ReversedListIterable, A.ListIterable); + _inherit(A._Record2, A._Record); + _inheritMany(A._Record2, [A._Record_2, A._Record_2_isActive_todo]); + _inherit(A.ConstantStringMap, A.ConstantMap); + _inherit(A.NullError, A.TypeError); + _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__propagateToListeners_handleWhenCompleteCallback_closure, A._RootZone_bindUnaryCallbackGuarded_closure, A.MapBase_entries_closure, A.DomRenderObject_updateElement_closure, A.DomRenderObject_updateElement_closure1, A.EventBinding_closure, A.events_closure, A._callWithValue_closure, A._callWithValue___closure, A.Element_updateChildren_replaceWithNullIfForgotten, A.Element_detachRenderObject_closure, A.Element__updateAncestorSiblingRecursively_closure, A._InactiveElements__unmount_closure, A.TodoMVCState_build_closure, A.TodoMVCState_build_closure0, A.TodoMVCState_build_closure2, A.NewTodo_build_closure, A.MapExtensions_get_keyValues_closure, A._EventStreamSubscription_closure]); + _inheritMany(A.TearOffClosure, [A.StaticClosure, A.BoundClosure]); + _inheritMany(A.MapBase, [A.JsLinkedHashMap, A._HashMap]); + _inheritMany(A.Closure2Args, [A.JsLinkedHashMap_addAll_closure, A.initHooks_closure0, A._awaitOnObject_closure0, A._wrapJsFunctionForAsync_closure, A._Future__propagateToListeners_handleWhenCompleteCallback_closure0, A.HashMap_HashMap$from_closure, A.MapBase_mapToString_closure, A.DomRenderObject_clearEvents_closure, A.DomRenderObject_updateElement_closure0, A.TodoMVCState_clearCompleted__closure]); + _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.Closure0Args, [A._AsyncRun__scheduleImmediateJsOverride_internalCallback, A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, A._TimerImpl_internalCallback, A._Future__addListener_closure, A._Future__prependListeners_closure, A._Future__chainCoreFuture_closure, A._Future__asyncCompleteWithValue_closure, A._Future__asyncCompleteErrorObject_closure, A._Future__propagateToListeners_handleWhenCompleteCallback, A._Future__propagateToListeners_handleValueCallback, A._Future__propagateToListeners_handleError, A._rootHandleError_closure, A._RootZone_bindCallbackGuarded_closure, A._callWithValue__closure, A.SchedulerBinding_scheduleBuild_closure, A.BuildOwner_performInitialBuild_closure, A.Element_rebuild_closure, A.TodoMVCState_addTodo_closure, A.TodoMVCState_toggle_closure, A.TodoMVCState_toggleAll_closure, A.TodoMVCState_destroy_closure, A.TodoMVCState_clearCompleted_closure, A.TodoMVCState_setDisplayState_closure, A.TodoMVCState_build_closure1]); + _inherit(A._RootZone, A._Zone); + _inherit(A._SetBase, A.SetBase); + _inheritMany(A._SetBase, [A._HashSet, A._LinkedHashSet]); + _inheritMany(A.ArgumentError, [A.RangeError, A.IndexError]); + _inherit(A.AppBinding, A._AppBinding_Object_SchedulerBinding); + _inherit(A._BrowserAppBinding_AppBinding_ComponentsBinding, A.AppBinding); + _inherit(A.BrowserAppBinding, A._BrowserAppBinding_AppBinding_ComponentsBinding); + _inherit(A.DomRenderObject, A.RenderObject); + _inherit(A.RootDomRenderObject, A.DomRenderObject); + _inheritMany(A._Enum, [A.InputType, A.SchedulerPhase, A._ElementLifecycle, A.DisplayState]); + _inherit(A.Styles, A._Styles_Object_StylesMixin); + _inherit(A._RawStyles, A.Styles); + _inheritMany(A.Element, [A.BuildableElement, A.ProxyElement, A.LeafElement]); + _inheritMany(A.Component, [A.ProxyComponent, A.Text, A.StatefulComponent, A.StatelessComponent]); + _inheritMany(A.ProxyComponent, [A._Root, A.DomComponent]); + _inherit(A.ProxyRenderObjectElement, A.ProxyElement); + _inheritMany(A.ProxyRenderObjectElement, [A._RootElement, A.DomElement]); + _inherit(A.LeafRenderObjectElement, A.LeafElement); + _inherit(A.TextElement, A.LeafRenderObjectElement); + _inherit(A.LocalKey, A.Key); + _inherit(A.ValueKey, A.LocalKey); + _inheritMany(A.BuildableElement, [A.StatefulElement, A.StatelessElement]); + _inheritMany(A.StatelessComponent, [A.App, A.NewTodo]); + _inherit(A.TodoMVC, A.StatefulComponent); + _inherit(A.TodoMVCState, A.State); + _mixin(A.__CastListBase__CastIterableBase_ListMixin, A.ListBase); + _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._BrowserAppBinding_AppBinding_ComponentsBinding, A.ComponentsBinding); + _mixin(A._AppBinding_Object_SchedulerBinding, A.SchedulerBinding); + _mixin(A._Styles_Object_StylesMixin, A.StylesMixin); + _mixinHard(A.ProxyRenderObjectElement, A.RenderObjectElement); + _mixinHard(A.LeafRenderObjectElement, A.RenderObjectElement); + })(); + 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)", "~(@)", "~(Element)", "~(~())", "Null(@)", "Null()", "~(String)", "@(@)", "@(@,String)", "@(String)", "Null(~())", "Null(@,StackTrace)", "~(int,@)", "Null(Object,StackTrace)", "~(@,@)", "~(Object?,Object?)", "~(String,EventBinding)", "String(MapEntry)", "~(String,~(JSObject))", "Object?()", "bool(InputType)", "Element?(Element?)", "bool(int,+isActive,todo(bool,String))", "int(@,@)", "Map({onChange:~(1^)?,onClick:~()?,onInput:~(0^)?})", "int(Element,Element)"], + interceptorsByTag: null, + leafTags: null, + arrayRti: Symbol("$ti"), + rttc: { + "2;": (t1, t2) => o => o instanceof A._Record_2 && t1._is(o._0) && t2._is(o._1), + "2;isActive,todo": (t1, t2) => o => o instanceof A._Record_2_isActive_todo && t1._is(o._0) && t2._is(o._1) + } + }; + A._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"LegacyJavaScriptObject","UnknownJavaScriptObject":"LegacyJavaScriptObject","JavaScriptFunction":"LegacyJavaScriptObject","JSBool":{"bool":[],"TrustedGetRuntimeType":[]},"JSNull":{"TrustedGetRuntimeType":[]},"JavaScriptObject":{"JSObject":[]},"LegacyJavaScriptObject":{"JSObject":[]},"JSArray":{"List":["1"],"EfficientLengthIterable":["1"],"JSObject":[]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"EfficientLengthIterable":["1"],"JSObject":[]},"JSNumber":{"double":[]},"JSInt":{"double":[],"int":[],"TrustedGetRuntimeType":[]},"JSNumNotInt":{"double":[],"TrustedGetRuntimeType":[]},"JSString":{"String":[],"TrustedGetRuntimeType":[]},"_CastIterableBase":{"Iterable":["2"]},"_CastListBase":{"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"]},"CastList":{"_CastListBase":["1","2"],"ListBase":["2"],"List":["2"],"_CastIterableBase":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"ListBase.E":"2","Iterable.E":"2"},"LateError":{"Error":[]},"EfficientLengthIterable":{"Iterable":["1"]},"ListIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"]},"MappedIterable":{"Iterable":["2"],"Iterable.E":"2"},"EfficientLengthMappedIterable":{"MappedIterable":["1","2"],"EfficientLengthIterable":["2"],"Iterable":["2"],"Iterable.E":"2"},"WhereIterable":{"Iterable":["1"],"Iterable.E":"1"},"ReversedListIterable":{"ListIterable":["1"],"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1","ListIterable.E":"1"},"ConstantStringMap":{"ConstantMap":["1","2"]},"_KeysOrValues":{"Iterable":["1"],"Iterable.E":"1"},"NullError":{"TypeError":[],"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"_CyclicInitializationError":{"Error":[]},"RuntimeError":{"Error":[]},"JsLinkedHashMap":{"MapBase":["1","2"]},"LinkedHashMapKeysIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"LinkedHashMapEntriesIterable":{"EfficientLengthIterable":["MapEntry<1,2>"],"Iterable":["MapEntry<1,2>"],"Iterable.E":"MapEntry<1,2>"},"NativeByteBuffer":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedData":{"JSObject":[]},"NativeByteData":{"JSObject":[],"TrustedGetRuntimeType":[]},"NativeTypedArray":{"JavaScriptIndexingBehavior":["1"],"JSObject":[]},"NativeTypedArrayOfDouble":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[]},"NativeTypedArrayOfInt":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[]},"NativeFloat32List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeFloat64List":{"ListBase":["double"],"List":["double"],"JavaScriptIndexingBehavior":["double"],"EfficientLengthIterable":["double"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"double"},"NativeInt16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeInt8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint16List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint32List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8ClampedList":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"NativeUint8List":{"ListBase":["int"],"List":["int"],"JavaScriptIndexingBehavior":["int"],"EfficientLengthIterable":["int"],"JSObject":[],"TrustedGetRuntimeType":[],"ListBase.E":"int"},"_Type":{"Type":[]},"_Error":{"Error":[]},"_TypeError":{"TypeError":[],"Error":[]},"_SyncStarIterable":{"Iterable":["1"],"Iterable.E":"1"},"AsyncError":{"Error":[]},"_Future":{"Future":["1"]},"_HashMap":{"MapBase":["1","2"]},"_HashMapKeyIterable":{"EfficientLengthIterable":["1"],"Iterable":["1"],"Iterable.E":"1"},"_HashSet":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"_LinkedHashSet":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"SetBase":{"EfficientLengthIterable":["1"]},"_SetBase":{"SetBase":["1"],"EfficientLengthIterable":["1"]},"List":{"EfficientLengthIterable":["1"]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"StateError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"StackOverflowError":{"Error":[]},"_StringStackTrace":{"StackTrace":[]},"_WrappingDomComponent":{"DomComponent":[],"ProxyComponent":[],"Component":[]},"InheritedElement":{"Element":[]},"BuildableElement":{"Element":[]},"_Root":{"ProxyComponent":[],"Component":[]},"_RootElement":{"RenderObjectElement":[],"Element":[]},"DomComponent":{"ProxyComponent":[],"Component":[]},"DomElement":{"RenderObjectElement":[],"Element":[]},"Text":{"Component":[]},"TextElement":{"RenderObjectElement":[],"Element":[]},"ProxyComponent":{"Component":[]},"ProxyElement":{"Element":[]},"LeafElement":{"Element":[]},"ProxyRenderObjectElement":{"RenderObjectElement":[],"Element":[]},"LeafRenderObjectElement":{"RenderObjectElement":[],"Element":[]},"StatefulComponent":{"Component":[]},"StatefulElement":{"Element":[]},"StatelessComponent":{"Component":[]},"StatelessElement":{"Element":[]},"App":{"StatelessComponent":[],"Component":[]},"TodoMVC":{"Component":[]},"NewTodo":{"StatelessComponent":[],"Component":[]},"Int8List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint8List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint8ClampedList":{"List":["int"],"EfficientLengthIterable":["int"]},"Int16List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint16List":{"List":["int"],"EfficientLengthIterable":["int"]},"Int32List":{"List":["int"],"EfficientLengthIterable":["int"]},"Uint32List":{"List":["int"],"EfficientLengthIterable":["int"]},"Float32List":{"List":["double"],"EfficientLengthIterable":["double"]},"Float64List":{"List":["double"],"EfficientLengthIterable":["double"]}}')); + A._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"WhereIterator":1,"FixedLengthListMixin":1,"__CastListBase__CastIterableBase_ListMixin":2,"LinkedHashMapKeyIterator":1,"NativeTypedArray":1,"_SyncStarIterator":1,"_StreamIterator":1,"_SetBase":1,"StylesMixin":1,"State":1,"_EventStreamSubscription":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 { + Component: findType("Component"), + DomComponent: findType("DomComponent"), + EfficientLengthIterable_dynamic: findType("EfficientLengthIterable<@>"), + Element: findType("Element"), + Error: findType("Error"), + EventBinding: findType("EventBinding"), + Function: findType("Function"), + InheritedElement: findType("InheritedElement"), + JSArray_Component: findType("JSArray"), + JSArray_Element: findType("JSArray"), + JSArray_JSObject: findType("JSArray"), + JSArray_Object: findType("JSArray"), + JSArray_String: findType("JSArray"), + JSArray_dynamic: findType("JSArray<@>"), + JSArray_of_void_Function: findType("JSArray<~()>"), + JSNull: findType("JSNull"), + JSObject: findType("JSObject"), + JavaScriptFunction: findType("JavaScriptFunction"), + JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"), + Key: findType("Key"), + List_dynamic: findType("List<@>"), + Null: findType("Null"), + Object: findType("Object"), + ProxyComponent: findType("ProxyComponent"), + Record: findType("Record"), + Record_0: findType("+()"), + Record_2_bool_isActive_and_String_todo: findType("+isActive,todo(bool,String)"), + RenderObjectElement: findType("RenderObjectElement"), + StackTrace: findType("StackTrace"), + StatelessComponent: findType("StatelessComponent"), + String: findType("String"), + Text: findType("Text"), + TrustedGetRuntimeType: findType("TrustedGetRuntimeType"), + Type: findType("Type"), + TypeError: findType("TypeError"), + UnknownJavaScriptObject: findType("UnknownJavaScriptObject"), + ValueKey_String: findType("ValueKey"), + WhereIterable_InputType: findType("WhereIterable"), + _Future_dynamic: findType("_Future<@>"), + _Future_void: findType("_Future<~>"), + _SyncStarIterable_JSObject: findType("_SyncStarIterable"), + bool: findType("bool"), + double: findType("double"), + dynamic: 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_Element: findType("Element?"), + nullable_Future_Null: findType("Future?"), + nullable_JSObject: findType("JSObject?"), + nullable_Object: findType("Object?"), + nullable_String: findType("String?"), + nullable_bool: findType("bool?"), + nullable_double: findType("double?"), + nullable_int: findType("int?"), + nullable_num: findType("num?"), + num: findType("num"), + void: findType("~"), + void_Function: findType("~()"), + void_Function_JSObject: findType("~(JSObject)") + }; + })(); + (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.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_SentinelValue = new A.SentinelValue(); + B.C__RootZone = new A._RootZone(); + B.C__StringStackTrace = new A._StringStackTrace(); + B.DisplayState_0 = new A.DisplayState("all"); + B.DisplayState_1 = new A.DisplayState("active"); + B.DisplayState_2 = new A.DisplayState("completed"); + B.InputType_Ip0 = new A.InputType("datetime-local", "dateTimeLocal"); + B.InputType_checkbox_checkbox = new A.InputType("checkbox", "checkbox"); + B.InputType_date_date = new A.InputType("date", "date"); + B.InputType_file_file = new A.InputType("file", "file"); + B.InputType_number_number = new A.InputType("number", "number"); + B.InputType_radio_radio = new A.InputType("radio", "radio"); + B.InputType_button_button = new A.InputType("button", "button"); + B.InputType_color_color = new A.InputType("color", "color"); + B.InputType_email_email = new A.InputType("email", "email"); + B.InputType_hidden_hidden = new A.InputType("hidden", "hidden"); + B.InputType_image_image = new A.InputType("image", "image"); + B.InputType_month_month = new A.InputType("month", "month"); + B.InputType_password_password = new A.InputType("password", "password"); + B.InputType_range_range = new A.InputType("range", "range"); + B.InputType_reset_reset = new A.InputType("reset", "reset"); + B.InputType_search_search = new A.InputType("search", "search"); + B.InputType_submit_submit = new A.InputType("submit", "submit"); + B.InputType_tel_tel = new A.InputType("tel", "tel"); + B.InputType_text_text = new A.InputType("text", "text"); + B.InputType_time_time = new A.InputType("time", "time"); + B.InputType_url_url = new A.InputType("url", "url"); + B.InputType_week_week = new A.InputType("week", "week"); + B.List_T5C = A._setArrayType(makeConstList([B.InputType_button_button, B.InputType_checkbox_checkbox, B.InputType_color_color, B.InputType_date_date, B.InputType_Ip0, B.InputType_email_email, B.InputType_file_file, B.InputType_hidden_hidden, B.InputType_image_image, B.InputType_month_month, B.InputType_number_number, B.InputType_password_password, B.InputType_radio_radio, B.InputType_range_range, B.InputType_reset_reset, B.InputType_search_search, B.InputType_submit_submit, B.InputType_tel_tel, B.InputType_text_text, B.InputType_time_time, B.InputType_url_url, B.InputType_week_week]), A.findType("JSArray")); + B.Object_svg_0_math_1 = {svg: 0, math: 1}; + B.Map_rvfri = new A.ConstantStringMap(B.Object_svg_0_math_1, ["http://www.w3.org/2000/svg", "http://www.w3.org/1998/Math/MathML"], A.findType("ConstantStringMap")); + B.Record2_Active_DisplayState_1 = new A._Record_2("Active", B.DisplayState_1); + B.Record2_All_DisplayState_0 = new A._Record_2("All", B.DisplayState_0); + B.Record2_Completed_DisplayState_2 = new A._Record_2("Completed", B.DisplayState_2); + B.SchedulerPhase_0 = new A.SchedulerPhase("idle"); + B.SchedulerPhase_1 = new A.SchedulerPhase("midFrameCallback"); + B.SchedulerPhase_2 = new A.SchedulerPhase("postFrameCallbacks"); + B.Type_ByteBuffer_rqD = A.typeLiteral("ByteBuffer"); + B.Type_ByteData_9dB = A.typeLiteral("ByteData"); + B.Type_Float32List_9Kz = A.typeLiteral("Float32List"); + B.Type_Float64List_9Kz = A.typeLiteral("Float64List"); + B.Type_Int16List_s5h = A.typeLiteral("Int16List"); + B.Type_Int32List_O8Z = A.typeLiteral("Int32List"); + B.Type_Int8List_rFV = A.typeLiteral("Int8List"); + B.Type_JSObject_ttY = A.typeLiteral("JSObject"); + B.Type_Object_A4p = A.typeLiteral("Object"); + B.Type_String_AXU = A.typeLiteral("String"); + B.Type_Uint16List_kmP = A.typeLiteral("Uint16List"); + B.Type_Uint32List_kmP = A.typeLiteral("Uint32List"); + B.Type_Uint8ClampedList_04U = A.typeLiteral("Uint8ClampedList"); + B.Type_Uint8List_8Eb = A.typeLiteral("Uint8List"); + B.Type__WrappingDomComponent_kh6 = A.typeLiteral("_WrappingDomComponent"); + B._ElementLifecycle_0 = new A._ElementLifecycle("initial"); + B._ElementLifecycle_1 = new A._ElementLifecycle("active"); + B._ElementLifecycle_2 = new A._ElementLifecycle("inactive"); + B._ElementLifecycle_3 = new A._ElementLifecycle("defunct"); + })(); + (function staticFields() { + $._JS_INTEROP_INTERCEPTOR_TAG = null; + $.toStringVisiting = A._setArrayType([], type$.JSArray_Object); + $.Primitives__identityHashCodeProperty = null; + $.BoundClosure__receiverFieldNameCache = null; + $.BoundClosure__interceptorFieldNameCache = null; + $.getTagFunction = null; + $.alternateTagFunction = null; + $.prototypeForTagFunction = null; + $.dispatchRecordsForInstanceTags = null; + $.interceptorsForUncacheableTags = null; + $.initNativeDispatchFlag = null; + $._Record__computedFieldKeys = A._setArrayType([], A.findType("JSArray?>")); + $._nextCallback = null; + $._lastCallback = null; + $._lastPriorityCallback = null; + $._isInCallbackLoop = false; + $.Zone__current = B.C__RootZone; + $.Element__nextHashCode = 1; + })(); + (function lazyInitializers() { + var _lazyFinal = hunkHelpers.lazyFinal; + _lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", () => A.getIsolateAffinityTag("_$dart_dartClosure")); + _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($, "_hashSeed", "$get$_hashSeed", () => A.objectHashCode(B.Type_Object_A4p)); + })(); + (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$0 = function() { + return this(); + }; + Function.prototype.call$1 = function(a) { + return this(a); + }; + 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$0 = function() { + return this(); + }; + 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([]); + } + }); +})(); + +//# sourceMappingURL=main.dart.js.map diff --git a/resources/todomvc/dart2wasm-jaspr/base.css b/resources/todomvc/dart2wasm-jaspr/base.css new file mode 100644 index 000000000..da65968a7 --- /dev/null +++ b/resources/todomvc/dart2wasm-jaspr/base.css @@ -0,0 +1,141 @@ +hr { + margin: 20px 0; + border: 0; + border-top: 1px dashed #c5c5c5; + border-bottom: 1px dashed #f7f7f7; +} + +.learn a { + font-weight: normal; + text-decoration: none; + color: #b83f45; +} + +.learn a:hover { + text-decoration: underline; + color: #787e7e; +} + +.learn h3, +.learn h4, +.learn h5 { + margin: 10px 0; + font-weight: 500; + line-height: 1.2; + color: #000; +} + +.learn h3 { + font-size: 24px; +} + +.learn h4 { + font-size: 18px; +} + +.learn h5 { + margin-bottom: 0; + font-size: 14px; +} + +.learn ul { + padding: 0; + margin: 0 0 30px 25px; +} + +.learn li { + line-height: 20px; +} + +.learn p { + font-size: 15px; + font-weight: 300; + line-height: 1.3; + margin-top: 0; + margin-bottom: 0; +} + +#issue-count { + display: none; +} + +.quote { + border: none; + margin: 20px 0 60px 0; +} + +.quote p { + font-style: italic; +} + +.quote p:before { + content: '“'; + font-size: 50px; + opacity: .15; + position: absolute; + top: -20px; + left: 3px; +} + +.quote p:after { + content: '”'; + font-size: 50px; + opacity: .15; + position: absolute; + bottom: -42px; + right: 3px; +} + +.quote footer { + position: absolute; + bottom: -40px; + right: 0; +} + +.quote footer img { + border-radius: 3px; +} + +.quote footer a { + margin-left: 5px; + vertical-align: middle; +} + +.speech-bubble { + position: relative; + padding: 10px; + background: rgba(0, 0, 0, .04); + border-radius: 5px; +} + +.speech-bubble:after { + content: ''; + position: absolute; + top: 100%; + right: 30px; + border: 13px solid transparent; + border-top-color: rgba(0, 0, 0, .04); +} + +.learn-bar > .learn { + position: absolute; + width: 272px; + top: 8px; + left: -300px; + padding: 10px; + border-radius: 5px; + background-color: rgba(255, 255, 255, .6); + transition-property: left; + transition-duration: 500ms; +} + +@media (min-width: 899px) { + .learn-bar { + width: auto; + padding-left: 300px; + } + + .learn-bar > .learn { + left: 8px; + } +} diff --git a/resources/todomvc/dart2wasm-jaspr/favicon.ico b/resources/todomvc/dart2wasm-jaspr/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..bd829b4fc70a3dc9baf443ebf39272c712b7bc46 GIT binary patch literal 2595 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 literal 0 HcmV?d00001 diff --git a/resources/todomvc/dart2wasm-jaspr/index.css b/resources/todomvc/dart2wasm-jaspr/index.css new file mode 100644 index 000000000..e2a84598a --- /dev/null +++ b/resources/todomvc/dart2wasm-jaspr/index.css @@ -0,0 +1,393 @@ +@charset "utf-8"; + +html, +body { + margin: 0; + padding: 0; +} + +button { + margin: 0; + padding: 0; + border: 0; + background: none; + font-size: 100%; + vertical-align: baseline; + font-family: inherit; + font-weight: inherit; + color: inherit; + -webkit-appearance: none; + appearance: none; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +body { + font: 14px 'Helvetica Neue', Helvetica, Arial, sans-serif; + line-height: 1.4em; + background: #f5f5f5; + color: #111111; + min-width: 230px; + max-width: 550px; + margin: 0 auto; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + font-weight: 300; +} + +.hidden { + display: none; +} + +.todoapp { + background: #fff; + margin: 130px 0 40px 0; + position: relative; + box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2), + 0 25px 50px 0 rgba(0, 0, 0, 0.1); +} + +.todoapp input::-webkit-input-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp input::-moz-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp input::input-placeholder { + font-style: italic; + font-weight: 400; + color: rgba(0, 0, 0, 0.4); +} + +.todoapp h1 { + position: absolute; + top: -140px; + width: 100%; + font-size: 80px; + font-weight: 200; + text-align: center; + color: #b83f45; + -webkit-text-rendering: optimizeLegibility; + -moz-text-rendering: optimizeLegibility; + text-rendering: optimizeLegibility; +} + +.new-todo, +.edit { + position: relative; + margin: 0; + width: 100%; + font-size: 24px; + font-family: inherit; + font-weight: inherit; + line-height: 1.4em; + color: inherit; + padding: 6px; + border: 1px solid #999; + box-shadow: inset 0 -1px 5px 0 rgba(0, 0, 0, 0.2); + box-sizing: border-box; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +.new-todo { + padding: 16px 16px 16px 60px; + height: 65px; + border: none; + background: rgba(0, 0, 0, 0.003); + box-shadow: inset 0 -2px 1px rgba(0,0,0,0.03); +} + +.main { + position: relative; + z-index: 2; + border-top: 1px solid #e6e6e6; +} + +.toggle-all { + width: 1px; + height: 1px; + border: none; /* Mobile Safari */ + opacity: 0; + position: absolute; + right: 100%; + bottom: 100%; +} + +.toggle-all + label { + display: flex; + align-items: center; + justify-content: center; + width: 45px; + height: 65px; + font-size: 0; + position: absolute; + top: -65px; + left: -0; +} + +.toggle-all + label:before { + content: '❯'; + display: inline-block; + font-size: 22px; + color: #949494; + padding: 10px 27px 10px 27px; + -webkit-transform: rotate(90deg); + transform: rotate(90deg); +} + +.toggle-all:checked + label:before { + color: #484848; +} + +.todo-list { + margin: 0; + padding: 0; + list-style: none; +} + +.todo-list li { + position: relative; + font-size: 24px; + border-bottom: 1px solid #ededed; +} + +.todo-list li:last-child { + border-bottom: none; +} + +.todo-list li.editing { + border-bottom: none; + padding: 0; +} + +.todo-list li.editing .edit { + display: block; + width: calc(100% - 43px); + padding: 12px 16px; + margin: 0 0 0 43px; +} + +.todo-list li.editing .view { + display: none; +} + +.todo-list li .toggle { + text-align: center; + width: 40px; + /* auto, since non-WebKit browsers doesn't support input styling */ + height: auto; + position: absolute; + top: 0; + bottom: 0; + margin: auto 0; + border: none; /* Mobile Safari */ + -webkit-appearance: none; + appearance: none; +} + +.todo-list li .toggle { + opacity: 0; +} + +.todo-list li .toggle + label { + /* + Firefox requires `#` to be escaped - https://bugzilla.mozilla.org/show_bug.cgi?id=922433 + IE and Edge requires *everything* to be escaped to render, so we do that instead of just the `#` - https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/7157459/ + */ + background-image: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%23949494%22%20stroke-width%3D%223%22/%3E%3C/svg%3E'); + background-repeat: no-repeat; + background-position: center left; +} + +.todo-list li .toggle:checked + label { + background-image: url('data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%2359A193%22%20stroke-width%3D%223%22%2F%3E%3Cpath%20fill%3D%22%233EA390%22%20d%3D%22M72%2025L42%2071%2027%2056l-4%204%2020%2020%2034-52z%22%2F%3E%3C%2Fsvg%3E'); +} + +.todo-list li label { + word-break: break-all; + padding: 15px 15px 15px 60px; + display: block; + line-height: 1.2; + transition: color 0.4s; + font-weight: 400; + color: #484848; +} + +.todo-list li.completed label { + color: #949494; + text-decoration: line-through; +} + +.todo-list li .destroy { + display: none; + position: absolute; + top: 0; + right: 10px; + bottom: 0; + width: 40px; + height: 40px; + margin: auto 0; + font-size: 30px; + color: #949494; + transition: color 0.2s ease-out; +} + +.todo-list li .destroy:hover, +.todo-list li .destroy:focus { + color: #C18585; +} + +.todo-list li .destroy:after { + content: '×'; + display: block; + height: 100%; + line-height: 1.1; +} + +.todo-list li:hover .destroy { + display: block; +} + +.todo-list li .edit { + display: none; +} + +.todo-list li.editing:last-child { + margin-bottom: -1px; +} + +.footer { + padding: 10px 15px; + height: 20px; + text-align: center; + font-size: 15px; + border-top: 1px solid #e6e6e6; +} + +.footer:before { + content: ''; + position: absolute; + right: 0; + bottom: 0; + left: 0; + height: 50px; + overflow: hidden; + box-shadow: 0 1px 1px rgba(0, 0, 0, 0.2), + 0 8px 0 -3px #f6f6f6, + 0 9px 1px -3px rgba(0, 0, 0, 0.2), + 0 16px 0 -6px #f6f6f6, + 0 17px 2px -6px rgba(0, 0, 0, 0.2); +} + +.todo-count { + float: left; + text-align: left; +} + +.todo-count strong { + font-weight: 300; +} + +.filters { + margin: 0; + padding: 0; + list-style: none; + position: absolute; + right: 0; + left: 0; +} + +.filters li { + display: inline; +} + +.filters li span { + color: inherit; + margin: 3px; + padding: 3px 7px; + text-decoration: none; + border: 1px solid transparent; + border-radius: 3px; +} + +.filters li span:hover { + border-color: #DB7676; +} + +.filters li span.selected { + border-color: #CE4646; +} + +.clear-completed, +html .clear-completed:active { + float: right; + position: relative; + line-height: 19px; + text-decoration: none; + cursor: pointer; +} + +.clear-completed:hover { + text-decoration: underline; +} + +.info { + margin: 65px auto 0; + color: #4d4d4d; + font-size: 11px; + text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5); + text-align: center; +} + +.info p { + line-height: 1; +} + +.info a { + color: inherit; + text-decoration: none; + font-weight: 400; +} + +.info a:hover { + text-decoration: underline; +} + +/* + Hack to remove background from Mobile Safari. + Can't use it globally since it destroys checkboxes in Firefox +*/ +@media screen and (-webkit-min-device-pixel-ratio:0) { + .toggle-all, + .todo-list li .toggle { + background: none; + } + + .todo-list li .toggle { + height: 40px; + } +} + +@media (max-width: 430px) { + .footer { + height: 50px; + } + + .filters { + bottom: 10px; + } +} + +:focus, +.toggle:focus + label, +.toggle-all:focus + label { + box-shadow: 0 0 2px 2px #CF7D7D; + outline: 0; +} diff --git a/resources/todomvc/dart2wasm-jaspr/index.html b/resources/todomvc/dart2wasm-jaspr/index.html new file mode 100644 index 000000000..287dd21fd --- /dev/null +++ b/resources/todomvc/dart2wasm-jaspr/index.html @@ -0,0 +1,22 @@ + + + + + + + + TodoMVC: Jaspr + + + + + + + + + + + diff --git a/resources/todomvc/dart2wasm-jaspr/main.dart.js b/resources/todomvc/dart2wasm-jaspr/main.dart.js new file mode 100644 index 000000000..0ffea7608 --- /dev/null +++ b/resources/todomvc/dart2wasm-jaspr/main.dart.js @@ -0,0 +1,15 @@ +(async () => { +const thisScript = document.currentScript; + +function relativeURL(ref) { + const base = thisScript?.src ?? document.baseURI; + return new URL(ref, base).toString(); +} + +let { compileStreaming } = await import("./main.mjs"); + +let app = await compileStreaming(fetch(relativeURL("main.wasm"))); +let module = await app.instantiate({}); +module.invokeMain(); + +})(); diff --git a/resources/todomvc/dart2wasm-jaspr/main.mjs b/resources/todomvc/dart2wasm-jaspr/main.mjs new file mode 100644 index 000000000..b2bd62aef --- /dev/null +++ b/resources/todomvc/dart2wasm-jaspr/main.mjs @@ -0,0 +1,599 @@ +// Compiles a dart2wasm-generated main module from `source` which can then +// instantiatable via the `instantiate` method. +// +// `source` needs to be a `Response` object (or promise thereof) e.g. created +// via the `fetch()` JS API. +export async function compileStreaming(source) { + const builtins = {builtins: ['js-string']}; + return new CompiledApp( + await WebAssembly.compileStreaming(source, builtins), builtins); +} + +// Compiles a dart2wasm-generated wasm modules from `bytes` which is then +// instantiatable via the `instantiate` method. +export async function compile(bytes) { + const builtins = {builtins: ['js-string']}; + return new CompiledApp(await WebAssembly.compile(bytes, builtins), builtins); +} + +// DEPRECATED: Please use `compile` or `compileStreaming` to get a compiled app, +// use `instantiate` method to get an instantiated app and then call +// `invokeMain` to invoke the main function. +export async function instantiate(modulePromise, importObjectPromise) { + var moduleOrCompiledApp = await modulePromise; + if (!(moduleOrCompiledApp instanceof CompiledApp)) { + moduleOrCompiledApp = new CompiledApp(moduleOrCompiledApp); + } + const instantiatedApp = await moduleOrCompiledApp.instantiate(await importObjectPromise); + return instantiatedApp.instantiatedModule; +} + +// DEPRECATED: Please use `compile` or `compileStreaming` to get a compiled app, +// use `instantiate` method to get an instantiated app and then call +// `invokeMain` to invoke the main function. +export const invoke = (moduleInstance, ...args) => { + moduleInstance.exports.$invokeMain(args); +} + +class CompiledApp { + constructor(module, builtins) { + this.module = module; + this.builtins = builtins; + } + + // The second argument is an options object containing: + // `loadDeferredWasm` is a JS function that takes a module name matching a + // wasm file produced by the dart2wasm compiler and returns the bytes to + // load the module. These bytes can be in either a format supported by + // `WebAssembly.compile` or `WebAssembly.compileStreaming`. + async instantiate(additionalImports, {loadDeferredWasm, loadDynamicModule} = {}) { + let dartInstance; + + // Prints to the console + function printToConsole(value) { + if (typeof dartPrint == "function") { + dartPrint(value); + return; + } + if (typeof console == "object" && typeof console.log != "undefined") { + console.log(value); + return; + } + if (typeof print == "function") { + print(value); + return; + } + + throw "Unable to print message: " + js; + } + + // Converts a Dart List to a JS array. Any Dart objects will be converted, but + // this will be cheap for JSValues. + function arrayFromDartList(constructor, list) { + const exports = dartInstance.exports; + const read = exports.$listRead; + const length = exports.$listLength(list); + const array = new constructor(length); + for (let i = 0; i < length; i++) { + array[i] = read(list, i); + } + return array; + } + + // A special symbol attached to functions that wrap Dart functions. + const jsWrappedDartFunctionSymbol = Symbol("JSWrappedDartFunction"); + + function finalizeWrapper(dartFunction, wrapped) { + wrapped.dartFunction = dartFunction; + wrapped[jsWrappedDartFunctionSymbol] = true; + return wrapped; + } + + // Imports + const dart2wasm = { + _42: (o, c) => o instanceof c, + _81: () => { + let stackString = new Error().stack.toString(); + let frames = stackString.split('\n'); + let drop = 2; + if (frames[0] === 'Error') { + drop += 1; + } + return frames.slice(drop).join('\n'); + }, + _109: s => JSON.stringify(s), + _111: s => printToConsole(s), + _114: Function.prototype.call.bind(String.prototype.toLowerCase), + _120: Function.prototype.call.bind(String.prototype.indexOf), + _122: (string, token) => string.split(token), + _123: Object.is, + _124: (a, i) => a.push(i), + _134: a => a.length, + _136: (a, i) => a[i], + _140: (o, start, length) => new Uint8Array(o.buffer, o.byteOffset + start, length), + _141: (o, start, length) => new Int8Array(o.buffer, o.byteOffset + start, length), + _142: (o, start, length) => new Uint8ClampedArray(o.buffer, o.byteOffset + start, length), + _143: (o, start, length) => new Uint16Array(o.buffer, o.byteOffset + start, length), + _144: (o, start, length) => new Int16Array(o.buffer, o.byteOffset + start, length), + _145: (o, start, length) => new Uint32Array(o.buffer, o.byteOffset + start, length), + _146: (o, start, length) => new Int32Array(o.buffer, o.byteOffset + start, length), + _149: (o, start, length) => new Float32Array(o.buffer, o.byteOffset + start, length), + _150: (o, start, length) => new Float64Array(o.buffer, o.byteOffset + start, length), + _153: (o) => new DataView(o.buffer, o.byteOffset, o.byteLength), + _157: Function.prototype.call.bind(Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength').get), + _158: (b, o) => new DataView(b, o), + _160: Function.prototype.call.bind(DataView.prototype.getUint8), + _162: Function.prototype.call.bind(DataView.prototype.getInt8), + _164: Function.prototype.call.bind(DataView.prototype.getUint16), + _166: Function.prototype.call.bind(DataView.prototype.getInt16), + _168: Function.prototype.call.bind(DataView.prototype.getUint32), + _170: Function.prototype.call.bind(DataView.prototype.getInt32), + _176: Function.prototype.call.bind(DataView.prototype.getFloat32), + _178: Function.prototype.call.bind(DataView.prototype.getFloat64), + _205: (c) => + queueMicrotask(() => dartInstance.exports.$invokeCallback(c)), + _213: (x0,x1) => x0.createElement(x1), + _216: f => finalizeWrapper(f, function(x0) { return dartInstance.exports._216(f,arguments.length,x0) }), + _218: (x0,x1,x2,x3) => x0.addEventListener(x1,x2,x3), + _219: (x0,x1,x2,x3) => x0.removeEventListener(x1,x2,x3), + _227: (x0,x1) => x0.item(x1), + _228: (x0,x1,x2) => x0.createElementNS(x1,x2), + _229: (x0,x1) => x0.item(x1), + _230: (x0,x1,x2) => x0.replaceChild(x1,x2), + _231: (x0,x1) => x0.append(x1), + _232: (x0,x1) => x0.item(x1), + _233: (x0,x1) => x0.removeAttribute(x1), + _234: x0 => new Text(x0), + _235: (x0,x1) => x0.replaceWith(x1), + _236: (x0,x1) => x0.item(x1), + _237: (x0,x1,x2) => x0.insertBefore(x1,x2), + _238: (x0,x1,x2) => x0.insertBefore(x1,x2), + _239: (x0,x1) => x0.removeChild(x1), + _240: (x0,x1) => x0.removeChild(x1), + _241: (x0,x1) => x0.hasAttribute(x1), + _242: (x0,x1) => x0.removeAttribute(x1), + _243: (x0,x1) => x0.getAttribute(x1), + _244: (x0,x1,x2) => x0.setAttribute(x1,x2), + _246: (x0,x1) => x0.querySelector(x1), + _263: (x0,x1) => x0.item(x1), + _287: o => o === undefined, + _306: o => typeof o === 'function' && o[jsWrappedDartFunctionSymbol] === true, + _310: (l, r) => l === r, + _311: o => o, + _312: o => o, + _313: o => o, + _314: b => !!b, + _315: o => o.length, + _318: (o, i) => o[i], + _319: f => f.dartFunction, + _320: l => arrayFromDartList(Int8Array, l), + _321: l => arrayFromDartList(Uint8Array, l), + _322: l => arrayFromDartList(Uint8ClampedArray, l), + _323: l => arrayFromDartList(Int16Array, l), + _324: l => arrayFromDartList(Uint16Array, l), + _325: l => arrayFromDartList(Int32Array, l), + _326: l => arrayFromDartList(Uint32Array, l), + _327: l => arrayFromDartList(Float32Array, l), + _328: l => arrayFromDartList(Float64Array, l), + _330: (data, length) => { + const getValue = dartInstance.exports.$byteDataGetUint8; + const view = new DataView(new ArrayBuffer(length)); + for (let i = 0; i < length; i++) { + view.setUint8(i, getValue(data, i)); + } + return view; + }, + _331: l => arrayFromDartList(Array, l), + _335: () => globalThis, + _338: (o, p) => o[p], + _342: o => String(o), + _344: o => { + if (o === undefined) return 1; + var type = typeof o; + if (type === 'boolean') return 2; + if (type === 'number') return 3; + if (type === 'string') return 4; + if (o instanceof Array) return 5; + if (ArrayBuffer.isView(o)) { + if (o instanceof Int8Array) return 6; + if (o instanceof Uint8Array) return 7; + if (o instanceof Uint8ClampedArray) return 8; + if (o instanceof Int16Array) return 9; + if (o instanceof Uint16Array) return 10; + if (o instanceof Int32Array) return 11; + if (o instanceof Uint32Array) return 12; + if (o instanceof Float32Array) return 13; + if (o instanceof Float64Array) return 14; + if (o instanceof DataView) return 15; + } + if (o instanceof ArrayBuffer) return 16; + return 17; + }, + _370: (o, p) => o[p], + _373: x0 => x0.random(), + _374: x0 => x0.random(), + _378: () => globalThis.Math, + _380: Function.prototype.call.bind(Number.prototype.toString), + _381: Function.prototype.call.bind(BigInt.prototype.toString), + _382: Function.prototype.call.bind(Number.prototype.toString), + _1464: x0 => x0.checked, + _1471: x0 => x0.files, + _1514: x0 => x0.type, + _1518: x0 => x0.value, + _1519: (x0,x1) => x0.value = x1, + _1520: x0 => x0.valueAsDate, + _1522: x0 => x0.valueAsNumber, + _1607: x0 => x0.selectedOptions, + _1630: x0 => x0.value, + _1669: x0 => x0.value, + _4919: x0 => x0.target, + _4971: x0 => x0.length, + _4974: x0 => x0.length, + _5026: x0 => x0.parentNode, + _5028: x0 => x0.childNodes, + _5031: x0 => x0.previousSibling, + _5032: x0 => x0.nextSibling, + _5035: x0 => x0.textContent, + _5036: (x0,x1) => x0.textContent = x1, + _5040: () => globalThis.document, + _5478: x0 => x0.namespaceURI, + _5481: x0 => x0.tagName, + _5489: x0 => x0.attributes, + _5618: x0 => x0.length, + _5622: x0 => x0.name, + + }; + + const baseImports = { + dart2wasm: dart2wasm, + Math: Math, + Date: Date, + Object: Object, + Array: Array, + Reflect: Reflect, + s: [ + "Too few arguments passed. Expected 1 or more, got ", +"Infinity or NaN toInt", +" instead.", +"null", +"", +" (", +")", +": ", +"Instance of '", +"'", +"Object?", +"Object", +"dynamic", +"void", +"Invalid top type kind", +"minified:Class", +"<", +", ", +">", +"?", +"Attempt to execute code removed by Dart AOT compiler (TFA)", +"T", +"Invalid argument", +"(s)", +"0.0", +"-0.0", +"1.0", +"-1.0", +"NaN", +"-Infinity", +"Infinity", +"e", +".0", +"RangeError (details omitted due to --minify)", +"Unsupported operation: ", +"true", +"false", +"Null check operator used on a null value", +"Division resulted in non-finite value", +"IntegerDivisionByZeroException", +"Type '", +"' is not a subtype of type '", +" in type cast", +"Null", +"Never", +"X", +" extends ", +"(", +"[", +"]", +"{", +"}", +" => ", +"Closure: ", +"...", +"Runtime type check failed (details omitted due to --minify)", +"Type argument substitution not supported for ", +"Type parameter should have been substituted already.", +" ", +"FutureOr", +"required ", +"Concurrent modification during iteration: ", +".", +"Unhandled dartifyRaw type case: ", +"{...}", +"Function?", +"Function", +"buffer", +"Too few arguments passed. Expected 2 or more, got ", +"Expected integer value, but was not integer.", +"Too few arguments passed. Expected 0 or more, got ", +"Cannot add to a fixed-length list", +"Could not call main", +"JavaScriptError", +"body", +"Future already completed", +"onError", +"Error handler must accept one Object or one Object and a StackTrace as arguments, and return a value of the returned future's type", +"Cannot complete a future with itself", +"The error handler of Future.then must return a value of the returned future's type", +"The error handler of Future.catchError must return a value of the future's type", +"_stackTrace=", +"Cannot add to an unmodifiable list", +"NoSuchMethodError: method not found: '", +"'\n", +"Receiver: ", +"\n", +"Arguments: [", +"Symbol(\"", +"\")", +":", +"s", +"@", +",", +"=", +"IndexError (details omitted due to --minify)", +"IntegerDivisionByZeroException._stackTrace", +"_stackTrace", +"Bad state: ", +"active", +"_ElementLifecycle.", +"Field 'beforeStart' has already been initialized.", +"LateInitializationError: ", +"(...)", +"attachTarget", +"Field '", +"' has not been initialized.", +"attachBetween", +"initial", +"beforeStart", +"inactive", +"div", +"Error on building component: ", +"Error: ", +"Text", +"svg", +"http://www.w3.org/2000/svg", +"math", +"http://www.w3.org/1998/Math/MathML", +"Element", +"id", +"class", +"style", +"value", +"HTMLInputElement", +"call", +"MapEntry(", +"; ", +"http://www.w3.org/1999/xhtml", +"elem", +"Local '", +"attributesToRemove", +"info", +"Double-click to edit a todo", +"Created by the Dart team", +"Part of ", +"http://todomvc.com", +"TodoMVC", +"footer", +"a", +"href", +"p", +"all", +"isActive", +"todo", +"DisplayState.", +"root", +"todoapp", +"header", +"data-testid", +"todos", +"input-container", +"main", +"display", +"none;", +"block;", +"toggle-all-container", +"toggle-all", +"checkbox", +"checked", +"toggle-all-label", +"for", +"Mark all as complete", +"todo-list", +"completed", +"data-id", +"view", +"toggle", +"-", +"destroy", +"todo-count", +" item", +" left", +"filters", +"All", +"Active", +"Completed", +"selected", +"click", +"clear-completed", +"Clear completed", +"section", +"midFrameCallback", +"postFrameCallbacks", +"idle", +"Error on rebuilding component: ", +"defunct", +"SchedulerPhase.", +"span", +"strong", +"ul", +"li", +"button", +"autofocus", +"disabled", +"input", +"change", +"color", +"date", +"datetime-local", +"dateTimeLocal", +"email", +"file", +"hidden", +"image", +"month", +"number", +"password", +"radio", +"range", +"reset", +"search", +"submit", +"tel", +"text", +"time", +"url", +"week", +"HTMLTextAreaElement", +"HTMLSelectElement", +"HTMLOptionElement", +"<'", +"'>", +"label", +"type", +"InputType.", +"isActive: ", +"todo: ", +"new-todo", +"placeholder", +"What needs to be done?", +"h1" + ], + + }; + + const jsStringPolyfill = { + "charCodeAt": (s, i) => s.charCodeAt(i), + "compare": (s1, s2) => { + if (s1 < s2) return -1; + if (s1 > s2) return 1; + return 0; + }, + "concat": (s1, s2) => s1 + s2, + "equals": (s1, s2) => s1 === s2, + "fromCharCode": (i) => String.fromCharCode(i), + "length": (s) => s.length, + "substring": (s, a, b) => s.substring(a, b), + "fromCharCodeArray": (a, start, end) => { + if (end <= start) return ''; + + const read = dartInstance.exports.$wasmI16ArrayGet; + let result = ''; + let index = start; + const chunkLength = Math.min(end - index, 500); + let array = new Array(chunkLength); + while (index < end) { + const newChunkLength = Math.min(end - index, 500); + for (let i = 0; i < newChunkLength; i++) { + array[i] = read(a, index++); + } + if (newChunkLength < chunkLength) { + array = array.slice(0, newChunkLength); + } + result += String.fromCharCode(...array); + } + return result; + }, + "intoCharCodeArray": (s, a, start) => { + if (s == '') return 0; + + const write = dartInstance.exports.$wasmI16ArraySet; + for (var i = 0; i < s.length; ++i) { + write(a, start++, s.charCodeAt(i)); + } + return s.length; + }, + }; + + + const loadModuleFromBytes = async (bytes) => { + const module = await WebAssembly.compile(bytes, this.builtins); + return await WebAssembly.instantiate(module, { + ...baseImports, + ...additionalImports, + "wasm:js-string": jsStringPolyfill, + "module0": dartInstance.exports, + }); + } + + const loadModule = async (loader, loaderArgument) => { + const source = await Promise.resolve(loader(loaderArgument)); + const module = await ((source instanceof Response) + ? WebAssembly.compileStreaming(source, this.builtins) + : WebAssembly.compile(source, this.builtins)); + return await WebAssembly.instantiate(module, { + ...baseImports, + ...additionalImports, + "wasm:js-string": jsStringPolyfill, + "module0": dartInstance.exports, + }); + } + + const deferredLibraryHelper = { + "loadModule": async (moduleName) => { + if (!loadDeferredWasm) { + throw "No implementation of loadDeferredWasm provided."; + } + return await loadModule(loadDeferredWasm, moduleName); + }, + "loadDynamicModuleFromUri": async (uri) => { + if (!loadDynamicModule) { + throw "No implementation of loadDynamicModule provided."; + } + const loadedModule = await loadModule(loadDynamicModule, uri); + return loadedModule.exports.$invokeEntryPoint; + }, + "loadDynamicModuleFromBytes": async (bytes) => { + const loadedModule = await loadModuleFromBytes(loadDynamicModule, uri); + return loadedModule.exports.$invokeEntryPoint; + }, + }; + + dartInstance = await WebAssembly.instantiate(this.module, { + ...baseImports, + ...additionalImports, + "deferredLibraryHelper": deferredLibraryHelper, + "wasm:js-string": jsStringPolyfill, + }); + + return new InstantiatedApp(this, dartInstance); + } +} + +class InstantiatedApp { + constructor(compiledApp, instantiatedModule) { + this.compiledApp = compiledApp; + this.instantiatedModule = instantiatedModule; + } + + // Call the main function with the given arguments. + invokeMain(...args) { + this.instantiatedModule.exports.$invokeMain(args); + } +} diff --git a/resources/todomvc/dart2wasm-jaspr/main.wasm b/resources/todomvc/dart2wasm-jaspr/main.wasm new file mode 100644 index 0000000000000000000000000000000000000000..072526ad98fcf095a9ca52abe5bdd82bfecb2dc8 GIT binary patch literal 115194 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 fOSq65%=hq$