Created
November 13, 2013 02:00
-
-
Save onlyangel/7442305 to your computer and use it in GitHub Desktop.
Para victor y su prueba de inputTexts
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import 'dart:html'; | |
| void main() { | |
| querySelectorAll("input:not([value]),input[value='']").forEach((Element e)=>e.classes.add("empty")); | |
| querySelectorAll("input").forEach((InputElement e){ | |
| e | |
| ..onInput.listen((ev)=>changeClasss(e)) | |
| ..onKeyUp.listen((ev)=>changeClasss(e)); | |
| }); | |
| } | |
| void changeClasss(InputElement e){ | |
| e.classes.toggle("empty", e.value==""); | |
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated by dart2js, the Dart to JavaScript compiler. | |
| // The code supports the following hooks: | |
| // dartPrint(message) - if this function is defined it is called | |
| // instead of the Dart [print] method. | |
| // dartMainRunner(main) - if this function is defined, the Dart [main] | |
| // method will not be invoked directly. | |
| // Instead, a closure that will invoke [main] is | |
| // passed to [dartMainRunner]. | |
| (function($) { | |
| var A = {}; | |
| delete A.x; | |
| var B = {}; | |
| delete B.x; | |
| var C = {}; | |
| delete C.x; | |
| var D = {}; | |
| delete D.x; | |
| var E = {}; | |
| delete E.x; | |
| var F = {}; | |
| delete F.x; | |
| var G = {}; | |
| delete G.x; | |
| var H = {}; | |
| delete H.x; | |
| var J = {}; | |
| delete J.x; | |
| var K = {}; | |
| delete K.x; | |
| var L = {}; | |
| delete L.x; | |
| var M = {}; | |
| delete M.x; | |
| var N = {}; | |
| delete N.x; | |
| var O = {}; | |
| delete O.x; | |
| var P = {}; | |
| delete P.x; | |
| var Q = {}; | |
| delete Q.x; | |
| var R = {}; | |
| delete R.x; | |
| var S = {}; | |
| delete S.x; | |
| var T = {}; | |
| delete T.x; | |
| var U = {}; | |
| delete U.x; | |
| var V = {}; | |
| delete V.x; | |
| var W = {}; | |
| delete W.x; | |
| var X = {}; | |
| delete X.x; | |
| var Y = {}; | |
| delete Y.x; | |
| var Z = {}; | |
| delete Z.x; | |
| function Isolate() {} | |
| init(); | |
| $ = Isolate.$isolateProperties; | |
| var $$ = {}; | |
| // Native classes | |
| // Method closures | |
| $$.BoundClosure$i0 = [H, {"": "BoundClosure;_self,_target,_receiver,__js_helper$_name", | |
| call$0: function() { | |
| return this._target.call(this._self, this._receiver); | |
| } | |
| }]; | |
| $$.BoundClosure$1 = [H, {"": "BoundClosure;_self,_target,_receiver,__js_helper$_name", | |
| call$1: function(p0) { | |
| return this._target.call(this._self, p0); | |
| }, | |
| $is_args1: true | |
| }]; | |
| $$.BoundClosure$0 = [P, {"": "BoundClosure;_self,_target,_receiver,__js_helper$_name", | |
| call$0: function() { | |
| return this._target.call(this._self); | |
| } | |
| }]; | |
| $$.BoundClosure$i1 = [P, {"": "BoundClosure;_self,_target,_receiver,__js_helper$_name", | |
| call$1: function(p0) { | |
| return this._target.call(this._self, this._receiver, p0); | |
| }, | |
| $is_args1: true | |
| }]; | |
| $$.BoundClosure$2 = [P, {"": "BoundClosure;_self,_target,_receiver,__js_helper$_name", | |
| call$2: function(p0, p1) { | |
| return this._target.call(this._self, p0, p1); | |
| }, | |
| call$1: function(p0) { | |
| return this.call$2(p0, null); | |
| }, | |
| $is_args2: true, | |
| $is_args1: true | |
| }]; | |
| $$.Closure$2 = [H, {"": "Closure;call$2,$name", $is_args2: true}]; | |
| $$.Closure$0 = [H, {"": "Closure;call$0,$name"}]; | |
| $$.Closure$7 = [H, {"": "Closure;call$7,$name"}]; | |
| $$.Closure$1 = [P, {"": "Closure;call$1,$name", $is_args1: true}]; | |
| $$.Closure$20 = [P, {"": "Closure;call$2,$name", | |
| call$1: function(p0) { | |
| return this.call$2(p0, null); | |
| }, | |
| $is_args2: true, | |
| $is_args1: true | |
| }]; | |
| (function (reflectionData) { | |
| function map(x){x={x:x};delete x.x;return x} | |
| if (!init.libraries) init.libraries = []; | |
| if (!init.mangledNames) init.mangledNames = map(); | |
| if (!init.mangledGlobalNames) init.mangledGlobalNames = map(); | |
| if (!init.statics) init.statics = map(); | |
| if (!init.typeInformation) init.typeInformation = map(); | |
| if (!init.globalFunctions) init.globalFunctions = map(); | |
| var libraries = init.libraries; | |
| var mangledNames = init.mangledNames; | |
| var mangledGlobalNames = init.mangledGlobalNames; | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| var length = reflectionData.length; | |
| for (var i = 0; i < length; i++) { | |
| var data = reflectionData[i]; | |
| var name = data[0]; | |
| var uri = data[1]; | |
| var metadata = data[2]; | |
| var globalObject = data[3]; | |
| var descriptor = data[4]; | |
| var isRoot = !!data[5]; | |
| var fields = descriptor && descriptor[""]; | |
| var classes = []; | |
| var functions = []; | |
| function processStatics(descriptor) { | |
| for (var property in descriptor) { | |
| if (!hasOwnProperty.call(descriptor, property)) continue; | |
| if (property === "") continue; | |
| var element = descriptor[property]; | |
| var firstChar = property.substring(0, 1); | |
| var previousProperty; | |
| if (firstChar === "+") { | |
| mangledGlobalNames[previousProperty] = property.substring(1); | |
| if (descriptor[property] == 1) descriptor[previousProperty].$reflectable = 1; | |
| if (element && element.length) init.typeInformation[previousProperty] = element; | |
| } else if (firstChar === "@") { | |
| property = property.substring(1); | |
| $[property]["@"] = element; | |
| } else if (firstChar === "*") { | |
| globalObject[previousProperty].$defaultValues = element; | |
| var optionalMethods = descriptor.$methodsWithOptionalArguments; | |
| if (!optionalMethods) { | |
| descriptor.$methodsWithOptionalArguments = optionalMethods = {} | |
| } | |
| optionalMethods[property] = previousProperty; | |
| } else if (typeof element === "function") { | |
| globalObject[previousProperty = property] = element; | |
| functions.push(property); | |
| init.globalFunctions[property] = element; | |
| } else { | |
| previousProperty = property; | |
| var newDesc = {}; | |
| var previousProp; | |
| for (var prop in element) { | |
| if (!hasOwnProperty.call(element, prop)) continue; | |
| firstChar = prop.substring(0, 1); | |
| if (prop === "static") { | |
| processStatics(init.statics[property] = element[prop]); | |
| } else if (firstChar === "+") { | |
| mangledNames[previousProp] = prop.substring(1); | |
| if (element[prop] == 1) element[previousProp].$reflectable = 1; | |
| } else if (firstChar === "@" && prop !== "@") { | |
| newDesc[prop.substring(1)]["@"] = element[prop]; | |
| } else if (firstChar === "*") { | |
| newDesc[previousProp].$defaultValues = element[prop]; | |
| var optionalMethods = newDesc.$methodsWithOptionalArguments; | |
| if (!optionalMethods) { | |
| newDesc.$methodsWithOptionalArguments = optionalMethods={} | |
| } | |
| optionalMethods[prop] = previousProp; | |
| } else { | |
| newDesc[previousProp = prop] = element[prop]; | |
| } | |
| } | |
| $$[property] = [globalObject, newDesc]; | |
| classes.push(property); | |
| } | |
| } | |
| } | |
| processStatics(descriptor); | |
| libraries.push([name, uri, classes, functions, metadata, fields, isRoot, | |
| globalObject]); | |
| } | |
| })([ | |
| ["_foreign_helper", "dart:_foreign_helper", , H, { | |
| JS_CONST: {"": "Object;code"}}], | |
| ["_interceptors", "dart:_interceptors", , J, { | |
| getInterceptor: function(object) { | |
| return void 0; | |
| }, | |
| makeDispatchRecord: function(interceptor, proto, extension, indexability) { | |
| return {i: interceptor, p: proto, e: extension, x: indexability}; | |
| }, | |
| getNativeInterceptor: function(object) { | |
| var record, proto, objectProto, interceptor; | |
| record = object[init.dispatchPropertyName]; | |
| if (record == null) | |
| if ($.initNativeDispatchFlag == null) { | |
| H.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 H.wrapException(P.UnimplementedError$("Return interceptor for " + H.S(proto(object, record)))); | |
| } | |
| interceptor = H.lookupAndCacheInterceptor(object); | |
| if (interceptor == null) | |
| return C.UnknownJavaScriptObject_methods; | |
| return interceptor; | |
| }, | |
| Interceptor: {"": "Object;", | |
| $eq: function(receiver, other) { | |
| return receiver === other; | |
| }, | |
| get$hashCode: function(receiver) { | |
| return H.Primitives_objectHashCode(receiver); | |
| }, | |
| toString$0: function(receiver) { | |
| return H.Primitives_objectToString(receiver); | |
| }, | |
| "%": "DOMError|FileError|MediaError|MediaKeyError|Navigator|NavigatorUserMediaError|PositionError|SQLError|SVGAnimatedNumberList" | |
| }, | |
| JSBool: {"": "bool/Interceptor;", | |
| toString$0: function(receiver) { | |
| return String(receiver); | |
| }, | |
| get$hashCode: function(receiver) { | |
| return receiver ? 519018 : 218159; | |
| }, | |
| $isbool: true | |
| }, | |
| JSNull: {"": "Interceptor;", | |
| $eq: function(receiver, other) { | |
| return null == other; | |
| }, | |
| toString$0: function(receiver) { | |
| return "null"; | |
| }, | |
| get$hashCode: function(receiver) { | |
| return 0; | |
| } | |
| }, | |
| JavaScriptObject: {"": "Interceptor;", | |
| get$hashCode: function(_) { | |
| return 0; | |
| } | |
| }, | |
| PlainJavaScriptObject: {"": "JavaScriptObject;"}, | |
| UnknownJavaScriptObject: {"": "JavaScriptObject;"}, | |
| JSArray: {"": "List/Interceptor;", | |
| add$1: function(receiver, value) { | |
| if (!!receiver.fixed$length) | |
| H.throwExpression(P.UnsupportedError$("add")); | |
| receiver.push(value); | |
| }, | |
| forEach$1: function(receiver, f) { | |
| return H.IterableMixinWorkaround_forEach(receiver, f); | |
| }, | |
| join$1: function(receiver, separator) { | |
| var t1, list, i, t2; | |
| t1 = receiver.length; | |
| list = P.List_List(t1, null); | |
| for (i = 0; i < receiver.length; ++i) { | |
| t2 = H.S(receiver[i]); | |
| if (i >= t1) | |
| throw H.ioore(list, i); | |
| list[i] = t2; | |
| } | |
| return list.join(separator); | |
| }, | |
| elementAt$1: function(receiver, index) { | |
| if (index < 0 || index >= receiver.length) | |
| throw H.ioore(receiver, index); | |
| return receiver[index]; | |
| }, | |
| toString$0: function(receiver) { | |
| return H.IterableMixinWorkaround_toStringIterable(receiver, "[", "]"); | |
| }, | |
| toList$1$growable: function(receiver, growable) { | |
| return P.List_List$from(receiver, growable, H.getRuntimeTypeArgument(receiver, "JSArray", 0)); | |
| }, | |
| toList$0: function($receiver) { | |
| return this.toList$1$growable($receiver, true); | |
| }, | |
| get$iterator: function(receiver) { | |
| return new H.ListIterator(receiver, receiver.length, 0, null); | |
| }, | |
| get$hashCode: function(receiver) { | |
| return H.Primitives_objectHashCode(receiver); | |
| }, | |
| get$length: function(receiver) { | |
| return receiver.length; | |
| }, | |
| $index: function(receiver, index) { | |
| if (typeof index !== "number" || Math.floor(index) !== index) | |
| throw H.wrapException(new P.ArgumentError(index)); | |
| if (index >= receiver.length || index < 0) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| return receiver[index]; | |
| }, | |
| $indexSet: function(receiver, index, value) { | |
| if (!!receiver.immutable$list) | |
| H.throwExpression(P.UnsupportedError$("indexed set")); | |
| if (typeof index !== "number" || Math.floor(index) !== index) | |
| throw H.wrapException(new P.ArgumentError(index)); | |
| if (index >= receiver.length || index < 0) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| receiver[index] = value; | |
| }, | |
| $isList: true, | |
| $asList: null, | |
| $isList: true, | |
| $isEfficientLength: true | |
| }, | |
| JSMutableArray: {"": "JSArray;", $isJSMutableArray: true, | |
| $asJSArray: function() { | |
| return [null]; | |
| }, | |
| $asList: function() { | |
| return [null]; | |
| } | |
| }, | |
| JSFixedArray: {"": "JSMutableArray;"}, | |
| JSExtendableArray: {"": "JSMutableArray;", $isJSExtendableArray: true}, | |
| JSNumber: {"": "num/Interceptor;", | |
| remainder$1: function(receiver, b) { | |
| return receiver % b; | |
| }, | |
| toInt$0: function(receiver) { | |
| var t1; | |
| if (receiver >= -2147483648 && receiver <= 2147483647) | |
| return receiver | 0; | |
| if (isFinite(receiver)) { | |
| t1 = receiver < 0 ? Math.ceil(receiver) : Math.floor(receiver); | |
| return t1 + 0; | |
| } | |
| throw H.wrapException(P.UnsupportedError$('' + receiver)); | |
| }, | |
| toString$0: function(receiver) { | |
| if (receiver === 0 && 1 / receiver < 0) | |
| return "-0.0"; | |
| else | |
| return "" + receiver; | |
| }, | |
| get$hashCode: function(receiver) { | |
| return receiver & 0x1FFFFFFF; | |
| }, | |
| $tdiv: function(receiver, other) { | |
| if ((receiver | 0) === receiver && (other | 0) === other && 0 !== other && -1 !== other) | |
| return receiver / other | 0; | |
| else | |
| return this._slowTdiv$1(receiver, other); | |
| }, | |
| _slowTdiv$1: function(receiver, other) { | |
| return this.toInt$0(receiver / other); | |
| }, | |
| $shr: function(receiver, other) { | |
| if (other < 0) | |
| throw H.wrapException(P.ArgumentError$(other)); | |
| if (receiver > 0) { | |
| if (other > 31) | |
| return 0; | |
| return receiver >>> other; | |
| } | |
| if (other > 31) | |
| other = 31; | |
| return receiver >> other >>> 0; | |
| }, | |
| $lt: function(receiver, other) { | |
| if (typeof other !== "number") | |
| throw H.wrapException(P.ArgumentError$(other)); | |
| return receiver < other; | |
| }, | |
| $gt: function(receiver, other) { | |
| if (typeof other !== "number") | |
| throw H.wrapException(new P.ArgumentError(other)); | |
| return receiver > other; | |
| }, | |
| $ge: function(receiver, other) { | |
| if (typeof other !== "number") | |
| throw H.wrapException(P.ArgumentError$(other)); | |
| return receiver >= other; | |
| }, | |
| $isnum: true, | |
| static: { | |
| "": "JSNumber__MIN_INT32,JSNumber__MAX_INT32", | |
| } | |
| }, | |
| JSInt: {"": "int/JSNumber;", $isnum: true, $isint: true}, | |
| JSDouble: {"": "double/JSNumber;", $isnum: true}, | |
| JSString: {"": "String/Interceptor;", | |
| codeUnitAt$1: function(receiver, index) { | |
| if (typeof index !== "number" || Math.floor(index) !== index) | |
| throw H.wrapException(P.ArgumentError$(index)); | |
| if (index < 0) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| if (index >= receiver.length) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| return receiver.charCodeAt(index); | |
| }, | |
| substring$2: function(receiver, startIndex, endIndex) { | |
| if (endIndex == null) | |
| endIndex = receiver.length; | |
| if (typeof endIndex !== "number" || Math.floor(endIndex) !== endIndex) | |
| H.throwExpression(P.ArgumentError$(endIndex)); | |
| if (startIndex < 0) | |
| throw H.wrapException(P.RangeError$value(startIndex)); | |
| if (typeof endIndex !== "number") | |
| throw H.iae(endIndex); | |
| if (startIndex > endIndex) | |
| throw H.wrapException(P.RangeError$value(startIndex)); | |
| if (endIndex > receiver.length) | |
| throw H.wrapException(P.RangeError$value(endIndex)); | |
| return receiver.substring(startIndex, endIndex); | |
| }, | |
| substring$1: function($receiver, startIndex) { | |
| return this.substring$2($receiver, startIndex, null); | |
| }, | |
| trim$0: function(receiver) { | |
| var endIndex, startIndex, codeUnit, endIndex0, endIndex1; | |
| for (endIndex = receiver.length, startIndex = 0; startIndex < endIndex;) { | |
| if (startIndex >= endIndex) | |
| H.throwExpression(P.RangeError$value(startIndex)); | |
| codeUnit = receiver.charCodeAt(startIndex); | |
| if (codeUnit === 32 || codeUnit === 13 || J.JSString__isWhitespace(codeUnit)) | |
| ++startIndex; | |
| else | |
| break; | |
| } | |
| if (startIndex === endIndex) | |
| return ""; | |
| for (endIndex0 = endIndex; true; endIndex0 = endIndex1) { | |
| endIndex1 = endIndex0 - 1; | |
| if (endIndex1 < 0) | |
| H.throwExpression(P.RangeError$value(endIndex1)); | |
| if (endIndex1 >= endIndex) | |
| H.throwExpression(P.RangeError$value(endIndex1)); | |
| codeUnit = receiver.charCodeAt(endIndex1); | |
| if (codeUnit === 32 || codeUnit === 13 || J.JSString__isWhitespace(codeUnit)) | |
| ; | |
| else | |
| break; | |
| } | |
| if (startIndex === 0 && endIndex0 === endIndex) | |
| return receiver; | |
| return receiver.substring(startIndex, endIndex0); | |
| }, | |
| get$isEmpty: function(receiver) { | |
| return receiver.length === 0; | |
| }, | |
| toString$0: function(receiver) { | |
| return receiver; | |
| }, | |
| get$hashCode: function(receiver) { | |
| var t1, hash, i; | |
| for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) { | |
| hash = 536870911 & hash + receiver.charCodeAt(i); | |
| hash = 536870911 & hash + ((524287 & hash) << 10 >>> 0); | |
| hash ^= hash >> 6; | |
| } | |
| hash = 536870911 & hash + ((67108863 & hash) << 3 >>> 0); | |
| hash ^= hash >> 11; | |
| return 536870911 & hash + ((16383 & hash) << 15 >>> 0); | |
| }, | |
| get$length: function(receiver) { | |
| return receiver.length; | |
| }, | |
| $index: function(receiver, index) { | |
| if (typeof index !== "number" || Math.floor(index) !== index) | |
| throw H.wrapException(new P.ArgumentError(index)); | |
| if (index >= receiver.length || index < 0) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| return receiver[index]; | |
| }, | |
| $isString: true, | |
| static: { | |
| JSString__isWhitespace: function(codeUnit) { | |
| if (codeUnit < 256) | |
| switch (codeUnit) { | |
| case 9: | |
| case 10: | |
| case 11: | |
| case 12: | |
| case 13: | |
| case 32: | |
| case 133: | |
| case 160: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| switch (codeUnit) { | |
| case 5760: | |
| case 6158: | |
| case 8192: | |
| case 8193: | |
| case 8194: | |
| case 8195: | |
| case 8196: | |
| case 8197: | |
| case 8198: | |
| case 8199: | |
| case 8200: | |
| case 8201: | |
| case 8202: | |
| case 8232: | |
| case 8233: | |
| case 8239: | |
| case 8287: | |
| case 12288: | |
| case 65279: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| }} | |
| }}], | |
| ["_isolate_helper", "dart:_isolate_helper", , H, { | |
| _callInIsolate: function(isolate, $function) { | |
| var result = isolate.eval$1($function); | |
| $globalState.topEventLoop.run$0(); | |
| return result; | |
| }, | |
| startRootIsolate: function(entry) { | |
| var rootContext; | |
| $globalState = H._Manager$(entry); | |
| if ($globalState.isWorker === true) | |
| return; | |
| rootContext = H._IsolateContext$(); | |
| $globalState.rootContext = rootContext; | |
| $globalState.currentContext = rootContext; | |
| if (!!entry.$is_args1) | |
| rootContext.eval$1(new H.startRootIsolate_closure(entry)); | |
| else if (!!entry.$is_args2) | |
| rootContext.eval$1(new H.startRootIsolate_closure0(entry)); | |
| else | |
| rootContext.eval$1(entry); | |
| $globalState.topEventLoop.run$0(); | |
| }, | |
| IsolateNatives_computeThisScript: function() { | |
| var currentScript = init.currentScript; | |
| if (currentScript != null) | |
| return String(currentScript.src); | |
| if (typeof version == "function" && typeof os == "object" && "system" in os) | |
| return H.IsolateNatives_computeThisScriptD8(); | |
| if (typeof version == "function" && typeof system == "function") | |
| return thisFilename(); | |
| return; | |
| }, | |
| IsolateNatives_computeThisScriptD8: function() { | |
| var stack, matches; | |
| stack = new Error().stack; | |
| if (stack == null) { | |
| stack = (function() {try { throw new Error() } catch(e) { return e.stack }})(); | |
| if (stack == null) | |
| throw H.wrapException(P.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 H.wrapException(P.UnsupportedError$("Cannot extract URI from \"" + stack + "\"")); | |
| }, | |
| IsolateNatives__processWorkerMessage: function(sender, e) { | |
| var msg, t1, functionName, entryPoint, args, message, isSpawnUri, replyTo, context, t2; | |
| msg = H._deserializeMessage(e.data); | |
| t1 = J.getInterceptor$asx(msg); | |
| switch (t1.$index(msg, "command")) { | |
| case "start": | |
| $globalState.currentManagerId = t1.$index(msg, "id"); | |
| functionName = t1.$index(msg, "functionName"); | |
| entryPoint = functionName == null ? $globalState.entry : init.globalFunctions[functionName]; | |
| args = t1.$index(msg, "args"); | |
| message = H._deserializeMessage(t1.$index(msg, "msg")); | |
| isSpawnUri = t1.$index(msg, "isSpawnUri"); | |
| replyTo = H._deserializeMessage(t1.$index(msg, "replyTo")); | |
| context = H._IsolateContext$(); | |
| $globalState.topEventLoop.events._add$1(new H._IsolateEvent(context, new H.IsolateNatives__processWorkerMessage_closure(entryPoint, args, message, isSpawnUri, replyTo), "worker-start")); | |
| $globalState.currentContext = context; | |
| $globalState.topEventLoop.run$0(); | |
| break; | |
| case "spawn-worker": | |
| H.IsolateNatives__spawnWorker(t1.$index(msg, "functionName"), t1.$index(msg, "uri"), t1.$index(msg, "args"), t1.$index(msg, "msg"), t1.$index(msg, "isSpawnUri"), t1.$index(msg, "replyPort")); | |
| break; | |
| case "message": | |
| if (t1.$index(msg, "port") != null) | |
| t1.$index(msg, "port").send$1(t1.$index(msg, "msg")); | |
| $globalState.topEventLoop.run$0(); | |
| break; | |
| case "close": | |
| t1 = $globalState.managers; | |
| t2 = $.get$IsolateNatives_workerIds(); | |
| t1.remove$1(t1, t2.$index(t2, sender)); | |
| sender.terminate(); | |
| $globalState.topEventLoop.run$0(); | |
| break; | |
| case "log": | |
| H.IsolateNatives__log(t1.$index(msg, "msg")); | |
| break; | |
| case "print": | |
| if ($globalState.isWorker === true) { | |
| t1 = $globalState.mainManager; | |
| t2 = H._serializeMessage(H.fillLiteralMap(["command", "print", "msg", msg], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| t1.toString; | |
| self.postMessage(t2); | |
| } else | |
| P.print(t1.$index(msg, "msg")); | |
| break; | |
| case "error": | |
| throw H.wrapException(t1.$index(msg, "msg")); | |
| default: | |
| } | |
| }, | |
| IsolateNatives__log: function(msg) { | |
| var trace, t1, t2, exception; | |
| if ($globalState.isWorker === true) { | |
| t1 = $globalState.mainManager; | |
| t2 = H._serializeMessage(H.fillLiteralMap(["command", "log", "msg", msg], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| t1.toString; | |
| self.postMessage(t2); | |
| } else | |
| try { | |
| $.get$globalThis().console.log(msg); | |
| } catch (exception) { | |
| H.unwrapException(exception); | |
| trace = new H._StackTrace(exception, null); | |
| throw H.wrapException(P.Exception_Exception(trace)); | |
| } | |
| }, | |
| IsolateNatives__startIsolate: function(topLevel, args, message, isSpawnUri, replyTo) { | |
| var t1; | |
| H.Primitives_initializeStatics($globalState.currentContext.id); | |
| $.lazyPort = H.ReceivePortImpl$(); | |
| t1 = $.lazyPort; | |
| t1.toString; | |
| replyTo.send$1(["spawned", new H._NativeJsSendPort(t1, $globalState.currentContext.id)]); | |
| if (isSpawnUri !== true) | |
| topLevel.call$1(message); | |
| else { | |
| t1 = J.getInterceptor(topLevel); | |
| if (!!t1.$is_args2) | |
| topLevel.call$2(args, message); | |
| else if (!!t1.$is_args1) | |
| topLevel.call$1(args); | |
| else | |
| topLevel.call$0(); | |
| } | |
| }, | |
| IsolateNatives__spawnWorker: function(functionName, uri, args, message, isSpawnUri, replyPort) { | |
| var worker, t1, workerId; | |
| if (uri == null) | |
| uri = $.get$IsolateNatives_thisScript(); | |
| worker = new Worker(uri); | |
| worker.onmessage = function(e) { H.IsolateNatives__processWorkerMessage$closure.call$2(worker, e); }; | |
| t1 = $globalState; | |
| workerId = t1.nextManagerId; | |
| t1.nextManagerId = workerId + 1; | |
| t1 = $.get$IsolateNatives_workerIds(); | |
| t1.$indexSet(t1, worker, workerId); | |
| t1 = $globalState.managers; | |
| t1.$indexSet(t1, workerId, worker); | |
| worker.postMessage(H._serializeMessage(H.fillLiteralMap(["command", "start", "id", workerId, "replyTo", H._serializeMessage(replyPort), "args", args, "msg", H._serializeMessage(message), "isSpawnUri", isSpawnUri, "functionName", functionName], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null)))); | |
| }, | |
| _waitForPendingPorts: function(message, callback) { | |
| var finder = H._PendingSendPortFinder$(); | |
| finder.traverse$1(message); | |
| P.Future_wait(finder.ports).then$1(new H._waitForPendingPorts_closure(callback)); | |
| }, | |
| _serializeMessage: function(message) { | |
| var t1; | |
| if ($globalState.supportsWorkers === true) { | |
| t1 = new H._JsSerializer(0, new H._MessageTraverserVisitedMap()); | |
| t1._visited = new H._JsVisitedMap(null); | |
| return t1.traverse$1(message); | |
| } else { | |
| t1 = new H._JsCopier(new H._MessageTraverserVisitedMap()); | |
| t1._visited = new H._JsVisitedMap(null); | |
| return t1.traverse$1(message); | |
| } | |
| }, | |
| _deserializeMessage: function(message) { | |
| if ($globalState.supportsWorkers === true) | |
| return new H._JsDeserializer(null).deserialize$1(message); | |
| else | |
| return message; | |
| }, | |
| _MessageTraverser_isPrimitive: function(x) { | |
| return x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean"; | |
| }, | |
| _Deserializer_isPrimitive: function(x) { | |
| return x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean"; | |
| }, | |
| startRootIsolate_closure: {"": "Closure;entry_0", | |
| call$0: function() { | |
| this.entry_0.call$1([]); | |
| } | |
| }, | |
| startRootIsolate_closure0: {"": "Closure;entry_1", | |
| call$0: function() { | |
| this.entry_1.call$2([], null); | |
| } | |
| }, | |
| _Manager: {"": "Object;nextIsolateId,currentManagerId,nextManagerId,currentContext,rootContext,topEventLoop,fromCommandLine,isWorker,supportsWorkers,isolates,mainManager,managers,entry", | |
| _nativeDetectEnvironment$0: function() { | |
| var t1, t2; | |
| t1 = $.get$globalWindow() == null; | |
| t2 = $.get$globalWorker(); | |
| this.isWorker = t1 && $.get$globalPostMessageDefined() === true; | |
| if (this.isWorker !== true) | |
| t2 = t2 != null && $.get$IsolateNatives_thisScript() != null; | |
| else | |
| t2 = true; | |
| this.supportsWorkers = t2; | |
| this.fromCommandLine = t1 && this.isWorker !== true; | |
| }, | |
| _nativeInitWorkerMessageHandler$0: function() { | |
| var $function = function (e) { H.IsolateNatives__processWorkerMessage$closure.call$2(this.mainManager, e); }; | |
| $.get$globalThis().onmessage = $function; | |
| $.get$globalThis().dartPrint = function (object) {}; | |
| }, | |
| _Manager$1: function(entry) { | |
| this._nativeDetectEnvironment$0(); | |
| this.topEventLoop = new H._EventLoop(P.ListQueue$(null, H._IsolateEvent), 0); | |
| this.isolates = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, H._IsolateContext); | |
| this.managers = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, null); | |
| if (this.isWorker === true) { | |
| this.mainManager = new H._MainManagerStub(); | |
| this._nativeInitWorkerMessageHandler$0(); | |
| } | |
| }, | |
| static: { | |
| _Manager$: function(entry) { | |
| var t1 = new H._Manager(0, 0, 1, null, null, null, null, null, null, null, null, null, entry); | |
| t1._Manager$1(entry); | |
| return t1; | |
| }} | |
| }, | |
| _IsolateContext: {"": "Object;id,ports,isolateStatics<", | |
| eval$1: function(code) { | |
| var old, result; | |
| old = $globalState.currentContext; | |
| $globalState.currentContext = this; | |
| $ = this.isolateStatics; | |
| result = null; | |
| try { | |
| result = code.call$0(); | |
| } finally { | |
| $globalState.currentContext = old; | |
| if (old != null) | |
| $ = old.get$isolateStatics(); | |
| } | |
| return result; | |
| }, | |
| lookup$1: function(portId) { | |
| var t1 = this.ports; | |
| return t1.$index(t1, portId); | |
| }, | |
| register$2: function(_, portId, port) { | |
| var t1; | |
| if (this.ports.containsKey$1(portId)) | |
| throw H.wrapException(P.Exception_Exception("Registry: ports must be registered only once.")); | |
| t1 = this.ports; | |
| t1.$indexSet(t1, portId, port); | |
| t1 = $globalState.isolates; | |
| t1.$indexSet(t1, this.id, this); | |
| }, | |
| unregister$1: function(portId) { | |
| var t1 = this.ports; | |
| t1.remove$1(t1, portId); | |
| if (this.ports._collection$_length === 0) { | |
| t1 = $globalState.isolates; | |
| t1.remove$1(t1, this.id); | |
| } | |
| }, | |
| _IsolateContext$0: function() { | |
| var t1, t2; | |
| t1 = $globalState; | |
| t2 = t1.nextIsolateId; | |
| t1.nextIsolateId = t2 + 1; | |
| this.id = t2; | |
| this.ports = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, P.ReceivePort); | |
| this.isolateStatics = new Isolate(); | |
| }, | |
| static: { | |
| _IsolateContext$: function() { | |
| var t1 = new H._IsolateContext(null, null, null); | |
| t1._IsolateContext$0(); | |
| return t1; | |
| }} | |
| }, | |
| _EventLoop: {"": "Object;events,activeTimerCount", | |
| dequeue$0: function() { | |
| var t1 = this.events; | |
| if (t1._head === t1._tail) | |
| return; | |
| return t1.removeFirst$0(); | |
| }, | |
| checkOpenReceivePortsFromCommandLine$0: function() { | |
| if ($globalState.rootContext != null && $globalState.isolates.containsKey$1($globalState.rootContext.id) && $globalState.fromCommandLine === true && $globalState.rootContext.ports._collection$_length === 0) | |
| throw H.wrapException(P.Exception_Exception("Program exited with open ReceivePorts.")); | |
| }, | |
| runIteration$0: function() { | |
| var $event, t1, t2; | |
| $event = this.dequeue$0(); | |
| if ($event == null) { | |
| this.checkOpenReceivePortsFromCommandLine$0(); | |
| t1 = $globalState; | |
| if (t1.isWorker === true && t1.isolates._collection$_length === 0 && t1.topEventLoop.activeTimerCount === 0) { | |
| t1 = t1.mainManager; | |
| t2 = H._serializeMessage(H.fillLiteralMap(["command", "close"], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| t1.toString; | |
| self.postMessage(t2); | |
| } | |
| return false; | |
| } | |
| $event.process$0(); | |
| return true; | |
| }, | |
| _runHelper$0: function() { | |
| if ($.get$globalWindow() != null) | |
| new H._EventLoop__runHelper_next(this).call$0(); | |
| else | |
| for (; this.runIteration$0();) | |
| ; | |
| }, | |
| run$0: function() { | |
| var e, trace, exception, t1, t2; | |
| if ($globalState.isWorker !== true) | |
| this._runHelper$0(); | |
| else | |
| try { | |
| this._runHelper$0(); | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| trace = new H._StackTrace(exception, null); | |
| t1 = $globalState.mainManager; | |
| t2 = H._serializeMessage(H.fillLiteralMap(["command", "error", "msg", H.S(e) + "\n" + H.S(trace)], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| t1.toString; | |
| self.postMessage(t2); | |
| } | |
| } | |
| }, | |
| _EventLoop__runHelper_next: {"": "Closure;this_0", | |
| call$0: function() { | |
| if (!this.this_0.runIteration$0()) | |
| return; | |
| P.Timer_Timer(C.Duration_0, this); | |
| } | |
| }, | |
| _IsolateEvent: {"": "Object;isolate,fn,message", | |
| process$0: function() { | |
| this.isolate.eval$1(this.fn); | |
| } | |
| }, | |
| _MainManagerStub: {"": "Object;"}, | |
| IsolateNatives__processWorkerMessage_closure: {"": "Closure;entryPoint_0,args_1,message_2,isSpawnUri_3,replyTo_4", | |
| call$0: function() { | |
| H.IsolateNatives__startIsolate(this.entryPoint_0, this.args_1, this.message_2, this.isSpawnUri_3, this.replyTo_4); | |
| } | |
| }, | |
| _BaseSendPort: {"": "Object;", $isSendPort: true}, | |
| _NativeJsSendPort: {"": "_BaseSendPort;_receivePort,_isolateId", | |
| send$1: function(message) { | |
| H._waitForPendingPorts(message, new H._NativeJsSendPort_send_closure(this, message)); | |
| }, | |
| $eq: function(_, other) { | |
| var t1; | |
| if (other == null) | |
| return false; | |
| t1 = J.getInterceptor(other); | |
| return typeof other === "object" && other !== null && !!t1.$is_NativeJsSendPort && J.$eq(this._receivePort, other._receivePort); | |
| }, | |
| get$hashCode: function(_) { | |
| return this._receivePort.get$_id(); | |
| }, | |
| $is_NativeJsSendPort: true, | |
| $isSendPort: true | |
| }, | |
| _NativeJsSendPort_send_closure: {"": "Closure;this_1,message_2", | |
| call$0: function() { | |
| var t1, t2, t3, t4, isolate, shouldSerialize, msg; | |
| t1 = {}; | |
| t2 = $globalState.isolates; | |
| t3 = this.this_1; | |
| t4 = t3._isolateId; | |
| isolate = t2.$index(t2, t4); | |
| if (isolate == null) | |
| return; | |
| if ((t3._receivePort.get$__isolate_helper$_controller()._state & 4) !== 0) | |
| return; | |
| shouldSerialize = $globalState.currentContext != null && $globalState.currentContext.id !== t4; | |
| msg = this.message_2; | |
| t1.msg_0 = msg; | |
| if (shouldSerialize) | |
| t1.msg_0 = H._serializeMessage(t1.msg_0); | |
| t2 = $globalState.topEventLoop; | |
| t4 = "receive " + H.S(msg); | |
| t2.events._add$1(new H._IsolateEvent(isolate, new H._NativeJsSendPort_send__closure(t1, t3, shouldSerialize), t4)); | |
| } | |
| }, | |
| _NativeJsSendPort_send__closure: {"": "Closure;box_0,this_3,shouldSerialize_4", | |
| call$0: function() { | |
| var t1, t2; | |
| t1 = this.this_3._receivePort; | |
| if ((t1.get$__isolate_helper$_controller()._state & 4) === 0) { | |
| if (this.shouldSerialize_4) { | |
| t2 = this.box_0; | |
| t2.msg_0 = H._deserializeMessage(t2.msg_0); | |
| } | |
| t1 = t1.__isolate_helper$_controller; | |
| t2 = this.box_0.msg_0; | |
| if (t1._state >= 4) | |
| H.throwExpression(t1._badEventState$0()); | |
| t1._async$_add$1(t2); | |
| } | |
| } | |
| }, | |
| _WorkerSendPort: {"": "_BaseSendPort;_workerId,_receivePortId,_isolateId", | |
| send$1: function(message) { | |
| H._waitForPendingPorts(message, new H._WorkerSendPort_send_closure(this, message)); | |
| }, | |
| $eq: function(_, other) { | |
| var t1; | |
| if (other == null) | |
| return false; | |
| t1 = J.getInterceptor(other); | |
| return typeof other === "object" && other !== null && !!t1.$is_WorkerSendPort && J.$eq(this._workerId, other._workerId) && J.$eq(this._isolateId, other._isolateId) && J.$eq(this._receivePortId, other._receivePortId); | |
| }, | |
| get$hashCode: function(_) { | |
| var t1, t2, t3; | |
| t1 = this._workerId; | |
| if (typeof t1 !== "number") | |
| throw t1.$shl(); | |
| t2 = this._isolateId; | |
| if (typeof t2 !== "number") | |
| throw t2.$shl(); | |
| t3 = this._receivePortId; | |
| if (typeof t3 !== "number") | |
| throw H.iae(t3); | |
| return (t1 << 16 ^ t2 << 8 ^ t3) >>> 0; | |
| }, | |
| $is_WorkerSendPort: true, | |
| $isSendPort: true | |
| }, | |
| _WorkerSendPort_send_closure: {"": "Closure;this_0,message_1", | |
| call$0: function() { | |
| var t1, workerMessage, t2, manager; | |
| t1 = this.this_0; | |
| workerMessage = H._serializeMessage(H.fillLiteralMap(["command", "message", "port", t1, "msg", this.message_1], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| if ($globalState.isWorker === true) { | |
| $globalState.mainManager.toString; | |
| self.postMessage(workerMessage); | |
| } else { | |
| t2 = $globalState.managers; | |
| manager = t2.$index(t2, t1._workerId); | |
| if (manager != null) | |
| manager.postMessage(workerMessage); | |
| } | |
| } | |
| }, | |
| ReceivePortImpl: {"": "Stream;_id<,__isolate_helper$_controller<", | |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { | |
| var t1 = this.__isolate_helper$_controller; | |
| t1.toString; | |
| t1 = new P._ControllerStream(t1); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1.listen$4$cancelOnError$onDone$onError(onData, cancelOnError, onDone, onError); | |
| }, | |
| close$0: function(_) { | |
| var t1 = this.__isolate_helper$_controller; | |
| if ((t1._state & 4) !== 0) | |
| return; | |
| t1.close$0(t1); | |
| $globalState.currentContext.unregister$1(this._id); | |
| }, | |
| get$close: function(_receiver) { | |
| return new H.BoundClosure$i0(this, H.ReceivePortImpl.prototype.close$0, _receiver, "close$0"); | |
| }, | |
| ReceivePortImpl$0: function() { | |
| this.__isolate_helper$_controller = P.StreamController_StreamController(this.get$close(this), null, null, null, true, null); | |
| var t1 = $globalState.currentContext; | |
| t1.register$2(t1, this._id, this); | |
| }, | |
| static: { | |
| "": "ReceivePortImpl__nextFreeId", | |
| ReceivePortImpl$: function() { | |
| var t1 = $.ReceivePortImpl__nextFreeId; | |
| $.ReceivePortImpl__nextFreeId = t1 + 1; | |
| t1 = new H.ReceivePortImpl(t1, null); | |
| t1.ReceivePortImpl$0(); | |
| return t1; | |
| }} | |
| }, | |
| _waitForPendingPorts_closure: {"": "Closure;callback_0", | |
| call$1: function(_) { | |
| return this.callback_0.call$0(); | |
| }, | |
| $is_args1: true | |
| }, | |
| _PendingSendPortFinder: {"": "_MessageTraverser;ports,_visited", | |
| visitPrimitive$1: function(x) { | |
| }, | |
| visitList$1: function(list) { | |
| var t1 = this._visited; | |
| if (t1.$index(t1, list) != null) | |
| return; | |
| t1 = this._visited; | |
| t1.$indexSet(t1, list, true); | |
| J.forEach$1$ax(list, this.get$_dispatch()); | |
| }, | |
| visitMap$1: function(map) { | |
| var t1 = this._visited; | |
| if (t1.$index(t1, map) != null) | |
| return; | |
| t1 = this._visited; | |
| t1.$indexSet(t1, map, true); | |
| J.forEach$1$ax(map.get$values(map), this.get$_dispatch()); | |
| }, | |
| visitSendPort$1: function(port) { | |
| }, | |
| _PendingSendPortFinder$0: function() { | |
| this._visited = new H._JsVisitedMap(null); | |
| }, | |
| static: { | |
| _PendingSendPortFinder$: function() { | |
| var t1 = new H._PendingSendPortFinder([], new H._MessageTraverserVisitedMap()); | |
| t1._PendingSendPortFinder$0(); | |
| return t1; | |
| }} | |
| }, | |
| _JsSerializer: {"": "_Serializer;_nextFreeRefId,_visited", | |
| visitSendPort$1: function(x) { | |
| if (!!x.$is_NativeJsSendPort) | |
| return ["sendport", $globalState.currentManagerId, x._isolateId, x._receivePort.get$_id()]; | |
| if (!!x.$is_WorkerSendPort) | |
| return ["sendport", x._workerId, x._isolateId, x._receivePortId]; | |
| throw H.wrapException("Illegal underlying port " + H.S(x)); | |
| } | |
| }, | |
| _JsCopier: {"": "_Copier;_visited", | |
| visitSendPort$1: function(x) { | |
| if (!!x.$is_NativeJsSendPort) | |
| return new H._NativeJsSendPort(x._receivePort, x._isolateId); | |
| if (!!x.$is_WorkerSendPort) | |
| return new H._WorkerSendPort(x._workerId, x._receivePortId, x._isolateId); | |
| throw H.wrapException("Illegal underlying port " + H.S(x)); | |
| } | |
| }, | |
| _JsDeserializer: {"": "_Deserializer;_deserialized", | |
| deserializeSendPort$1: function(list) { | |
| var t1, managerId, isolateId, receivePortId, isolate, receivePort; | |
| t1 = J.getInterceptor$asx(list); | |
| managerId = t1.$index(list, 1); | |
| isolateId = t1.$index(list, 2); | |
| receivePortId = t1.$index(list, 3); | |
| if (J.$eq(managerId, $globalState.currentManagerId)) { | |
| t1 = $globalState.isolates; | |
| isolate = t1.$index(t1, isolateId); | |
| if (isolate == null) | |
| return; | |
| receivePort = isolate.lookup$1(receivePortId); | |
| if (receivePort == null) | |
| return; | |
| return new H._NativeJsSendPort(receivePort, isolateId); | |
| } else | |
| return new H._WorkerSendPort(managerId, receivePortId, isolateId); | |
| } | |
| }, | |
| _JsVisitedMap: {"": "Object;tagged", | |
| $index: function(_, object) { | |
| return object.__MessageTraverser__attached_info__; | |
| }, | |
| $indexSet: function(_, object, info) { | |
| this.tagged.push(object); | |
| object.__MessageTraverser__attached_info__ = info; | |
| }, | |
| reset$0: function(_) { | |
| this.tagged = P.List_List(null, null); | |
| }, | |
| cleanup$0: function() { | |
| var $length, i, t1; | |
| for ($length = this.tagged.length, i = 0; i < $length; ++i) { | |
| t1 = this.tagged; | |
| if (i >= t1.length) | |
| throw H.ioore(t1, i); | |
| t1[i].__MessageTraverser__attached_info__ = null; | |
| } | |
| this.tagged = null; | |
| } | |
| }, | |
| _MessageTraverserVisitedMap: {"": "Object;", | |
| $index: function(_, object) { | |
| return; | |
| }, | |
| $indexSet: function(_, object, info) { | |
| }, | |
| reset$0: function(_) { | |
| }, | |
| cleanup$0: function() { | |
| } | |
| }, | |
| _MessageTraverser: {"": "Object;", | |
| traverse$1: function(x) { | |
| var result, t1; | |
| if (H._MessageTraverser_isPrimitive(x)) | |
| return this.visitPrimitive$1(x); | |
| t1 = this._visited; | |
| t1.reset$0(t1); | |
| result = null; | |
| try { | |
| result = this._dispatch$1(x); | |
| } finally { | |
| this._visited.cleanup$0(); | |
| } | |
| return result; | |
| }, | |
| _dispatch$1: function(x) { | |
| var t1; | |
| if (x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean") | |
| return this.visitPrimitive$1(x); | |
| t1 = J.getInterceptor(x); | |
| if (typeof x === "object" && x !== null && (x.constructor === Array || !!t1.$isList)) | |
| return this.visitList$1(x); | |
| if (typeof x === "object" && x !== null && !!t1.$isMap) | |
| return this.visitMap$1(x); | |
| if (typeof x === "object" && x !== null && !!t1.$isSendPort) | |
| return this.visitSendPort$1(x); | |
| return this.visitObject$1(x); | |
| }, | |
| get$_dispatch: function() { | |
| return new H.BoundClosure$1(this, H._MessageTraverser.prototype._dispatch$1, null, "_dispatch$1"); | |
| }, | |
| visitObject$1: function(x) { | |
| throw H.wrapException("Message serialization: Illegal value " + H.S(x) + " passed"); | |
| } | |
| }, | |
| _Copier: {"": "_MessageTraverser;", | |
| visitPrimitive$1: function(x) { | |
| return x; | |
| }, | |
| visitList$1: function(list) { | |
| var t1, copy, len, t2, i; | |
| t1 = this._visited; | |
| copy = t1.$index(t1, list); | |
| if (copy != null) | |
| return copy; | |
| t1 = J.getInterceptor$asx(list); | |
| len = t1.get$length(list); | |
| copy = P.List_List(len, null); | |
| t2 = this._visited; | |
| t2.$indexSet(t2, list, copy); | |
| for (i = 0; i < len; ++i) { | |
| t2 = this._dispatch$1(t1.$index(list, i)); | |
| if (i >= len) | |
| throw H.ioore(copy, i); | |
| copy[i] = t2; | |
| } | |
| return copy; | |
| }, | |
| visitMap$1: function(map) { | |
| var t1, t2; | |
| t1 = {}; | |
| t2 = this._visited; | |
| t1.copy_0 = t2.$index(t2, map); | |
| t2 = t1.copy_0; | |
| if (t2 != null) | |
| return t2; | |
| t1.copy_0 = P.LinkedHashMap_LinkedHashMap(null, null, null, null, null); | |
| t2 = this._visited; | |
| t2.$indexSet(t2, map, t1.copy_0); | |
| map.forEach$1(map, new H._Copier_visitMap_closure(t1, this)); | |
| return t1.copy_0; | |
| } | |
| }, | |
| _Copier_visitMap_closure: {"": "Closure;box_0,this_1", | |
| call$2: function(key, val) { | |
| var t1 = this.this_1; | |
| J.$indexSet$ax(this.box_0.copy_0, t1._dispatch$1(key), t1._dispatch$1(val)); | |
| }, | |
| $is_args2: true | |
| }, | |
| _Serializer: {"": "_MessageTraverser;", | |
| visitPrimitive$1: function(x) { | |
| return x; | |
| }, | |
| visitList$1: function(list) { | |
| var t1, copyId, id; | |
| t1 = this._visited; | |
| copyId = t1.$index(t1, list); | |
| if (copyId != null) | |
| return ["ref", copyId]; | |
| id = this._nextFreeRefId; | |
| this._nextFreeRefId = id + 1; | |
| t1 = this._visited; | |
| t1.$indexSet(t1, list, id); | |
| return ["list", id, this._serializeList$1(list)]; | |
| }, | |
| visitMap$1: function(map) { | |
| var t1, copyId, id; | |
| t1 = this._visited; | |
| copyId = t1.$index(t1, map); | |
| if (copyId != null) | |
| return ["ref", copyId]; | |
| id = this._nextFreeRefId; | |
| this._nextFreeRefId = id + 1; | |
| t1 = this._visited; | |
| t1.$indexSet(t1, map, id); | |
| return ["map", id, this._serializeList$1(J.toList$0$ax(map.get$keys())), this._serializeList$1(J.toList$0$ax(map.get$values(map)))]; | |
| }, | |
| _serializeList$1: function(list) { | |
| var t1, len, result, i, t2; | |
| t1 = J.getInterceptor$asx(list); | |
| len = t1.get$length(list); | |
| result = P.List_List(len, null); | |
| for (i = 0; i < len; ++i) { | |
| t2 = this._dispatch$1(t1.$index(list, i)); | |
| if (i >= len) | |
| throw H.ioore(result, i); | |
| result[i] = t2; | |
| } | |
| return result; | |
| } | |
| }, | |
| _Deserializer: {"": "Object;", | |
| deserialize$1: function(x) { | |
| if (H._Deserializer_isPrimitive(x)) | |
| return x; | |
| this._deserialized = P.HashMap_HashMap(null, null, null, null, null); | |
| return this._deserializeHelper$1(x); | |
| }, | |
| _deserializeHelper$1: function(x) { | |
| var t1, id; | |
| if (x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean") | |
| return x; | |
| t1 = J.getInterceptor$asx(x); | |
| switch (t1.$index(x, 0)) { | |
| case "ref": | |
| id = t1.$index(x, 1); | |
| t1 = this._deserialized; | |
| return t1.$index(t1, id); | |
| case "list": | |
| return this._deserializeList$1(x); | |
| case "map": | |
| return this._deserializeMap$1(x); | |
| case "sendport": | |
| return this.deserializeSendPort$1(x); | |
| default: | |
| return this.deserializeObject$1(x); | |
| } | |
| }, | |
| _deserializeList$1: function(x) { | |
| var t1, id, dartList, len, i; | |
| t1 = J.getInterceptor$asx(x); | |
| id = t1.$index(x, 1); | |
| dartList = t1.$index(x, 2); | |
| t1 = this._deserialized; | |
| t1.$indexSet(t1, id, dartList); | |
| t1 = J.getInterceptor$asx(dartList); | |
| len = t1.get$length(dartList); | |
| if (typeof len !== "number") | |
| throw H.iae(len); | |
| i = 0; | |
| for (; i < len; ++i) | |
| t1.$indexSet(dartList, i, this._deserializeHelper$1(t1.$index(dartList, i))); | |
| return dartList; | |
| }, | |
| _deserializeMap$1: function(x) { | |
| var result, t1, id, t2, keys, values, len, i; | |
| result = P.LinkedHashMap_LinkedHashMap(null, null, null, null, null); | |
| t1 = J.getInterceptor$asx(x); | |
| id = t1.$index(x, 1); | |
| t2 = this._deserialized; | |
| t2.$indexSet(t2, id, result); | |
| keys = t1.$index(x, 2); | |
| values = t1.$index(x, 3); | |
| t1 = J.getInterceptor$asx(keys); | |
| len = t1.get$length(keys); | |
| if (typeof len !== "number") | |
| throw H.iae(len); | |
| t2 = J.getInterceptor$asx(values); | |
| i = 0; | |
| for (; i < len; ++i) | |
| result.$indexSet(result, this._deserializeHelper$1(t1.$index(keys, i)), this._deserializeHelper$1(t2.$index(values, i))); | |
| return result; | |
| }, | |
| deserializeObject$1: function(x) { | |
| throw H.wrapException("Unexpected serialized object"); | |
| } | |
| }, | |
| TimerImpl: {"": "Object;_once,_inEventLoop,_handle", | |
| cancel$0: function() { | |
| if ($.get$globalThis().setTimeout != null) { | |
| if (this._inEventLoop) | |
| throw H.wrapException(P.UnsupportedError$("Timer in event loop cannot be canceled.")); | |
| if (this._handle == null) | |
| return; | |
| var t1 = $globalState.topEventLoop; | |
| t1.activeTimerCount = t1.activeTimerCount - 1; | |
| if (this._once) | |
| $.get$globalThis().clearTimeout(this._handle); | |
| else | |
| $.get$globalThis().clearInterval(this._handle); | |
| this._handle = null; | |
| } else | |
| throw H.wrapException(P.UnsupportedError$("Canceling a timer.")); | |
| }, | |
| TimerImpl$2: function(milliseconds, callback) { | |
| var t1, t2; | |
| if (milliseconds === 0) | |
| t1 = $.get$globalThis().setTimeout == null || $globalState.isWorker === true; | |
| else | |
| t1 = false; | |
| if (t1) { | |
| this._handle = 1; | |
| t1 = $globalState.topEventLoop; | |
| t2 = $globalState.currentContext; | |
| t1.events._add$1(new H._IsolateEvent(t2, new H.TimerImpl_internalCallback(this, callback), "timer")); | |
| this._inEventLoop = true; | |
| } else if ($.get$globalThis().setTimeout != null) { | |
| t1 = $globalState.topEventLoop; | |
| t1.activeTimerCount = t1.activeTimerCount + 1; | |
| this._handle = $.get$globalThis().setTimeout(H.convertDartClosureToJS(new H.TimerImpl_internalCallback0(this, callback), 0), milliseconds); | |
| } else | |
| throw H.wrapException(P.UnsupportedError$("Timer greater than 0.")); | |
| }, | |
| static: { | |
| TimerImpl$: function(milliseconds, callback) { | |
| var t1 = new H.TimerImpl(true, false, null); | |
| t1.TimerImpl$2(milliseconds, callback); | |
| return t1; | |
| }} | |
| }, | |
| TimerImpl_internalCallback: {"": "Closure;this_0,callback_1", | |
| call$0: function() { | |
| this.this_0._handle = null; | |
| this.callback_1.call$0(); | |
| } | |
| }, | |
| TimerImpl_internalCallback0: {"": "Closure;this_2,callback_3", | |
| call$0: function() { | |
| this.this_2._handle = null; | |
| var t1 = $globalState.topEventLoop; | |
| t1.activeTimerCount = t1.activeTimerCount - 1; | |
| this.callback_3.call$0(); | |
| } | |
| }}], | |
| ["_js_helper", "dart:_js_helper", , H, { | |
| isJsIndexable: function(object, record) { | |
| var result, t1; | |
| if (record != null) { | |
| result = record.x; | |
| if (result != null) | |
| return result; | |
| } | |
| t1 = J.getInterceptor(object); | |
| return typeof object === "object" && object !== null && !!t1.$isJavaScriptIndexingBehavior; | |
| }, | |
| S: function(value) { | |
| var res; | |
| 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"; | |
| res = J.toString$0(value); | |
| if (typeof res !== "string") | |
| throw H.wrapException(P.ArgumentError$(value)); | |
| return res; | |
| }, | |
| Primitives_initializeStatics: function(id) { | |
| $.Primitives_mirrorFunctionCacheName = $.Primitives_mirrorFunctionCacheName + ("_" + H.S(id)); | |
| $.Primitives_mirrorInvokeCacheName = $.Primitives_mirrorInvokeCacheName + ("_" + H.S(id)); | |
| }, | |
| Primitives_objectHashCode: function(object) { | |
| var hash = object.$identityHash; | |
| if (hash == null) { | |
| hash = Math.random() * 0x3fffffff | 0; | |
| object.$identityHash = hash; | |
| } | |
| return hash; | |
| }, | |
| Primitives_objectTypeName: function(object) { | |
| var $name, decompiled; | |
| $name = C.JS_CONST_86y(J.getInterceptor(object)); | |
| if ($name === "Object") { | |
| decompiled = String(object.constructor).match(/^\s*function\s*(\S*)\s*\(/)[1]; | |
| if (typeof decompiled === "string") | |
| $name = decompiled; | |
| } | |
| if (J.getInterceptor$s($name).codeUnitAt$1($name, 0) === 36) | |
| $name = C.JSString_methods.substring$1($name, 1); | |
| return $name + H.joinArguments(H.getRuntimeTypeInfo(object), 0, null); | |
| }, | |
| Primitives_objectToString: function(object) { | |
| return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
| }, | |
| Primitives_newFixedList: function($length) { | |
| var result = new Array($length); | |
| result.fixed$length = true; | |
| return result; | |
| }, | |
| Primitives__fromCharCodeApply: function(array) { | |
| var end, t1, result, i, subarray, t2; | |
| end = array.length; | |
| for (t1 = end <= 500, result = "", i = 0; i < end; i += 500) { | |
| if (t1) | |
| subarray = array; | |
| else { | |
| t2 = i + 500; | |
| t2 = t2 < end ? t2 : end; | |
| subarray = array.slice(i, t2); | |
| } | |
| result += String.fromCharCode.apply(null, subarray); | |
| } | |
| return result; | |
| }, | |
| Primitives_stringFromCodePoints: function(codePoints) { | |
| var a, t1, i; | |
| a = []; | |
| a.$builtinTypeInfo = [J.JSInt]; | |
| for (t1 = new H.ListIterator(codePoints, codePoints.length, 0, null); t1.moveNext$0();) { | |
| i = t1._dev$_current; | |
| if (typeof i !== "number" || Math.floor(i) !== i) | |
| throw H.wrapException(P.ArgumentError$(i)); | |
| if (i <= 65535) | |
| a.push(i); | |
| else if (i <= 1114111) { | |
| a.push(55296 + (C.JSInt_methods.$shr(i - 65536, 10) & 1023)); | |
| a.push(56320 + (i & 1023)); | |
| } else | |
| throw H.wrapException(P.ArgumentError$(i)); | |
| } | |
| return H.Primitives__fromCharCodeApply(a); | |
| }, | |
| Primitives_stringFromCharCodes: function(charCodes) { | |
| var t1, i; | |
| for (t1 = new H.ListIterator(charCodes, charCodes.length, 0, null); t1.moveNext$0();) { | |
| i = t1._dev$_current; | |
| if (typeof i !== "number" || Math.floor(i) !== i) | |
| throw H.wrapException(P.ArgumentError$(i)); | |
| if (i < 0) | |
| throw H.wrapException(P.ArgumentError$(i)); | |
| if (i > 65535) | |
| return H.Primitives_stringFromCodePoints(charCodes); | |
| } | |
| return H.Primitives__fromCharCodeApply(charCodes); | |
| }, | |
| Primitives_getProperty: function(object, key) { | |
| if (object == null || typeof object === "boolean" || typeof object === "number" || typeof object === "string") | |
| throw H.wrapException(new P.ArgumentError(object)); | |
| return object[key]; | |
| }, | |
| Primitives_setProperty: function(object, key, value) { | |
| if (object == null || typeof object === "boolean" || typeof object === "number" || typeof object === "string") | |
| throw H.wrapException(new P.ArgumentError(object)); | |
| object[key] = value; | |
| }, | |
| iae: function(argument) { | |
| throw H.wrapException(P.ArgumentError$(argument)); | |
| }, | |
| ioore: function(receiver, index) { | |
| if (receiver == null) | |
| J.get$length$asx(receiver); | |
| if (typeof index !== "number" || Math.floor(index) !== index) | |
| H.iae(index); | |
| throw H.wrapException(P.RangeError$value(index)); | |
| }, | |
| wrapException: function(ex) { | |
| var wrapper; | |
| if (ex == null) | |
| ex = new P.NullThrownError(); | |
| wrapper = new Error(); | |
| wrapper.dartException = ex; | |
| if ("defineProperty" in Object) { | |
| Object.defineProperty(wrapper, "message", { get: H.toStringWrapper$closure.call$0 }); | |
| wrapper.name = ""; | |
| } else | |
| wrapper.toString = H.toStringWrapper$closure.call$0; | |
| return wrapper; | |
| }, | |
| toStringWrapper: function() { | |
| return J.toString$0(this.dartException); | |
| }, | |
| throwExpression: function(ex) { | |
| throw H.wrapException(ex); | |
| }, | |
| unwrapException: function(ex) { | |
| var t1, message, number, ieErrorCode, t2, t3, t4, nullLiteralCall, t5, t6, t7, t8, t9, match; | |
| t1 = new H.unwrapException_saveStackTrace(ex); | |
| if (ex == null) | |
| return; | |
| if (typeof ex !== "object") | |
| return ex; | |
| if ("dartException" in ex) | |
| return t1.call$1(ex.dartException); | |
| else if (!("message" in ex)) | |
| return ex; | |
| message = ex.message; | |
| if ("number" in ex && typeof ex.number == "number") { | |
| number = ex.number; | |
| ieErrorCode = number & 65535; | |
| if ((C.JSInt_methods.$shr(number, 16) & 8191) === 10) | |
| switch (ieErrorCode) { | |
| case 438: | |
| return t1.call$1(H.JsNoSuchMethodError$(H.S(message) + " (Error " + ieErrorCode + ")", null)); | |
| case 445: | |
| case 5007: | |
| t2 = H.S(message) + " (Error " + ieErrorCode + ")"; | |
| return t1.call$1(new H.NullError(t2, null)); | |
| default: | |
| } | |
| } | |
| if (ex instanceof TypeError) { | |
| t2 = $.get$TypeErrorDecoder_noSuchMethodPattern(); | |
| t3 = $.get$TypeErrorDecoder_notClosurePattern(); | |
| t4 = $.get$TypeErrorDecoder_nullCallPattern(); | |
| nullLiteralCall = $.get$TypeErrorDecoder_nullLiteralCallPattern(); | |
| t5 = $.get$TypeErrorDecoder_undefinedCallPattern(); | |
| t6 = $.get$TypeErrorDecoder_undefinedLiteralCallPattern(); | |
| t7 = $.get$TypeErrorDecoder_nullPropertyPattern(); | |
| $.get$TypeErrorDecoder_nullLiteralPropertyPattern(); | |
| t8 = $.get$TypeErrorDecoder_undefinedPropertyPattern(); | |
| t9 = $.get$TypeErrorDecoder_undefinedLiteralPropertyPattern(); | |
| match = t2.matchTypeError$1(message); | |
| if (match != null) | |
| return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
| else { | |
| match = t3.matchTypeError$1(message); | |
| if (match != null) { | |
| match.method = "call"; | |
| return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
| } else { | |
| match = t4.matchTypeError$1(message); | |
| if (match == null) { | |
| match = nullLiteralCall.matchTypeError$1(message); | |
| if (match == null) { | |
| match = t5.matchTypeError$1(message); | |
| if (match == null) { | |
| match = t6.matchTypeError$1(message); | |
| if (match == null) { | |
| match = t7.matchTypeError$1(message); | |
| if (match == null) { | |
| match = nullLiteralCall.matchTypeError$1(message); | |
| if (match == null) { | |
| match = t8.matchTypeError$1(message); | |
| if (match == null) { | |
| match = t9.matchTypeError$1(message); | |
| t2 = match != null; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| } else | |
| t2 = true; | |
| if (t2) { | |
| t2 = match == null ? null : match.method; | |
| return t1.call$1(new H.NullError(message, t2)); | |
| } | |
| } | |
| } | |
| t2 = typeof message === "string" ? message : ""; | |
| return t1.call$1(new H.UnknownJsTypeError(t2)); | |
| } | |
| if (ex instanceof RangeError) { | |
| if (typeof message === "string" && message.indexOf("call stack") !== -1) | |
| return new P.StackOverflowError(); | |
| return t1.call$1(new P.ArgumentError(null)); | |
| } | |
| if (typeof InternalError == "function" && ex instanceof InternalError) | |
| if (typeof message === "string" && message === "too much recursion") | |
| return new P.StackOverflowError(); | |
| return ex; | |
| }, | |
| objectHashCode: function(object) { | |
| if (object == null || typeof object != 'object') | |
| return J.get$hashCode$(object); | |
| else | |
| return H.Primitives_objectHashCode(object); | |
| }, | |
| fillLiteralMap: function(keyValuePairs, result) { | |
| var $length, index, index0, index1; | |
| $length = keyValuePairs.length; | |
| for (index = 0; index < $length; index = index1) { | |
| index0 = index + 1; | |
| index1 = index0 + 1; | |
| result.$indexSet(result, keyValuePairs[index], keyValuePairs[index0]); | |
| } | |
| return result; | |
| }, | |
| invokeClosure: function(closure, isolate, numberOfArguments, arg1, arg2, arg3, arg4) { | |
| var t1 = J.getInterceptor(numberOfArguments); | |
| if (t1.$eq(numberOfArguments, 0)) | |
| return H._callInIsolate(isolate, new H.invokeClosure_closure(closure)); | |
| else if (t1.$eq(numberOfArguments, 1)) | |
| return H._callInIsolate(isolate, new H.invokeClosure_closure0(closure, arg1)); | |
| else if (t1.$eq(numberOfArguments, 2)) | |
| return H._callInIsolate(isolate, new H.invokeClosure_closure1(closure, arg1, arg2)); | |
| else if (t1.$eq(numberOfArguments, 3)) | |
| return H._callInIsolate(isolate, new H.invokeClosure_closure2(closure, arg1, arg2, arg3)); | |
| else if (t1.$eq(numberOfArguments, 4)) | |
| return H._callInIsolate(isolate, new H.invokeClosure_closure3(closure, arg1, arg2, arg3, arg4)); | |
| else | |
| throw H.wrapException(P.Exception_Exception("Unsupported number of arguments for wrapped closure")); | |
| }, | |
| convertDartClosureToJS: function(closure, arity) { | |
| var $function; | |
| if (closure == null) | |
| return; | |
| $function = closure.$identity; | |
| if (!!$function) | |
| return $function; | |
| $function = (function(closure, arity, context, invoke) { return function(a1, a2, a3, a4) { return invoke(closure, context, arity, a1, a2, a3, a4); };})(closure,arity,$globalState.currentContext,H.invokeClosure$closure.call$7); | |
| closure.$identity = $function; | |
| return $function; | |
| }, | |
| throwCyclicInit: function(staticName) { | |
| throw H.wrapException(P.CyclicInitializationError$("Cyclic initialization for static " + H.S(staticName))); | |
| }, | |
| setRuntimeTypeInfo: function(target, typeInfo) { | |
| if (target != null) | |
| target.$builtinTypeInfo = typeInfo; | |
| return target; | |
| }, | |
| getRuntimeTypeInfo: function(target) { | |
| if (target == null) | |
| return; | |
| return target.$builtinTypeInfo; | |
| }, | |
| getRuntimeTypeArguments: function(target, substitutionName) { | |
| return H.substitute(target["$as" + H.S(substitutionName)], H.getRuntimeTypeInfo(target)); | |
| }, | |
| getRuntimeTypeArgument: function(target, substitutionName, index) { | |
| var $arguments = H.getRuntimeTypeArguments(target, substitutionName); | |
| return $arguments == null ? null : $arguments[index]; | |
| }, | |
| getRuntimeTypeAsString: function(runtimeType, onTypeVariable) { | |
| return runtimeType[0].builtin$cls + H.joinArguments(runtimeType, 1, onTypeVariable); | |
| }, | |
| runtimeTypeToString: function(type, onTypeVariable) { | |
| if (type == null) | |
| return "dynamic"; | |
| else if (typeof type === "object" && type !== null && type.constructor === Array) | |
| return H.getRuntimeTypeAsString(type, onTypeVariable); | |
| else if (typeof type == "function") | |
| return type.builtin$cls; | |
| else if (typeof type === "number" && Math.floor(type) === type) | |
| return C.JSInt_methods.toString$0(type); | |
| else | |
| return; | |
| }, | |
| joinArguments: function(types, startIndex, onTypeVariable) { | |
| var buffer, index, firstArgument, allDynamic, argument, str; | |
| if (types == null) | |
| return ""; | |
| buffer = P.StringBuffer$(""); | |
| for (index = startIndex, firstArgument = true, allDynamic = true; index < types.length; ++index) { | |
| if (firstArgument) | |
| firstArgument = false; | |
| else | |
| buffer._contents = buffer._contents + ", "; | |
| argument = types[index]; | |
| if (argument != null) | |
| allDynamic = false; | |
| str = H.runtimeTypeToString(argument, onTypeVariable); | |
| str = typeof str === "string" ? str : H.S(str); | |
| buffer._contents = buffer._contents + str; | |
| } | |
| return allDynamic ? "" : "<" + H.S(buffer) + ">"; | |
| }, | |
| substitute: function(substitution, $arguments) { | |
| if (typeof substitution === "object" && substitution !== null && substitution.constructor === Array) | |
| $arguments = substitution; | |
| else if (typeof substitution == "function") { | |
| substitution = H.invokeOn(substitution, null, $arguments); | |
| if (typeof substitution === "object" && substitution !== null && substitution.constructor === Array) | |
| $arguments = substitution; | |
| else if (typeof substitution == "function") | |
| $arguments = H.invokeOn(substitution, null, $arguments); | |
| } | |
| return $arguments; | |
| }, | |
| computeSignature: function(signature, context, contextName) { | |
| return H.invokeOn(signature, context, H.getRuntimeTypeArguments(context, contextName)); | |
| }, | |
| invokeOn: function($function, receiver, $arguments) { | |
| return $function.apply(receiver, $arguments); | |
| }, | |
| toStringForNativeObject: function(obj) { | |
| var t1 = $.getTagFunction; | |
| return "Instance of " + (t1 == null ? "<Unknown>" : t1.call$1(obj)); | |
| }, | |
| hashCodeForNativeObject: function(object) { | |
| return H.Primitives_objectHashCode(object); | |
| }, | |
| defineProperty: function(obj, property, value) { | |
| Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true}); | |
| }, | |
| lookupAndCacheInterceptor: function(obj) { | |
| var tag, record, interceptor, interceptorClass, 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) { | |
| tag = $.alternateTagFunction.call$2(obj, tag); | |
| if (tag != null) { | |
| 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) | |
| return; | |
| interceptor = interceptorClass.prototype; | |
| mark = tag[0]; | |
| if (mark === "!") { | |
| record = H.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 = H.makeLeafDispatchRecord(interceptor); | |
| Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); | |
| return t1.i; | |
| } | |
| if (mark === "+") | |
| return H.patchInteriorProto(obj, interceptor); | |
| if (mark === "*") | |
| throw H.wrapException(P.UnimplementedError$(tag)); | |
| if (init.leafTags[tag] === true) { | |
| t1 = H.makeLeafDispatchRecord(interceptor); | |
| Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); | |
| return t1.i; | |
| } else | |
| return H.patchInteriorProto(obj, interceptor); | |
| }, | |
| patchInteriorProto: function(obj, interceptor) { | |
| var proto, record; | |
| proto = Object.getPrototypeOf(obj); | |
| record = J.makeDispatchRecord(interceptor, proto, null, null); | |
| Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); | |
| return interceptor; | |
| }, | |
| makeLeafDispatchRecord: function(interceptor) { | |
| return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); | |
| }, | |
| makeDefaultDispatchRecord: function(tag, interceptorClass, proto) { | |
| var interceptor = interceptorClass.prototype; | |
| if (init.leafTags[tag] === true) | |
| return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); | |
| else | |
| return J.makeDispatchRecord(interceptor, proto, null, null); | |
| }, | |
| initNativeDispatch: function() { | |
| if (true === $.initNativeDispatchFlag) | |
| return; | |
| $.initNativeDispatchFlag = true; | |
| H.initNativeDispatchContinue(); | |
| }, | |
| initNativeDispatchContinue: function() { | |
| var map, tags, i, tag, proto, record, interceptorClass; | |
| $.dispatchRecordsForInstanceTags = Object.create(null); | |
| $.interceptorsForUncacheableTags = Object.create(null); | |
| H.initHooks(); | |
| map = init.interceptorsByTag; | |
| tags = Object.getOwnPropertyNames(map); | |
| if (typeof window != "undefined") { | |
| window; | |
| for (i = 0; i < tags.length; ++i) { | |
| tag = tags[i]; | |
| proto = $.prototypeForTagFunction.call$1(tag); | |
| if (proto != null) { | |
| record = H.makeDefaultDispatchRecord(tag, map[tag], proto); | |
| if (record != null) | |
| Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); | |
| } | |
| } | |
| } | |
| 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: function() { | |
| var hooks, transformers, i, transformer, getTag, getUnknownTag, prototypeForTag; | |
| hooks = C.JS_CONST_TtD(); | |
| hooks = H.applyHooksTransformer(C.JS_CONST_0, H.applyHooksTransformer(C.JS_CONST_Fs4, H.applyHooksTransformer(C.JS_CONST_Fs4, H.applyHooksTransformer(C.JS_CONST_rD3, H.applyHooksTransformer(C.JS_CONST_6qb, H.applyHooksTransformer(C.JS_CONST_Cbr(C.JS_CONST_86y), hooks)))))); | |
| if (typeof dartNativeDispatchHooksTransformer != "undefined") { | |
| transformers = dartNativeDispatchHooksTransformer; | |
| if (typeof transformers == "function") | |
| transformers = [transformers]; | |
| if (transformers.constructor == Array) | |
| 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 H.initHooks_closure(getTag); | |
| $.alternateTagFunction = new H.initHooks_closure0(getUnknownTag); | |
| $.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag); | |
| }, | |
| applyHooksTransformer: function(transformer, hooks) { | |
| return transformer(hooks) || hooks; | |
| }, | |
| TypeErrorDecoder: {"": "Object;_pattern,_arguments,_argumentsExpr,_expr,_method,_receiver", | |
| matchTypeError$1: function(message) { | |
| var match, result, t1; | |
| match = new RegExp(this._pattern).exec(message); | |
| if (match == null) | |
| return; | |
| result = {}; | |
| 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; | |
| }, | |
| static: { | |
| "": "TypeErrorDecoder_noSuchMethodPattern,TypeErrorDecoder_notClosurePattern,TypeErrorDecoder_nullCallPattern,TypeErrorDecoder_nullLiteralCallPattern,TypeErrorDecoder_undefinedCallPattern,TypeErrorDecoder_undefinedLiteralCallPattern,TypeErrorDecoder_nullPropertyPattern,TypeErrorDecoder_nullLiteralPropertyPattern,TypeErrorDecoder_undefinedPropertyPattern,TypeErrorDecoder_undefinedLiteralPropertyPattern", | |
| TypeErrorDecoder_extractPattern: function(message) { | |
| var match, $arguments, argumentsExpr, expr, method, receiver; | |
| message = message.replace(String({}), '$receiver$').replace(new RegExp("[[\\]{}()*+?.\\\\^$|]", 'g'), '\\$&'); | |
| match = message.match(/\\\$[a-zA-Z]+\\\$/g); | |
| if (match == null) | |
| match = []; | |
| $arguments = match.indexOf("\\$arguments\\$"); | |
| argumentsExpr = match.indexOf("\\$argumentsExpr\\$"); | |
| expr = match.indexOf("\\$expr\\$"); | |
| method = match.indexOf("\\$method\\$"); | |
| receiver = match.indexOf("\\$receiver\\$"); | |
| return new H.TypeErrorDecoder(message.replace('\\$arguments\\$', '((?:x|[^x])*)').replace('\\$argumentsExpr\\$', '((?:x|[^x])*)').replace('\\$expr\\$', '((?:x|[^x])*)').replace('\\$method\\$', '((?:x|[^x])*)').replace('\\$receiver\\$', '((?:x|[^x])*)'), $arguments, argumentsExpr, expr, method, receiver); | |
| }, | |
| TypeErrorDecoder_provokeCallErrorOn: function(expression) { | |
| return function($expr$) { | |
| var $argumentsExpr$ = '$arguments$' | |
| try { | |
| $expr$.$method$($argumentsExpr$); | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(expression); | |
| }, | |
| TypeErrorDecoder_provokeCallErrorOnNull: function() { | |
| return function() { | |
| var $argumentsExpr$ = '$arguments$' | |
| try { | |
| null.$method$($argumentsExpr$); | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(); | |
| }, | |
| TypeErrorDecoder_provokeCallErrorOnUndefined: function() { | |
| return function() { | |
| var $argumentsExpr$ = '$arguments$' | |
| try { | |
| (void 0).$method$($argumentsExpr$); | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(); | |
| }, | |
| TypeErrorDecoder_provokePropertyErrorOn: function(expression) { | |
| return function($expr$) { | |
| try { | |
| $expr$.$method$; | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(expression); | |
| }, | |
| TypeErrorDecoder_provokePropertyErrorOnNull: function() { | |
| return function() { | |
| try { | |
| null.$method$; | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(); | |
| }, | |
| TypeErrorDecoder_provokePropertyErrorOnUndefined: function() { | |
| return function() { | |
| try { | |
| (void 0).$method$; | |
| } catch (e) { | |
| return e.message; | |
| } | |
| }(); | |
| }} | |
| }, | |
| NullError: {"": "Error;_message,_method", | |
| toString$0: function(_) { | |
| var t1 = this._method; | |
| if (t1 == null) | |
| return "NullError: " + H.S(this._message); | |
| return "NullError: Cannot call \"" + H.S(t1) + "\" on null"; | |
| }, | |
| $isError: true | |
| }, | |
| JsNoSuchMethodError: {"": "Error;_message,_method,_receiver", | |
| toString$0: function(_) { | |
| var t1, t2; | |
| t1 = this._method; | |
| if (t1 == null) | |
| return "NoSuchMethodError: " + H.S(this._message); | |
| t2 = this._receiver; | |
| if (t2 == null) | |
| return "NoSuchMethodError: Cannot call \"" + t1 + "\" (" + H.S(this._message) + ")"; | |
| return "NoSuchMethodError: Cannot call \"" + t1 + "\" on \"" + t2 + "\" (" + H.S(this._message) + ")"; | |
| }, | |
| $isError: true, | |
| static: { | |
| JsNoSuchMethodError$: function(_message, match) { | |
| var t1, t2; | |
| t1 = match == null; | |
| t2 = t1 ? null : match.method; | |
| t1 = t1 ? null : match.receiver; | |
| return new H.JsNoSuchMethodError(_message, t2, t1); | |
| }} | |
| }, | |
| UnknownJsTypeError: {"": "Error;_message", | |
| toString$0: function(_) { | |
| var t1 = this._message; | |
| return C.JSString_methods.get$isEmpty(t1) ? "Error" : "Error: " + t1; | |
| } | |
| }, | |
| unwrapException_saveStackTrace: {"": "Closure;ex_0", | |
| call$1: function(error) { | |
| var t1 = J.getInterceptor(error); | |
| if (typeof error === "object" && error !== null && !!t1.$isError) | |
| if (error.$thrownJsError == null) | |
| error.$thrownJsError = this.ex_0; | |
| return error; | |
| }, | |
| $is_args1: true | |
| }, | |
| _StackTrace: {"": "Object;_exception,_trace", | |
| toString$0: function(_) { | |
| var t1, trace; | |
| t1 = this._trace; | |
| if (t1 != null) | |
| return t1; | |
| t1 = this._exception; | |
| trace = typeof t1 === "object" ? t1.stack : null; | |
| t1 = trace == null ? "" : trace; | |
| this._trace = t1; | |
| return t1; | |
| } | |
| }, | |
| invokeClosure_closure: {"": "Closure;closure_0", | |
| call$0: function() { | |
| return this.closure_0.call$0(); | |
| } | |
| }, | |
| invokeClosure_closure0: {"": "Closure;closure_1,arg1_2", | |
| call$0: function() { | |
| return this.closure_1.call$1(this.arg1_2); | |
| } | |
| }, | |
| invokeClosure_closure1: {"": "Closure;closure_3,arg1_4,arg2_5", | |
| call$0: function() { | |
| return this.closure_3.call$2(this.arg1_4, this.arg2_5); | |
| } | |
| }, | |
| invokeClosure_closure2: {"": "Closure;closure_6,arg1_7,arg2_8,arg3_9", | |
| call$0: function() { | |
| return this.closure_6.call$3(this.arg1_7, this.arg2_8, this.arg3_9); | |
| } | |
| }, | |
| invokeClosure_closure3: {"": "Closure;closure_10,arg1_11,arg2_12,arg3_13,arg4_14", | |
| call$0: function() { | |
| return this.closure_10.call$4(this.arg1_11, this.arg2_12, this.arg3_13, this.arg4_14); | |
| } | |
| }, | |
| Closure: {"": "Object;", | |
| toString$0: function(_) { | |
| return "Closure"; | |
| } | |
| }, | |
| BoundClosure: {"": "Closure;_self,_target,_receiver,__js_helper$_name", | |
| $eq: function(_, other) { | |
| var t1; | |
| if (other == null) | |
| return false; | |
| if (this === other) | |
| return true; | |
| t1 = J.getInterceptor(other); | |
| if (typeof other !== "object" || other === null || !t1.$isBoundClosure) | |
| return false; | |
| return this._self === other._self && this._target === other._target && this._receiver === other._receiver; | |
| }, | |
| get$hashCode: function(_) { | |
| var t1, receiverHashCode; | |
| t1 = this._receiver; | |
| if (t1 == null) | |
| receiverHashCode = H.Primitives_objectHashCode(this._self); | |
| else | |
| receiverHashCode = typeof t1 !== "object" ? J.get$hashCode$(t1) : H.Primitives_objectHashCode(t1); | |
| return (receiverHashCode ^ H.Primitives_objectHashCode(this._target)) >>> 0; | |
| }, | |
| $isBoundClosure: true | |
| }, | |
| initHooks_closure: {"": "Closure;getTag_0", | |
| call$1: function(o) { | |
| return this.getTag_0(o); | |
| }, | |
| $is_args1: true | |
| }, | |
| initHooks_closure0: {"": "Closure;getUnknownTag_1", | |
| call$2: function(o, tag) { | |
| return this.getUnknownTag_1(o, tag); | |
| }, | |
| $is_args2: true | |
| }, | |
| initHooks_closure1: {"": "Closure;prototypeForTag_2", | |
| call$1: function(tag) { | |
| return this.prototypeForTag_2(tag); | |
| }, | |
| $is_args1: true | |
| }}], | |
| ["dart._collection.dev", "dart:_collection-dev", , H, { | |
| Arrays_copy: function(src, srcStart, dst, dstStart, count) { | |
| var i, j, t1; | |
| if (srcStart < dstStart) | |
| for (i = srcStart + count - 1, j = dstStart + count - 1; i >= srcStart; --i, --j) { | |
| if (i < 0 || i >= src.length) | |
| throw H.ioore(src, i); | |
| C.JSArray_methods.$indexSet(dst, j, src[i]); | |
| } | |
| else | |
| for (t1 = srcStart + count, j = dstStart, i = srcStart; i < t1; ++i, ++j) { | |
| if (i < 0 || i >= src.length) | |
| throw H.ioore(src, i); | |
| C.JSArray_methods.$indexSet(dst, j, src[i]); | |
| } | |
| }, | |
| IterableMixinWorkaround_forEach: function(iterable, f) { | |
| var t1; | |
| for (t1 = new H.ListIterator(iterable, iterable.length, 0, null); t1.moveNext$0();) | |
| f.call$1(t1._dev$_current); | |
| }, | |
| IterableMixinWorkaround_toStringIterable: function(iterable, leftDelimiter, rightDelimiter) { | |
| var result, i, t1; | |
| for (i = 0; i < $.get$IterableMixinWorkaround__toStringList().length; ++i) { | |
| t1 = $.get$IterableMixinWorkaround__toStringList(); | |
| if (i >= t1.length) | |
| throw H.ioore(t1, i); | |
| if (t1[i] === iterable) | |
| return H.S(leftDelimiter) + "..." + H.S(rightDelimiter); | |
| } | |
| result = P.StringBuffer$(""); | |
| try { | |
| $.get$IterableMixinWorkaround__toStringList().push(iterable); | |
| result.write$1(leftDelimiter); | |
| result.writeAll$2(iterable, ", "); | |
| result.write$1(rightDelimiter); | |
| } finally { | |
| t1 = $.get$IterableMixinWorkaround__toStringList(); | |
| if (0 >= t1.length) | |
| throw H.ioore(t1, 0); | |
| t1.pop(); | |
| } | |
| return result.get$_contents(); | |
| }, | |
| IterableMixinWorkaround__rangeCheck: function(list, start, end) { | |
| if (start < 0 || start > list.length) | |
| throw H.wrapException(P.RangeError$range(start, 0, list.length)); | |
| if (end < start || end > list.length) | |
| throw H.wrapException(P.RangeError$range(end, start, list.length)); | |
| }, | |
| IterableMixinWorkaround_setRangeList: function(list, start, end, from, skipCount) { | |
| var $length; | |
| H.IterableMixinWorkaround__rangeCheck(list, start, end); | |
| $length = end - start; | |
| if ($length === 0) | |
| return; | |
| if (skipCount < 0) | |
| throw H.wrapException(new P.ArgumentError(skipCount)); | |
| if (skipCount + $length > from.length) | |
| throw H.wrapException(P.StateError$("Not enough elements")); | |
| H.Arrays_copy(from, skipCount, list, start, $length); | |
| }, | |
| printToConsole: function(line) { | |
| if (typeof dartPrint == "function") { | |
| dartPrint(line); | |
| return; | |
| } | |
| if (typeof console == "object" && typeof console.log == "function") { | |
| console.log(line); | |
| return; | |
| } | |
| if (typeof window == "object") | |
| return; | |
| if (typeof print == "function") { | |
| print(line); | |
| return; | |
| } | |
| throw "Unable to print message: " + String(line); | |
| }, | |
| Symbol_getName: function(symbol) { | |
| return symbol.get$_name(); | |
| }, | |
| ListIterable: {"": "IterableBase;", | |
| get$iterator: function(_) { | |
| return new H.ListIterator(this, this.get$length(this), 0, null); | |
| }, | |
| forEach$1: function(_, action) { | |
| var $length, i; | |
| $length = this.get$length(this); | |
| for (i = 0; i < $length; ++i) { | |
| action.call$1(this.elementAt$1(this, i)); | |
| if ($length !== this.get$length(this)) | |
| throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| } | |
| }, | |
| fold$2: function(_, initialValue, combine) { | |
| var $length, value, i; | |
| $length = this.get$length(this); | |
| for (value = initialValue, i = 0; i < $length; ++i) { | |
| value = combine.call$2(value, this.elementAt$1(this, i)); | |
| if ($length !== this.get$length(this)) | |
| throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| } | |
| return value; | |
| }, | |
| $asIterableBase: null, | |
| $isEfficientLength: true | |
| }, | |
| ListIterator: {"": "Object;_iterable,_dev$_length,_index,_dev$_current", | |
| get$current: function() { | |
| return this._dev$_current; | |
| }, | |
| moveNext$0: function() { | |
| var t1, t2, $length, t3; | |
| t1 = this._iterable; | |
| t2 = J.getInterceptor$asx(t1); | |
| $length = t2.get$length(t1); | |
| if (this._dev$_length !== $length) | |
| throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| t3 = this._index; | |
| if (t3 >= $length) { | |
| this._dev$_current = null; | |
| return false; | |
| } | |
| this._dev$_current = t2.elementAt$1(t1, t3); | |
| this._index = this._index + 1; | |
| return true; | |
| } | |
| }, | |
| MappedIterable: {"": "IterableBase;_iterable,_f", | |
| get$iterator: function(_) { | |
| var t1 = this._iterable; | |
| t1 = t1.get$iterator(t1); | |
| t1 = new H.MappedIterator(null, t1, this._f); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "MappedIterable", 0), H.getRuntimeTypeArgument(this, "MappedIterable", 1)]); | |
| return t1; | |
| }, | |
| get$length: function(_) { | |
| var t1 = this._iterable; | |
| return t1.get$length(t1); | |
| }, | |
| $asIterableBase: function($S, $T) { | |
| return [$T]; | |
| }, | |
| static: { | |
| MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { | |
| var t1; | |
| if (!!iterable.$isEfficientLength) { | |
| t1 = new H.EfficientLengthMappedIterable(iterable, $function); | |
| H.setRuntimeTypeInfo(t1, [$S, $T]); | |
| return t1; | |
| } | |
| t1 = new H.MappedIterable(iterable, $function); | |
| H.setRuntimeTypeInfo(t1, [$S, $T]); | |
| return t1; | |
| }} | |
| }, | |
| EfficientLengthMappedIterable: {"": "MappedIterable;_iterable,_f", $asMappedIterable: null, $isEfficientLength: true}, | |
| MappedIterator: {"": "Iterator;_dev$_current,_iterator,_f", | |
| _f$1: function(arg0) { | |
| return this._f.call$1(arg0); | |
| }, | |
| moveNext$0: function() { | |
| var t1 = this._iterator; | |
| if (t1.moveNext$0()) { | |
| this._dev$_current = this._f$1(t1.get$current()); | |
| return true; | |
| } | |
| this._dev$_current = null; | |
| return false; | |
| }, | |
| get$current: function() { | |
| return this._dev$_current; | |
| }, | |
| $asIterator: function($S, $T) { | |
| return [$T]; | |
| } | |
| }, | |
| MappedListIterable: {"": "ListIterable;_source,_f", | |
| _f$1: function(arg0) { | |
| return this._f.call$1(arg0); | |
| }, | |
| get$length: function(_) { | |
| return J.get$length$asx(this._source); | |
| }, | |
| elementAt$1: function(_, index) { | |
| return this._f$1(J.elementAt$1$ax(this._source, index)); | |
| }, | |
| $asListIterable: function($S, $T) { | |
| return [$T]; | |
| }, | |
| $isEfficientLength: true | |
| }, | |
| WhereIterable: {"": "IterableBase;_iterable,_f", | |
| get$iterator: function(_) { | |
| var t1 = J.get$iterator$ax(this._iterable); | |
| t1 = new H.WhereIterator(t1, this._f); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "WhereIterable", 0)]); | |
| return t1; | |
| }, | |
| $asIterableBase: null | |
| }, | |
| WhereIterator: {"": "Iterator;_iterator,_f", | |
| _f$1: function(arg0) { | |
| return this._f.call$1(arg0); | |
| }, | |
| moveNext$0: function() { | |
| for (var t1 = this._iterator; t1.moveNext$0();) | |
| if (this._f$1(t1.get$current()) === true) | |
| return true; | |
| return false; | |
| }, | |
| get$current: function() { | |
| return this._iterator.get$current(); | |
| }, | |
| $asIterator: null | |
| }, | |
| FixedLengthListMixin: {"": "Object;", | |
| set$length: function(receiver, newLength) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot change the length of a fixed-length list")); | |
| }, | |
| add$1: function(receiver, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot add to a fixed-length list")); | |
| } | |
| }}], | |
| ["dart.async", "dart:async", , P, { | |
| _invokeErrorHandler: function(errorHandler, error, stackTrace) { | |
| var t1 = J.getInterceptor(errorHandler); | |
| if (!!t1.$is_args2) | |
| return errorHandler.call$2(error, stackTrace); | |
| else | |
| return errorHandler.call$1(error); | |
| }, | |
| _registerErrorHandler: function(errorHandler, zone) { | |
| var t1 = J.getInterceptor(errorHandler); | |
| zone.toString; | |
| if (!!t1.$is_args2) | |
| return errorHandler; | |
| else | |
| return errorHandler; | |
| }, | |
| Future_wait: function(futures) { | |
| var t1, t2, t3, future, pos, t4, t5, result, completer; | |
| t1 = {}; | |
| t1.completer_0 = null; | |
| t1.values_1 = null; | |
| t2 = new P.Future_wait_handleError(t1); | |
| t1.remaining_2 = 0; | |
| for (t3 = new H.ListIterator(futures, futures.length, 0, null); t3.moveNext$0();) { | |
| future = t3._dev$_current; | |
| pos = t1.remaining_2; | |
| t1.remaining_2 = pos + 1; | |
| t4 = future.catchError$1(t2); | |
| t5 = $.Zone__current; | |
| t5.toString; | |
| result = new P._Future(0, t5, null, null, new P.Future_wait_closure(t1, pos), null, P._registerErrorHandler(null, t5), null); | |
| result.$builtinTypeInfo = [null]; | |
| t4._addListener$1(result); | |
| } | |
| t2 = t1.remaining_2; | |
| if (t2 === 0) | |
| return P._Future$immediate(C.List_empty, null); | |
| t1.values_1 = P.List_List(t2, null); | |
| t2 = J.JSArray; | |
| completer = new P._AsyncCompleter(P._Future$(t2)); | |
| H.setRuntimeTypeInfo(completer, [t2]); | |
| t1.completer_0 = completer; | |
| return t1.completer_0.future; | |
| }, | |
| _asyncRunCallback: function() { | |
| var callback, t1, exception, milliseconds; | |
| for (; t1 = $.get$_asyncCallbacks(), t1._head !== t1._tail;) { | |
| callback = $.get$_asyncCallbacks().removeFirst$0(); | |
| try { | |
| callback.call$0(); | |
| } catch (exception) { | |
| H.unwrapException(exception); | |
| milliseconds = C.JSNumber_methods.$tdiv(C.Duration_0._duration, 1000); | |
| H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, P._asyncRunCallback$closure); | |
| throw exception; | |
| } | |
| } | |
| $._callbacksAreEnqueued = false; | |
| }, | |
| _scheduleAsyncCallback: function(callback) { | |
| $.get$_asyncCallbacks()._add$1(callback); | |
| if (!$._callbacksAreEnqueued) { | |
| P._createTimer(C.Duration_0, P._asyncRunCallback$closure); | |
| $._callbacksAreEnqueued = true; | |
| } | |
| }, | |
| scheduleMicrotask: function(callback) { | |
| var t1 = $.Zone__current; | |
| if (t1 === C.C__RootZone) { | |
| t1.toString; | |
| P._scheduleAsyncCallback(callback); | |
| return; | |
| } | |
| P._scheduleAsyncCallback(t1.bindCallback$2$runGuarded(callback, true)); | |
| }, | |
| StreamController_StreamController: function(onCancel, onListen, onPause, onResume, sync, $T) { | |
| var t1; | |
| if (sync) { | |
| t1 = new P._SyncStreamController(onListen, onPause, onResume, onCancel, null, 0, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| } else { | |
| t1 = new P._AsyncStreamController(onListen, onPause, onResume, onCancel, null, 0, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| } | |
| return t1; | |
| }, | |
| StreamController_StreamController$broadcast: function(onCancel, onListen, sync, $T) { | |
| var t1; | |
| if (sync) { | |
| t1 = new P._SyncBroadcastStreamController(onListen, onCancel, 0, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| t1._async$_previous = t1; | |
| t1._async$_next = t1; | |
| } else { | |
| t1 = new P._AsyncBroadcastStreamController(onListen, onCancel, 0, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| t1._async$_previous = t1; | |
| t1._async$_next = t1; | |
| } | |
| return t1; | |
| }, | |
| _runGuarded: function(notificationHandler) { | |
| var result, e, s, t1, t2, exception; | |
| if (notificationHandler == null) | |
| return; | |
| try { | |
| result = notificationHandler.call$0(); | |
| t1 = result; | |
| t2 = J.getInterceptor(t1); | |
| if (typeof t1 === "object" && t1 !== null && !!t2.$isFuture) | |
| return result; | |
| return; | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| t1 = $.Zone__current; | |
| t1.toString; | |
| P._rootHandleUncaughtError(t1, null, t1, e, s); | |
| } | |
| }, | |
| _nullDataHandler: function(value) { | |
| }, | |
| _nullErrorHandler: function(error, stackTrace) { | |
| var t1 = $.Zone__current; | |
| t1.toString; | |
| P._rootHandleUncaughtError(t1, null, t1, error, stackTrace); | |
| }, | |
| _nullDoneHandler: function() { | |
| }, | |
| _runUserCode: function(userCode, onSuccess, onError) { | |
| var e, s, exception, t1; | |
| try { | |
| onSuccess.call$1(userCode.call$0()); | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| onError.call$2(e, s); | |
| } | |
| }, | |
| _cancelAndError: function(subscription, future, error, stackTrace) { | |
| var cancelFuture, t1; | |
| cancelFuture = subscription.cancel$0(); | |
| t1 = J.getInterceptor(cancelFuture); | |
| if (typeof cancelFuture === "object" && cancelFuture !== null && !!t1.$isFuture) | |
| cancelFuture.whenComplete$1(new P._cancelAndError_closure(future, error, stackTrace)); | |
| else | |
| future._completeError$2(error, stackTrace); | |
| }, | |
| _cancelAndErrorClosure: function(subscription, future) { | |
| return new P._cancelAndErrorClosure_closure(subscription, future); | |
| }, | |
| Timer_Timer: function(duration, callback) { | |
| var t1 = $.Zone__current; | |
| if (t1 === C.C__RootZone) { | |
| t1.toString; | |
| return P._createTimer(duration, callback); | |
| } | |
| return P._createTimer(duration, t1.bindCallback$2$runGuarded(callback, true)); | |
| }, | |
| _createTimer: function(duration, callback) { | |
| var milliseconds = C.JSNumber_methods.$tdiv(duration._duration, 1000); | |
| return H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback); | |
| }, | |
| _rootHandleUncaughtError: function($self, $parent, zone, error, stackTrace) { | |
| P._rootRun($self, null, $self, new P._rootHandleUncaughtError_closure(error, stackTrace)); | |
| }, | |
| _rootRun: function($self, $parent, zone, f) { | |
| var old, t1, t2; | |
| t1 = $.Zone__current; | |
| t2 = zone; | |
| if (t1 == null ? t2 == null : t1 === t2) | |
| return f.call$0(); | |
| old = t1; | |
| try { | |
| $.Zone__current = zone; | |
| t1 = f.call$0(); | |
| return t1; | |
| } finally { | |
| $.Zone__current = old; | |
| } | |
| }, | |
| _rootRunUnary: function($self, $parent, zone, f, arg) { | |
| var old, t1, t2; | |
| t1 = $.Zone__current; | |
| t2 = zone; | |
| if (t1 == null ? t2 == null : t1 === t2) | |
| return f.call$1(arg); | |
| old = t1; | |
| try { | |
| $.Zone__current = zone; | |
| t1 = f.call$1(arg); | |
| return t1; | |
| } finally { | |
| $.Zone__current = old; | |
| } | |
| }, | |
| _rootRunBinary: function($self, $parent, zone, f, arg1, arg2) { | |
| var old, t1, t2; | |
| t1 = $.Zone__current; | |
| t2 = zone; | |
| if (t1 == null ? t2 == null : t1 === t2) | |
| return f.call$2(arg1, arg2); | |
| old = t1; | |
| try { | |
| $.Zone__current = zone; | |
| t1 = f.call$2(arg1, arg2); | |
| return t1; | |
| } finally { | |
| $.Zone__current = old; | |
| } | |
| }, | |
| _AsyncError: {"": "Object;error>,stackTrace<", $isError: true}, | |
| _BroadcastStream: {"": "_ControllerStream;_async$_controller", $as_ControllerStream: null}, | |
| _BroadcastSubscription: {"": "_ControllerSubscription;_eventState,_async$_next@,_async$_previous?,_async$_controller,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending", | |
| get$_async$_controller: function() { | |
| return this._async$_controller; | |
| }, | |
| _expectsEvent$1: function(eventId) { | |
| var t1 = this._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$and(); | |
| return (t1 & 1) === eventId; | |
| }, | |
| _onPause$0: function() { | |
| }, | |
| get$_onPause: function() { | |
| return new P.BoundClosure$0(this, P._BroadcastSubscription.prototype._onPause$0, null, "_onPause$0"); | |
| }, | |
| _onResume$0: function() { | |
| }, | |
| get$_onResume: function() { | |
| return new P.BoundClosure$0(this, P._BroadcastSubscription.prototype._onResume$0, null, "_onResume$0"); | |
| }, | |
| $as_ControllerSubscription: null, | |
| static: { | |
| "": "_BroadcastSubscription__STATE_EVENT_ID,_BroadcastSubscription__STATE_FIRING,_BroadcastSubscription__STATE_REMOVE_AFTER_FIRING", | |
| } | |
| }, | |
| _BroadcastStreamController: {"": "Object;_async$_next?,_async$_previous?", | |
| _ensureDoneFuture$0: function() { | |
| var t1 = this._doneFuture; | |
| if (t1 != null) | |
| return t1; | |
| t1 = P._Future$(null); | |
| this._doneFuture = t1; | |
| return t1; | |
| }, | |
| _addListener$1: function(subscription) { | |
| subscription._async$_previous = this._async$_previous; | |
| subscription._async$_next = this; | |
| this._async$_previous.set$_async$_next(subscription); | |
| this._async$_previous = subscription; | |
| subscription._eventState = this._state & 1; | |
| }, | |
| _removeListener$1: function(subscription) { | |
| var previous, next; | |
| previous = subscription._async$_previous; | |
| next = subscription._async$_next; | |
| previous.set$_async$_next(next); | |
| next.set$_async$_previous(previous); | |
| subscription._async$_previous = subscription; | |
| subscription._async$_next = subscription; | |
| }, | |
| _subscribe$1: function(cancelOnError) { | |
| var t1, t2, t3, subscription; | |
| if ((this._state & 4) !== 0) | |
| throw H.wrapException(new P.StateError("Subscribing to closed stream")); | |
| t1 = H.getRuntimeTypeArgument(this, "_BroadcastStreamController", 0); | |
| t2 = $.Zone__current; | |
| t3 = cancelOnError ? 1 : 0; | |
| subscription = new P._BroadcastSubscription(null, null, null, this, null, null, null, t2, t3, null, null); | |
| H.setRuntimeTypeInfo(subscription, [t1]); | |
| subscription._async$_previous = subscription; | |
| subscription._async$_next = subscription; | |
| this._addListener$1(subscription); | |
| t1 = this._async$_next; | |
| t2 = this._async$_previous; | |
| if (t1 == null ? t2 == null : t1 === t2) | |
| P._runGuarded(this._onListen); | |
| return subscription; | |
| }, | |
| _recordCancel$1: function(subscription) { | |
| var t1; | |
| if (subscription.get$_async$_next() === subscription) | |
| return; | |
| t1 = subscription._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$and(); | |
| if ((t1 & 2) !== 0) | |
| subscription._eventState = (t1 | 4) >>> 0; | |
| else { | |
| this._removeListener$1(subscription); | |
| if ((this._state & 2) === 0 && this._async$_next === this) | |
| this._callOnCancel$0(); | |
| } | |
| }, | |
| _recordPause$1: function(subscription) { | |
| }, | |
| _recordResume$1: function(subscription) { | |
| }, | |
| _addEventError$0: function() { | |
| if ((this._state & 4) !== 0) | |
| return new P.StateError("Cannot add new events after calling close"); | |
| return new P.StateError("Cannot add new events while doing an addStream"); | |
| }, | |
| add$1: function(_, data) { | |
| if (this._state >= 4) | |
| throw H.wrapException(this._addEventError$0()); | |
| this._sendData$1(data); | |
| }, | |
| get$add: function(_receiver) { | |
| return new P.BoundClosure$i1(this, P._BroadcastStreamController.prototype.add$1, _receiver, "add$1"); | |
| }, | |
| addError$2: function(error, stackTrace) { | |
| if (this._state >= 4) | |
| throw H.wrapException(this._addEventError$0()); | |
| this._sendError$2(error, stackTrace); | |
| }, | |
| get$addError: function() { | |
| return new P.BoundClosure$2(this, P._BroadcastStreamController.prototype.addError$2, null, "addError$2"); | |
| }, | |
| close$0: function(_) { | |
| var t1, doneFuture; | |
| t1 = this._state; | |
| if ((t1 & 4) !== 0) | |
| return this._doneFuture; | |
| if (t1 >= 4) | |
| throw H.wrapException(this._addEventError$0()); | |
| this._state = (t1 | 4) >>> 0; | |
| doneFuture = this._ensureDoneFuture$0(); | |
| this._sendDone$0(); | |
| return doneFuture; | |
| }, | |
| _async$_add$1: function(data) { | |
| this._sendData$1(data); | |
| }, | |
| _addError$2: function(error, stackTrace) { | |
| this._sendError$2(error, stackTrace); | |
| }, | |
| _close$0: function() { | |
| var addState = this._addStreamState; | |
| this._addStreamState = null; | |
| this._state = (this._state & 4294967287) >>> 0; | |
| C.JSNull_methods.complete$0(addState); | |
| }, | |
| _forEachListener$1: function(action) { | |
| var t1, id, link, link0; | |
| t1 = this._state; | |
| if ((t1 & 2) !== 0) | |
| throw H.wrapException(P.StateError$("Cannot fire new event. Controller is already firing an event")); | |
| if (this._async$_next === this) | |
| return; | |
| id = t1 & 1; | |
| this._state = (t1 ^ 3) >>> 0; | |
| link = this._async$_next; | |
| for (; link !== this;) | |
| if (link._expectsEvent$1(id)) { | |
| t1 = link._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$or(); | |
| link._eventState = (t1 | 2) >>> 0; | |
| action.call$1(link); | |
| t1 = link._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$xor(); | |
| link._eventState = (t1 ^ 1) >>> 0; | |
| link0 = link._async$_next; | |
| t1 = link._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$and(); | |
| if ((t1 & 4) !== 0) | |
| this._removeListener$1(link); | |
| t1 = link._eventState; | |
| if (typeof t1 !== "number") | |
| throw t1.$and(); | |
| link._eventState = (t1 & 4294967293) >>> 0; | |
| link = link0; | |
| } else | |
| link = link._async$_next; | |
| this._state = (this._state & 4294967293) >>> 0; | |
| if (this._async$_next === this) | |
| this._callOnCancel$0(); | |
| }, | |
| _callOnCancel$0: function() { | |
| if ((this._state & 4) !== 0 && this._doneFuture._state === 0) | |
| this._doneFuture._asyncComplete$1(null); | |
| P._runGuarded(this._onCancel); | |
| } | |
| }, | |
| _SyncBroadcastStreamController: {"": "_BroadcastStreamController;_onListen,_onCancel,_state,_async$_next,_async$_previous,_addStreamState,_doneFuture", | |
| _sendData$1: function(data) { | |
| if (this._async$_next === this) | |
| return; | |
| this._forEachListener$1(new P._SyncBroadcastStreamController__sendData_closure(this, data)); | |
| }, | |
| _sendError$2: function(error, stackTrace) { | |
| if (this._async$_next === this) | |
| return; | |
| this._forEachListener$1(new P._SyncBroadcastStreamController__sendError_closure(this, error, stackTrace)); | |
| }, | |
| _sendDone$0: function() { | |
| if (this._async$_next !== this) | |
| this._forEachListener$1(new P._SyncBroadcastStreamController__sendDone_closure(this)); | |
| else | |
| this._doneFuture._asyncComplete$1(null); | |
| }, | |
| $as_BroadcastStreamController: null | |
| }, | |
| _SyncBroadcastStreamController__sendData_closure: {"": "Closure;this_0,data_1", | |
| call$1: function(subscription) { | |
| subscription._async$_add$1(this.data_1); | |
| }, | |
| $is_args1: true | |
| }, | |
| _SyncBroadcastStreamController__sendError_closure: {"": "Closure;this_0,error_1,stackTrace_2", | |
| call$1: function(subscription) { | |
| subscription._addError$2(this.error_1, this.stackTrace_2); | |
| }, | |
| $is_args1: true | |
| }, | |
| _SyncBroadcastStreamController__sendDone_closure: {"": "Closure;this_0", | |
| call$1: function(subscription) { | |
| subscription._close$0(); | |
| }, | |
| $is_args1: true | |
| }, | |
| _AsyncBroadcastStreamController: {"": "_BroadcastStreamController;_onListen,_onCancel,_state,_async$_next,_async$_previous,_addStreamState,_doneFuture", | |
| _sendData$1: function(data) { | |
| var link; | |
| for (link = this._async$_next; link !== this; link = link._async$_next) | |
| link._addPending$1(new P._DelayedData(data, null)); | |
| }, | |
| _sendError$2: function(error, stackTrace) { | |
| var link; | |
| for (link = this._async$_next; link !== this; link = link._async$_next) | |
| link._addPending$1(new P._DelayedError(error, stackTrace, null)); | |
| }, | |
| _sendDone$0: function() { | |
| var link = this._async$_next; | |
| if (link !== this) | |
| for (; link !== this; link = link._async$_next) | |
| link._addPending$1(C.C__DelayedDone); | |
| else | |
| this._doneFuture._asyncComplete$1(null); | |
| }, | |
| $as_BroadcastStreamController: null | |
| }, | |
| Future: {"": "Object;", $isFuture: true}, | |
| Future_wait_handleError: {"": "Closure;box_0", | |
| call$1: function(error) { | |
| var t1 = this.box_0; | |
| if (t1.values_1 != null) { | |
| t1.values_1 = null; | |
| t1.completer_0.completeError$1(error); | |
| } | |
| return; | |
| }, | |
| $is_args1: true | |
| }, | |
| Future_wait_closure: {"": "Closure;box_0,pos_1", | |
| call$1: function(value) { | |
| var t1, t2, t3; | |
| t1 = this.box_0; | |
| t2 = t1.values_1; | |
| if (t2 == null) | |
| return; | |
| t3 = this.pos_1; | |
| if (t3 < 0 || t3 >= t2.length) | |
| throw H.ioore(t2, t3); | |
| t2[t3] = value; | |
| t1.remaining_2 = t1.remaining_2 - 1; | |
| if (t1.remaining_2 === 0) { | |
| t2 = t1.completer_0; | |
| t1 = t1.values_1; | |
| t2 = t2.future; | |
| if (t2._state !== 0) | |
| H.throwExpression(new P.StateError("Future already completed")); | |
| t2._asyncComplete$1(t1); | |
| } | |
| }, | |
| $is_args1: true | |
| }, | |
| _Completer: {"": "Object;"}, | |
| _AsyncCompleter: {"": "_Completer;future", | |
| completeError$2: function(error, stackTrace) { | |
| var t1; | |
| if (error == null) | |
| throw H.wrapException(new P.ArgumentError("Error must not be null")); | |
| t1 = this.future; | |
| if (t1._state !== 0) | |
| throw H.wrapException(new P.StateError("Future already completed")); | |
| t1._asyncCompleteError$2(error, stackTrace); | |
| }, | |
| completeError$1: function(error) { | |
| return this.completeError$2(error, null); | |
| }, | |
| $as_Completer: null | |
| }, | |
| _Future: {"": "Object;_state,_zone<,_resultOrListeners,_nextListener<,_onValueCallback,_errorTestCallback,_onErrorCallback,_whenCompleteActionCallback", | |
| get$_isComplete: function() { | |
| return this._state >= 4; | |
| }, | |
| get$_hasError: function() { | |
| return this._state === 8; | |
| }, | |
| set$_isChained: function(value) { | |
| if (value) | |
| this._state = 2; | |
| else | |
| this._state = 0; | |
| }, | |
| get$_onValue: function() { | |
| return this._state === 2 ? null : this._onValueCallback; | |
| }, | |
| _onValue$1: function(arg0) { | |
| return this.get$_onValue().call$1(arg0); | |
| }, | |
| get$_whenCompleteAction: function() { | |
| return this._state === 2 ? null : this._whenCompleteActionCallback; | |
| }, | |
| _whenCompleteAction$0: function() { | |
| return this.get$_whenCompleteAction().call$0(); | |
| }, | |
| then$2$onError: function(f, onError) { | |
| var result = P._Future$_then(f, onError, null); | |
| this._addListener$1(result); | |
| return result; | |
| }, | |
| then$1: function(f) { | |
| return this.then$2$onError(f, null); | |
| }, | |
| catchError$2$test: function(onError, test) { | |
| var result = P._Future$_catchError(onError, test, null); | |
| this._addListener$1(result); | |
| return result; | |
| }, | |
| catchError$1: function(onError) { | |
| return this.catchError$2$test(onError, null); | |
| }, | |
| whenComplete$1: function(action) { | |
| var result = P._Future$_whenComplete(action, H.getRuntimeTypeArgument(this, "_Future", 0)); | |
| this._addListener$1(result); | |
| return result; | |
| }, | |
| get$_value: function() { | |
| return this._resultOrListeners; | |
| }, | |
| get$_error: function() { | |
| return this._resultOrListeners; | |
| }, | |
| _setValue$1: function(value) { | |
| this._state = 4; | |
| this._resultOrListeners = value; | |
| }, | |
| _setError$2: function(error, stackTrace) { | |
| this._state = 8; | |
| this._resultOrListeners = new P._AsyncError(error, stackTrace); | |
| }, | |
| _addListener$1: function(listener) { | |
| if (this._state >= 4) { | |
| this._zone.toString; | |
| P._scheduleAsyncCallback(new P._Future__addListener_closure(this, listener)); | |
| } else { | |
| listener._nextListener = this._resultOrListeners; | |
| this._resultOrListeners = listener; | |
| } | |
| }, | |
| _removeListeners$0: function() { | |
| var current, prev, next; | |
| current = this._resultOrListeners; | |
| this._resultOrListeners = null; | |
| for (prev = null; current != null; prev = current, current = next) { | |
| next = current.get$_nextListener(); | |
| current._nextListener = prev; | |
| } | |
| return prev; | |
| }, | |
| _complete$1: function(value) { | |
| var t1, listeners; | |
| t1 = J.getInterceptor(value); | |
| if (typeof value === "object" && value !== null && !!t1.$isFuture) { | |
| P._Future__chainFutures(value, this); | |
| return; | |
| } | |
| listeners = this._removeListeners$0(); | |
| this._setValue$1(value); | |
| P._Future__propagateToListeners(this, listeners); | |
| }, | |
| _completeError$2: function(error, stackTrace) { | |
| var listeners = this._removeListeners$0(); | |
| this._setError$2(error, stackTrace); | |
| P._Future__propagateToListeners(this, listeners); | |
| }, | |
| get$_completeError: function() { | |
| return new P.BoundClosure$2(this, P._Future.prototype._completeError$2, null, "_completeError$2"); | |
| }, | |
| _asyncComplete$1: function(value) { | |
| if (this._state !== 0) | |
| H.throwExpression(P.StateError$("Future already completed")); | |
| this._state = 1; | |
| this._zone.toString; | |
| P._scheduleAsyncCallback(new P._Future__asyncComplete_closure(this, value)); | |
| }, | |
| _asyncCompleteError$2: function(error, stackTrace) { | |
| if (this._state !== 0) | |
| H.throwExpression(new P.StateError("Future already completed")); | |
| this._state = 1; | |
| this._zone.toString; | |
| P._scheduleAsyncCallback(new P._Future__asyncCompleteError_closure(this, error, stackTrace)); | |
| }, | |
| _async$_Future$immediate$1: function(value, $T) { | |
| this._asyncComplete$1(value); | |
| }, | |
| $is_Future: true, | |
| $isFuture: true, | |
| static: { | |
| "": "_Future__INCOMPLETE,_Future__PENDING_COMPLETE,_Future__CHAINED,_Future__VALUE,_Future__ERROR", | |
| _Future$: function($T) { | |
| var t1 = new P._Future(0, $.Zone__current, null, null, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| return t1; | |
| }, | |
| _Future$immediate: function(value, $T) { | |
| var t1 = new P._Future(0, $.Zone__current, null, null, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| t1._async$_Future$immediate$1(value, $T); | |
| return t1; | |
| }, | |
| _Future$_then: function(onValueCallback, onErrorCallback, $T) { | |
| var t1 = $.Zone__current; | |
| t1.toString; | |
| t1 = new P._Future(0, t1, null, null, onValueCallback, null, P._registerErrorHandler(onErrorCallback, t1), null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| return t1; | |
| }, | |
| _Future$_catchError: function(onErrorCallback, errorTestCallback, $T) { | |
| var t1, t2; | |
| t1 = $.Zone__current; | |
| t2 = P._registerErrorHandler(onErrorCallback, t1); | |
| t1.toString; | |
| t2 = new P._Future(0, t1, null, null, null, errorTestCallback, t2, null); | |
| H.setRuntimeTypeInfo(t2, [$T]); | |
| return t2; | |
| }, | |
| _Future$_whenComplete: function(whenCompleteActionCallback, $T) { | |
| var t1 = $.Zone__current; | |
| t1.toString; | |
| t1 = new P._Future(0, t1, null, null, null, null, null, whenCompleteActionCallback); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| return t1; | |
| }, | |
| _Future__chainFutures: function(source, target) { | |
| var t1; | |
| target._state = 2; | |
| t1 = J.getInterceptor(source); | |
| if (typeof source === "object" && source !== null && !!t1.$is_Future) | |
| if (source._state >= 4) | |
| P._Future__propagateToListeners(source, target); | |
| else | |
| source._addListener$1(target); | |
| else | |
| source.then$2$onError(new P._Future__chainFutures_closure(target), new P._Future__chainFutures_closure0(target)); | |
| }, | |
| _Future__propagateMultipleListeners: function(source, listeners) { | |
| var listeners0; | |
| do { | |
| listeners0 = listeners.get$_nextListener(); | |
| listeners._nextListener = null; | |
| P._Future__propagateToListeners(source, listeners); | |
| if (listeners0 != null) { | |
| listeners = listeners0; | |
| continue; | |
| } else | |
| break; | |
| } while (true); | |
| }, | |
| _Future__propagateToListeners: function(source, listeners) { | |
| var t1, t2, hasError, asyncError, t3, t4, t5, chainSource, listeners0; | |
| t1 = {}; | |
| t1.source_4 = source; | |
| for (; true;) { | |
| t2 = {}; | |
| if (!t1.source_4.get$_isComplete()) | |
| return; | |
| hasError = t1.source_4.get$_hasError(); | |
| if (hasError && listeners == null) { | |
| t2 = t1.source_4; | |
| asyncError = t2.get$_error(); | |
| t2 = t2._zone; | |
| t3 = J.get$error$x(asyncError); | |
| t4 = asyncError.get$stackTrace(); | |
| t2.toString; | |
| P._rootHandleUncaughtError(t2, null, t2, t3, t4); | |
| return; | |
| } | |
| if (listeners == null) | |
| return; | |
| if (listeners._nextListener != null) { | |
| P._Future__propagateMultipleListeners(t1.source_4, listeners); | |
| return; | |
| } | |
| if (hasError) { | |
| t3 = t1.source_4.get$_zone(); | |
| t4 = listeners._zone; | |
| t3.toString; | |
| t4.toString; | |
| t3 = t4 == null ? t3 != null : t4 !== t3; | |
| } else | |
| t3 = false; | |
| if (t3) { | |
| t2 = t1.source_4; | |
| asyncError = t2.get$_error(); | |
| t2 = t2._zone; | |
| t3 = J.get$error$x(asyncError); | |
| t4 = asyncError.get$stackTrace(); | |
| t2.toString; | |
| P._rootHandleUncaughtError(t2, null, t2, t3, t4); | |
| return; | |
| } | |
| t3 = $.Zone__current; | |
| t4 = listeners._zone; | |
| if (t3 == null ? t4 != null : t3 !== t4) { | |
| t4.toString; | |
| P._rootRun(t4, null, t4, new P._Future__propagateToListeners_closure(t1, listeners)); | |
| return; | |
| } | |
| t2.listenerHasValue_1 = null; | |
| t2.listenerValueOrError_2 = null; | |
| t2.isPropagationAborted_3 = false; | |
| t4.toString; | |
| P._rootRun(t4, null, t4, new P._Future__propagateToListeners_closure0(t1, t2, hasError, listeners)); | |
| if (t2.isPropagationAborted_3) | |
| return; | |
| t3 = t2.listenerHasValue_1 === true; | |
| if (t3) { | |
| t4 = t2.listenerValueOrError_2; | |
| t5 = J.getInterceptor(t4); | |
| t5 = typeof t4 === "object" && t4 !== null && !!t5.$isFuture; | |
| t4 = t5; | |
| } else | |
| t4 = false; | |
| if (t4) { | |
| chainSource = t2.listenerValueOrError_2; | |
| t2 = J.getInterceptor(chainSource); | |
| if (typeof chainSource === "object" && chainSource !== null && !!t2.$is_Future && chainSource._state >= 4) { | |
| listeners._state = 2; | |
| t1.source_4 = chainSource; | |
| continue; | |
| } | |
| P._Future__chainFutures(chainSource, listeners); | |
| return; | |
| } | |
| if (t3) { | |
| listeners0 = listeners._removeListeners$0(); | |
| t2 = t2.listenerValueOrError_2; | |
| listeners._state = 4; | |
| listeners._resultOrListeners = t2; | |
| } else { | |
| listeners0 = listeners._removeListeners$0(); | |
| asyncError = t2.listenerValueOrError_2; | |
| t2 = J.get$error$x(asyncError); | |
| t3 = asyncError.get$stackTrace(); | |
| listeners._state = 8; | |
| listeners._resultOrListeners = new P._AsyncError(t2, t3); | |
| } | |
| t1.source_4 = listeners; | |
| listeners = listeners0; | |
| } | |
| }} | |
| }, | |
| _Future__addListener_closure: {"": "Closure;this_0,listener_1", | |
| call$0: function() { | |
| P._Future__propagateToListeners(this.this_0, this.listener_1); | |
| } | |
| }, | |
| _Future__chainFutures_closure: {"": "Closure;target_0", | |
| call$1: function(value) { | |
| this.target_0._complete$1(value); | |
| }, | |
| $is_args1: true | |
| }, | |
| _Future__chainFutures_closure0: {"": "Closure;target_1", | |
| call$2: function(error, stackTrace) { | |
| this.target_1._completeError$2(error, stackTrace); | |
| }, | |
| call$1: function(error) { | |
| return this.call$2(error, null); | |
| }, | |
| $is_args2: true, | |
| $is_args1: true | |
| }, | |
| _Future__asyncComplete_closure: {"": "Closure;this_0,value_1", | |
| call$0: function() { | |
| this.this_0._complete$1(this.value_1); | |
| } | |
| }, | |
| _Future__asyncCompleteError_closure: {"": "Closure;this_0,error_1,stackTrace_2", | |
| call$0: function() { | |
| this.this_0._completeError$2(this.error_1, this.stackTrace_2); | |
| } | |
| }, | |
| _Future__propagateToListeners_closure: {"": "Closure;box_2,listener_3", | |
| call$0: function() { | |
| P._Future__propagateToListeners(this.box_2.source_4, this.listener_3); | |
| } | |
| }, | |
| _Future__propagateToListeners_closure0: {"": "Closure;box_2,box_1,hasError_4,listener_5", | |
| call$0: function() { | |
| var t1, value, asyncError, test, matchesTest, errorCallback, e, s, t2, t3, t4, exception; | |
| t1 = {}; | |
| try { | |
| t2 = this.box_2; | |
| if (!this.hasError_4) { | |
| value = t2.source_4.get$_value(); | |
| t2 = this.listener_5; | |
| t3 = t2._state === 2 ? null : t2._onValueCallback; | |
| t4 = this.box_1; | |
| if (t3 != null) { | |
| t4.listenerValueOrError_2 = t2._onValue$1(value); | |
| t4.listenerHasValue_1 = true; | |
| } else { | |
| t4.listenerValueOrError_2 = value; | |
| t4.listenerHasValue_1 = true; | |
| } | |
| } else { | |
| asyncError = t2.source_4.get$_error(); | |
| t2 = this.listener_5; | |
| test = t2._state === 2 ? null : t2._errorTestCallback; | |
| matchesTest = true; | |
| if (test != null) | |
| matchesTest = test.call$1(J.get$error$x(asyncError)); | |
| if (matchesTest === true) | |
| t3 = (t2._state === 2 ? null : t2._onErrorCallback) != null; | |
| else | |
| t3 = false; | |
| if (t3) { | |
| errorCallback = t2._state === 2 ? null : t2._onErrorCallback; | |
| t2 = this.box_1; | |
| t2.listenerValueOrError_2 = P._invokeErrorHandler(errorCallback, J.get$error$x(asyncError), asyncError.get$stackTrace()); | |
| t2.listenerHasValue_1 = true; | |
| } else { | |
| t2 = this.box_1; | |
| t2.listenerValueOrError_2 = asyncError; | |
| t2.listenerHasValue_1 = false; | |
| } | |
| } | |
| t2 = this.listener_5; | |
| if ((t2._state === 2 ? null : t2._whenCompleteActionCallback) != null) { | |
| t1.completeResult_0 = t2._whenCompleteAction$0(); | |
| t3 = t1.completeResult_0; | |
| t4 = J.getInterceptor(t3); | |
| if (typeof t3 === "object" && t3 !== null && !!t4.$isFuture) { | |
| t2.set$_isChained(true); | |
| t1.completeResult_0.then$2$onError(new P._Future__propagateToListeners__closure(this.box_2, t2), new P._Future__propagateToListeners__closure0(t1, t2)); | |
| this.box_1.isPropagationAborted_3 = true; | |
| } | |
| } | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| if (this.hasError_4) { | |
| t1 = J.get$error$x(this.box_2.source_4.get$_error()); | |
| t2 = e; | |
| t2 = t1 == null ? t2 == null : t1 === t2; | |
| t1 = t2; | |
| } else | |
| t1 = false; | |
| t2 = this.box_1; | |
| if (t1) | |
| t2.listenerValueOrError_2 = this.box_2.source_4.get$_error(); | |
| else | |
| t2.listenerValueOrError_2 = new P._AsyncError(e, s); | |
| this.box_1.listenerHasValue_1 = false; | |
| } | |
| } | |
| }, | |
| _Future__propagateToListeners__closure: {"": "Closure;box_2,listener_6", | |
| call$1: function(ignored) { | |
| P._Future__propagateToListeners(this.box_2.source_4, this.listener_6); | |
| }, | |
| $is_args1: true | |
| }, | |
| _Future__propagateToListeners__closure0: {"": "Closure;box_0,listener_7", | |
| call$2: function(error, stackTrace) { | |
| var t1, t2, t3; | |
| t1 = this.box_0; | |
| t2 = t1.completeResult_0; | |
| t3 = J.getInterceptor(t2); | |
| if (typeof t2 !== "object" || t2 === null || !t3.$is_Future) { | |
| t1.completeResult_0 = P._Future$(null); | |
| t1.completeResult_0._setError$2(error, stackTrace); | |
| } | |
| P._Future__propagateToListeners(t1.completeResult_0, this.listener_7); | |
| }, | |
| call$1: function(error) { | |
| return this.call$2(error, null); | |
| }, | |
| $is_args2: true, | |
| $is_args1: true | |
| }, | |
| Stream: {"": "Object;", | |
| forEach$1: function(_, action) { | |
| var t1, future; | |
| t1 = {}; | |
| future = P._Future$(null); | |
| t1.subscription_0 = null; | |
| t1.subscription_0 = this.listen$4$cancelOnError$onDone$onError(new P.Stream_forEach_closure(t1, this, action, future), true, new P.Stream_forEach_closure0(future), future.get$_completeError()); | |
| return future; | |
| }, | |
| get$length: function(_) { | |
| var t1, future; | |
| t1 = {}; | |
| future = P._Future$(J.JSInt); | |
| t1.count_0 = 0; | |
| this.listen$4$cancelOnError$onDone$onError(new P.Stream_length_closure(t1), true, new P.Stream_length_closure0(t1, future), future.get$_completeError()); | |
| return future; | |
| } | |
| }, | |
| Stream_forEach_closure: {"": "Closure;box_0,this_1,action_2,future_3", | |
| call$1: function(element) { | |
| P._runUserCode(new P.Stream_forEach__closure(this.action_2, element), new P.Stream_forEach__closure0(), P._cancelAndErrorClosure(this.box_0.subscription_0, this.future_3)); | |
| }, | |
| $is_args1: true | |
| }, | |
| Stream_forEach__closure: {"": "Closure;action_4,element_5", | |
| call$0: function() { | |
| return this.action_4.call$1(this.element_5); | |
| } | |
| }, | |
| Stream_forEach__closure0: {"": "Closure;", | |
| call$1: function(_) { | |
| }, | |
| $is_args1: true | |
| }, | |
| Stream_forEach_closure0: {"": "Closure;future_6", | |
| call$0: function() { | |
| this.future_6._complete$1(null); | |
| } | |
| }, | |
| Stream_length_closure: {"": "Closure;box_0", | |
| call$1: function(_) { | |
| var t1 = this.box_0; | |
| t1.count_0 = t1.count_0 + 1; | |
| }, | |
| $is_args1: true | |
| }, | |
| Stream_length_closure0: {"": "Closure;box_0,future_1", | |
| call$0: function() { | |
| this.future_1._complete$1(this.box_0.count_0); | |
| } | |
| }, | |
| StreamSubscription: {"": "Object;"}, | |
| _StreamController: {"": "Object;", | |
| get$_pendingEvents: function() { | |
| if ((this._state & 8) === 0) | |
| return this._varData; | |
| return this._varData.get$varData(); | |
| }, | |
| _ensurePendingEvents$0: function() { | |
| if ((this._state & 8) === 0) { | |
| if (this._varData == null) | |
| this._varData = new P._StreamImplEvents(null, null, 0); | |
| return this._varData; | |
| } | |
| var t1 = this._varData.get$varData(); | |
| return t1; | |
| }, | |
| get$_subscription: function() { | |
| if ((this._state & 8) !== 0) | |
| return this._varData.get$varData(); | |
| return this._varData; | |
| }, | |
| _badEventState$0: function() { | |
| if ((this._state & 4) !== 0) | |
| return new P.StateError("Cannot add event after closing"); | |
| return new P.StateError("Cannot add event while adding a stream"); | |
| }, | |
| _ensureDoneFuture$0: function() { | |
| if (this._doneFuture == null) { | |
| this._doneFuture = P._Future$(null); | |
| if ((this._state & 2) !== 0) | |
| this._doneFuture._complete$1(null); | |
| } | |
| return this._doneFuture; | |
| }, | |
| add$1: function(_, value) { | |
| if (this._state >= 4) | |
| throw H.wrapException(this._badEventState$0()); | |
| this._async$_add$1(value); | |
| }, | |
| close$0: function(_) { | |
| var t1 = this._state; | |
| if ((t1 & 4) !== 0) | |
| return this._doneFuture; | |
| if (t1 >= 4) | |
| throw H.wrapException(this._badEventState$0()); | |
| this._state = (t1 | 4) >>> 0; | |
| this._ensureDoneFuture$0(); | |
| t1 = this._state; | |
| if ((t1 & 1) !== 0) | |
| this._sendDone$0(); | |
| else if ((t1 & 3) === 0) { | |
| t1 = this._ensurePendingEvents$0(); | |
| t1.add$1(t1, C.C__DelayedDone); | |
| } | |
| return this._doneFuture; | |
| }, | |
| _async$_add$1: function(value) { | |
| var t1 = this._state; | |
| if ((t1 & 1) !== 0) | |
| this._sendData$1(value); | |
| else if ((t1 & 3) === 0) { | |
| t1 = this._ensurePendingEvents$0(); | |
| t1.add$1(t1, new P._DelayedData(value, null)); | |
| } | |
| }, | |
| _addError$2: function(error, stackTrace) { | |
| var t1 = this._state; | |
| if ((t1 & 1) !== 0) | |
| this._sendError$2(error, stackTrace); | |
| else if ((t1 & 3) === 0) { | |
| t1 = this._ensurePendingEvents$0(); | |
| t1.add$1(t1, new P._DelayedError(error, stackTrace, null)); | |
| } | |
| }, | |
| _close$0: function() { | |
| var addState = this._varData; | |
| this._varData = addState.get$varData(); | |
| this._state = (this._state & 4294967287) >>> 0; | |
| addState.complete$0(addState); | |
| }, | |
| _subscribe$1: function(cancelOnError) { | |
| var t1, t2, subscription, pendingEvents, addState; | |
| if ((this._state & 3) !== 0) | |
| throw H.wrapException(new P.StateError("Stream has already been listened to.")); | |
| t1 = $.Zone__current; | |
| t2 = cancelOnError ? 1 : 0; | |
| subscription = new P._ControllerSubscription(this, null, null, null, t1, t2, null, null); | |
| H.setRuntimeTypeInfo(subscription, [null]); | |
| pendingEvents = this.get$_pendingEvents(); | |
| this._state = (this._state | 1) >>> 0; | |
| if ((this._state & 8) !== 0) { | |
| addState = this._varData; | |
| addState.set$varData(subscription); | |
| addState.resume$0(); | |
| } else | |
| this._varData = subscription; | |
| subscription._setPendingEvents$1(pendingEvents); | |
| subscription._guardCallback$1(new P._StreamController__subscribe_closure(this)); | |
| return subscription; | |
| }, | |
| _recordCancel$1: function(subscription) { | |
| var t1, future; | |
| if ((this._state & 8) !== 0) | |
| this._varData.cancel$0(); | |
| this._varData = null; | |
| this._state = (this._state & 4294967286 | 2) >>> 0; | |
| t1 = new P._StreamController__recordCancel_complete(this); | |
| future = P._runGuarded(this.get$_onCancel()); | |
| if (future != null) | |
| future = future.whenComplete$1(t1); | |
| else | |
| t1.call$0(); | |
| return future; | |
| }, | |
| _recordPause$1: function(subscription) { | |
| var addState; | |
| if ((this._state & 8) !== 0) { | |
| addState = this._varData; | |
| addState.pause$0(addState); | |
| } | |
| P._runGuarded(this.get$_onPause()); | |
| }, | |
| _recordResume$1: function(subscription) { | |
| if ((this._state & 8) !== 0) | |
| this._varData.resume$0(); | |
| P._runGuarded(this.get$_onResume()); | |
| } | |
| }, | |
| _StreamController__subscribe_closure: {"": "Closure;this_0", | |
| call$0: function() { | |
| P._runGuarded(this.this_0.get$_onListen()); | |
| } | |
| }, | |
| _StreamController__recordCancel_complete: {"": "Closure;this_0", | |
| call$0: function() { | |
| var t1 = this.this_0._doneFuture; | |
| if (t1 != null && t1._state === 0) | |
| t1._asyncComplete$1(null); | |
| } | |
| }, | |
| _SyncStreamControllerDispatch: {"": "Object;", | |
| _sendData$1: function(data) { | |
| this.get$_subscription()._async$_add$1(data); | |
| }, | |
| _sendError$2: function(error, stackTrace) { | |
| this.get$_subscription()._addError$2(error, stackTrace); | |
| }, | |
| _sendDone$0: function() { | |
| this.get$_subscription()._close$0(); | |
| } | |
| }, | |
| _AsyncStreamControllerDispatch: {"": "Object;", | |
| _sendData$1: function(data) { | |
| this.get$_subscription()._addPending$1(new P._DelayedData(data, null)); | |
| }, | |
| _sendError$2: function(error, stackTrace) { | |
| this.get$_subscription()._addPending$1(new P._DelayedError(error, stackTrace, null)); | |
| }, | |
| _sendDone$0: function() { | |
| this.get$_subscription()._addPending$1(C.C__DelayedDone); | |
| } | |
| }, | |
| _AsyncStreamController: {"": "_StreamController__AsyncStreamControllerDispatch;_onListen<,_onPause<,_onResume<,_onCancel<,_varData,_state,_doneFuture"}, | |
| _StreamController__AsyncStreamControllerDispatch: {"": "_StreamController+_AsyncStreamControllerDispatch;"}, | |
| _SyncStreamController: {"": "_StreamController__SyncStreamControllerDispatch;_onListen<,_onPause<,_onResume<,_onCancel<,_varData,_state,_doneFuture"}, | |
| _StreamController__SyncStreamControllerDispatch: {"": "_StreamController+_SyncStreamControllerDispatch;"}, | |
| _ControllerStream: {"": "_StreamImpl;_async$_controller", | |
| _createSubscription$1: function(cancelOnError) { | |
| return this._async$_controller._subscribe$1(cancelOnError); | |
| }, | |
| get$hashCode: function(_) { | |
| return (H.Primitives_objectHashCode(this._async$_controller) ^ 892482866) >>> 0; | |
| }, | |
| $eq: function(_, other) { | |
| var t1; | |
| if (other == null) | |
| return false; | |
| if (this === other) | |
| return true; | |
| t1 = J.getInterceptor(other); | |
| if (typeof other !== "object" || other === null || !t1.$is_ControllerStream) | |
| return false; | |
| return other._async$_controller === this._async$_controller; | |
| }, | |
| $is_ControllerStream: true, | |
| $as_StreamImpl: null | |
| }, | |
| _ControllerSubscription: {"": "_BufferingStreamSubscription;_async$_controller<,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending", | |
| _onCancel$0: function() { | |
| return this.get$_async$_controller()._recordCancel$1(this); | |
| }, | |
| _onPause$0: function() { | |
| this.get$_async$_controller()._recordPause$1(this); | |
| }, | |
| get$_onPause: function() { | |
| return new P.BoundClosure$0(this, P._ControllerSubscription.prototype._onPause$0, null, "_onPause$0"); | |
| }, | |
| _onResume$0: function() { | |
| this.get$_async$_controller()._recordResume$1(this); | |
| }, | |
| get$_onResume: function() { | |
| return new P.BoundClosure$0(this, P._ControllerSubscription.prototype._onResume$0, null, "_onResume$0"); | |
| }, | |
| $as_BufferingStreamSubscription: null | |
| }, | |
| _EventSink: {"": "Object;"}, | |
| _BufferingStreamSubscription: {"": "Object;_async$_onData,_onError,_onDone,_zone<,_state,_cancelFuture,_pending", | |
| _setPendingEvents$1: function(pendingEvents) { | |
| if (pendingEvents == null) | |
| return; | |
| this._pending = pendingEvents; | |
| if (!pendingEvents.get$isEmpty(pendingEvents)) { | |
| this._state = (this._state | 64) >>> 0; | |
| this._pending.schedule$1(this); | |
| } | |
| }, | |
| onData$1: function(handleData) { | |
| $.Zone__current.toString; | |
| this._async$_onData = handleData; | |
| }, | |
| onError$1: function(_, handleError) { | |
| if (handleError == null) | |
| handleError = P._nullErrorHandler$closure; | |
| this._onError = P._registerErrorHandler(handleError, $.Zone__current); | |
| }, | |
| onDone$1: function(handleDone) { | |
| if (handleDone == null) | |
| handleDone = P._nullDoneHandler$closure; | |
| $.Zone__current.toString; | |
| this._onDone = handleDone; | |
| }, | |
| pause$1: function(_, resumeSignal) { | |
| var t1 = this._state; | |
| if ((t1 & 8) !== 0) | |
| return; | |
| this._state = (t1 + 128 | 4) >>> 0; | |
| if (t1 < 128 && this._pending != null) | |
| this._pending.cancelSchedule$0(); | |
| if ((t1 & 4) === 0 && (this._state & 32) === 0) | |
| this._guardCallback$1(this.get$_onPause()); | |
| }, | |
| pause$0: function($receiver) { | |
| return this.pause$1($receiver, null); | |
| }, | |
| resume$0: function() { | |
| var t1, t2; | |
| t1 = this._state; | |
| if ((t1 & 8) !== 0) | |
| return; | |
| if (t1 >= 128) { | |
| this._state = t1 - 128; | |
| t1 = this._state; | |
| if (t1 < 128) { | |
| if ((t1 & 64) !== 0) { | |
| t2 = this._pending; | |
| t2 = !t2.get$isEmpty(t2); | |
| } else | |
| t2 = false; | |
| if (t2) | |
| this._pending.schedule$1(this); | |
| else { | |
| this._state = (t1 & 4294967291) >>> 0; | |
| if ((this._state & 32) === 0) | |
| this._guardCallback$1(this.get$_onResume()); | |
| } | |
| } | |
| } | |
| }, | |
| cancel$0: function() { | |
| this._state = (this._state & 4294967279) >>> 0; | |
| if ((this._state & 8) !== 0) | |
| return this._cancelFuture; | |
| this._cancel$0(); | |
| return this._cancelFuture; | |
| }, | |
| get$_mayResumeInput: function() { | |
| if (this._state < 128) { | |
| var t1 = this._pending; | |
| t1 = t1 == null || t1.get$isEmpty(t1); | |
| } else | |
| t1 = false; | |
| return t1; | |
| }, | |
| _cancel$0: function() { | |
| this._state = (this._state | 8) >>> 0; | |
| if ((this._state & 64) !== 0) | |
| this._pending.cancelSchedule$0(); | |
| if ((this._state & 32) === 0) | |
| this._pending = null; | |
| this._cancelFuture = this._onCancel$0(); | |
| }, | |
| _async$_add$1: function(data) { | |
| var t1 = this._state; | |
| if ((t1 & 8) !== 0) | |
| return; | |
| if (t1 < 32) | |
| this._sendData$1(data); | |
| else | |
| this._addPending$1(new P._DelayedData(data, null)); | |
| }, | |
| _addError$2: function(error, stackTrace) { | |
| var t1 = this._state; | |
| if ((t1 & 8) !== 0) | |
| return; | |
| if (t1 < 32) | |
| this._sendError$2(error, stackTrace); | |
| else | |
| this._addPending$1(new P._DelayedError(error, stackTrace, null)); | |
| }, | |
| _close$0: function() { | |
| var t1 = this._state; | |
| if ((t1 & 8) !== 0) | |
| return; | |
| this._state = (t1 | 2) >>> 0; | |
| if (this._state < 32) | |
| this._sendDone$0(); | |
| else | |
| this._addPending$1(C.C__DelayedDone); | |
| }, | |
| _onPause$0: function() { | |
| }, | |
| get$_onPause: function() { | |
| return new P.BoundClosure$0(this, P._BufferingStreamSubscription.prototype._onPause$0, null, "_onPause$0"); | |
| }, | |
| _onResume$0: function() { | |
| }, | |
| get$_onResume: function() { | |
| return new P.BoundClosure$0(this, P._BufferingStreamSubscription.prototype._onResume$0, null, "_onResume$0"); | |
| }, | |
| _onCancel$0: function() { | |
| }, | |
| _addPending$1: function($event) { | |
| var pending, t1; | |
| pending = this._pending; | |
| if (pending == null) { | |
| pending = new P._StreamImplEvents(null, null, 0); | |
| this._pending = pending; | |
| } | |
| pending.add$1(pending, $event); | |
| t1 = this._state; | |
| if ((t1 & 64) === 0) { | |
| this._state = (t1 | 64) >>> 0; | |
| if (this._state < 128) | |
| this._pending.schedule$1(this); | |
| } | |
| }, | |
| _sendData$1: function(data) { | |
| var t1 = this._state; | |
| this._state = (t1 | 32) >>> 0; | |
| this._zone.runUnaryGuarded$2(this._async$_onData, data); | |
| this._state = (this._state & 4294967263) >>> 0; | |
| this._checkState$1((t1 & 4) !== 0); | |
| }, | |
| _sendError$2: function(error, stackTrace) { | |
| var t1, t2, t3; | |
| t1 = this._state; | |
| t2 = new P._BufferingStreamSubscription__sendError_sendError(this, error, stackTrace); | |
| if ((t1 & 1) !== 0) { | |
| this._state = (t1 | 16) >>> 0; | |
| this._cancel$0(); | |
| t1 = this._cancelFuture; | |
| t3 = J.getInterceptor(t1); | |
| if (typeof t1 === "object" && t1 !== null && !!t3.$isFuture) | |
| t1.whenComplete$1(t2); | |
| else | |
| t2.call$0(); | |
| } else { | |
| t2.call$0(); | |
| this._checkState$1((t1 & 4) !== 0); | |
| } | |
| }, | |
| _sendDone$0: function() { | |
| var t1, t2, t3; | |
| t1 = new P._BufferingStreamSubscription__sendDone_sendDone(this); | |
| this._cancel$0(); | |
| this._state = (this._state | 16) >>> 0; | |
| t2 = this._cancelFuture; | |
| t3 = J.getInterceptor(t2); | |
| if (typeof t2 === "object" && t2 !== null && !!t3.$isFuture) | |
| t2.whenComplete$1(t1); | |
| else | |
| t1.call$0(); | |
| }, | |
| _guardCallback$1: function(callback) { | |
| var t1 = this._state; | |
| this._state = (t1 | 32) >>> 0; | |
| callback.call$0(); | |
| this._state = (this._state & 4294967263) >>> 0; | |
| this._checkState$1((t1 & 4) !== 0); | |
| }, | |
| _checkState$1: function(wasInputPaused) { | |
| var t1, t2, isInputPaused; | |
| t1 = this._state; | |
| if ((t1 & 64) !== 0) { | |
| t2 = this._pending; | |
| t2 = t2.get$isEmpty(t2); | |
| } else | |
| t2 = false; | |
| if (t2) { | |
| this._state = (t1 & 4294967231) >>> 0; | |
| if ((this._state & 4) !== 0 && this.get$_mayResumeInput()) | |
| this._state = (this._state & 4294967291) >>> 0; | |
| } | |
| for (; true; wasInputPaused = isInputPaused) { | |
| t1 = this._state; | |
| if ((t1 & 8) !== 0) { | |
| this._pending = null; | |
| return; | |
| } | |
| isInputPaused = (t1 & 4) !== 0; | |
| if (wasInputPaused === isInputPaused) | |
| break; | |
| this._state = (t1 ^ 32) >>> 0; | |
| if (isInputPaused) | |
| this._onPause$0(); | |
| else | |
| this._onResume$0(); | |
| this._state = (this._state & 4294967263) >>> 0; | |
| } | |
| t1 = this._state; | |
| if ((t1 & 64) !== 0 && t1 < 128) | |
| this._pending.schedule$1(this); | |
| }, | |
| static: { | |
| "": "_BufferingStreamSubscription__STATE_CANCEL_ON_ERROR,_BufferingStreamSubscription__STATE_CLOSED,_BufferingStreamSubscription__STATE_INPUT_PAUSED,_BufferingStreamSubscription__STATE_CANCELED,_BufferingStreamSubscription__STATE_WAIT_FOR_CANCEL,_BufferingStreamSubscription__STATE_IN_CALLBACK,_BufferingStreamSubscription__STATE_HAS_PENDING,_BufferingStreamSubscription__STATE_PAUSE_COUNT,_BufferingStreamSubscription__STATE_PAUSE_COUNT_SHIFT", | |
| } | |
| }, | |
| _BufferingStreamSubscription__sendError_sendError: {"": "Closure;this_0,error_1,stackTrace_2", | |
| call$0: function() { | |
| var t1, t2, t3, t4, t5; | |
| t1 = this.this_0; | |
| t2 = t1._state; | |
| if ((t2 & 8) !== 0 && (t2 & 16) === 0) | |
| return; | |
| t1._state = (t2 | 32) >>> 0; | |
| t2 = t1._zone; | |
| t3 = $.Zone__current; | |
| t2.toString; | |
| t3.toString; | |
| if (t3 == null ? t2 != null : t3 !== t2) | |
| P._rootHandleUncaughtError(t3, null, t3, this.error_1, this.stackTrace_2); | |
| else { | |
| t3 = t1._onError; | |
| t4 = J.getInterceptor(t3); | |
| t5 = this.error_1; | |
| if (!!t4.$is_args2) | |
| t2.runBinaryGuarded$3(t3, t5, this.stackTrace_2); | |
| else | |
| t2.runUnaryGuarded$2(t3, t5); | |
| } | |
| t1._state = (t1._state & 4294967263) >>> 0; | |
| } | |
| }, | |
| _BufferingStreamSubscription__sendDone_sendDone: {"": "Closure;this_0", | |
| call$0: function() { | |
| var t1, t2; | |
| t1 = this.this_0; | |
| t2 = t1._state; | |
| if ((t2 & 16) === 0) | |
| return; | |
| t1._state = (t2 | 42) >>> 0; | |
| t1._zone.runGuarded$1(t1._onDone); | |
| t1._state = (t1._state & 4294967263) >>> 0; | |
| } | |
| }, | |
| _StreamImpl: {"": "Stream;", | |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { | |
| var subscription = this._createSubscription$1(true === cancelOnError); | |
| subscription.onData$1(onData); | |
| subscription.onError$1(subscription, onError); | |
| subscription.onDone$1(onDone); | |
| return subscription; | |
| }, | |
| _createSubscription$1: function(cancelOnError) { | |
| var t1, t2, t3; | |
| t1 = H.getRuntimeTypeArgument(this, "_StreamImpl", 0); | |
| t2 = $.Zone__current; | |
| t3 = cancelOnError ? 1 : 0; | |
| t3 = new P._BufferingStreamSubscription(null, null, null, t2, t3, null, null); | |
| H.setRuntimeTypeInfo(t3, [t1]); | |
| return t3; | |
| }, | |
| $asStream: null | |
| }, | |
| _DelayedEvent: {"": "Object;next@"}, | |
| _DelayedData: {"": "_DelayedEvent;value,next", | |
| perform$1: function(dispatch) { | |
| dispatch._sendData$1(this.value); | |
| } | |
| }, | |
| _DelayedError: {"": "_DelayedEvent;error>,stackTrace<,next", | |
| perform$1: function(dispatch) { | |
| dispatch._sendError$2(this.error, this.stackTrace); | |
| } | |
| }, | |
| _DelayedDone: {"": "Object;", | |
| perform$1: function(dispatch) { | |
| dispatch._sendDone$0(); | |
| }, | |
| get$next: function() { | |
| return; | |
| }, | |
| set$next: function(_) { | |
| throw H.wrapException(P.StateError$("No events after a done.")); | |
| } | |
| }, | |
| _PendingEvents: {"": "Object;", | |
| schedule$1: function(dispatch) { | |
| var t1 = this._state; | |
| if (t1 === 1) | |
| return; | |
| if (t1 >= 1) { | |
| this._state = 1; | |
| return; | |
| } | |
| P.scheduleMicrotask(new P._PendingEvents_schedule_closure(this, dispatch)); | |
| this._state = 1; | |
| }, | |
| cancelSchedule$0: function() { | |
| if (this._state === 1) | |
| this._state = 3; | |
| } | |
| }, | |
| _PendingEvents_schedule_closure: {"": "Closure;this_0,dispatch_1", | |
| call$0: function() { | |
| var t1, oldState; | |
| t1 = this.this_0; | |
| oldState = t1._state; | |
| t1._state = 0; | |
| if (oldState === 3) | |
| return; | |
| t1.handleNext$1(this.dispatch_1); | |
| } | |
| }, | |
| _StreamImplEvents: {"": "_PendingEvents;firstPendingEvent,lastPendingEvent,_state", | |
| get$isEmpty: function(_) { | |
| return this.lastPendingEvent == null; | |
| }, | |
| add$1: function(_, $event) { | |
| var t1 = this.lastPendingEvent; | |
| if (t1 == null) { | |
| this.lastPendingEvent = $event; | |
| this.firstPendingEvent = $event; | |
| } else { | |
| t1.set$next($event); | |
| this.lastPendingEvent = $event; | |
| } | |
| }, | |
| handleNext$1: function(dispatch) { | |
| var $event = this.firstPendingEvent; | |
| this.firstPendingEvent = $event.get$next(); | |
| if (this.firstPendingEvent == null) | |
| this.lastPendingEvent = null; | |
| $event.perform$1(dispatch); | |
| } | |
| }, | |
| _cancelAndError_closure: {"": "Closure;future_0,error_1,stackTrace_2", | |
| call$0: function() { | |
| return this.future_0._completeError$2(this.error_1, this.stackTrace_2); | |
| } | |
| }, | |
| _cancelAndErrorClosure_closure: {"": "Closure;subscription_0,future_1", | |
| call$2: function(error, stackTrace) { | |
| return P._cancelAndError(this.subscription_0, this.future_1, error, stackTrace); | |
| }, | |
| $is_args2: true | |
| }, | |
| _BaseZone: {"": "Object;", | |
| runGuarded$1: function(f) { | |
| var e, s, t1, exception; | |
| try { | |
| t1 = this.run$1(f); | |
| return t1; | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| return this.handleUncaughtError$2(e, s); | |
| } | |
| }, | |
| runUnaryGuarded$2: function(f, arg) { | |
| var e, s, t1, exception; | |
| try { | |
| t1 = this.runUnary$2(f, arg); | |
| return t1; | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| return this.handleUncaughtError$2(e, s); | |
| } | |
| }, | |
| runBinaryGuarded$3: function(f, arg1, arg2) { | |
| var e, s, t1, exception; | |
| try { | |
| t1 = this.runBinary$3(f, arg1, arg2); | |
| return t1; | |
| } catch (exception) { | |
| t1 = H.unwrapException(exception); | |
| e = t1; | |
| s = new H._StackTrace(exception, null); | |
| return this.handleUncaughtError$2(e, s); | |
| } | |
| }, | |
| bindCallback$2$runGuarded: function(f, runGuarded) { | |
| var registered = this.registerCallback$1(f); | |
| if (runGuarded) | |
| return new P._BaseZone_bindCallback_closure(this, registered); | |
| else | |
| return new P._BaseZone_bindCallback_closure0(this, registered); | |
| }, | |
| bindUnaryCallback$2$runGuarded: function(f, runGuarded) { | |
| var registered = this.registerUnaryCallback$1(f); | |
| if (runGuarded) | |
| return new P._BaseZone_bindUnaryCallback_closure(this, registered); | |
| else | |
| return new P._BaseZone_bindUnaryCallback_closure0(this, registered); | |
| } | |
| }, | |
| _BaseZone_bindCallback_closure: {"": "Closure;this_0,registered_1", | |
| call$0: function() { | |
| return this.this_0.runGuarded$1(this.registered_1); | |
| } | |
| }, | |
| _BaseZone_bindCallback_closure0: {"": "Closure;this_2,registered_3", | |
| call$0: function() { | |
| return this.this_2.run$1(this.registered_3); | |
| } | |
| }, | |
| _BaseZone_bindUnaryCallback_closure: {"": "Closure;this_0,registered_1", | |
| call$1: function(arg) { | |
| return this.this_0.runUnaryGuarded$2(this.registered_1, arg); | |
| }, | |
| $is_args1: true | |
| }, | |
| _BaseZone_bindUnaryCallback_closure0: {"": "Closure;this_2,registered_3", | |
| call$1: function(arg) { | |
| return this.this_2.runUnary$2(this.registered_3, arg); | |
| }, | |
| $is_args1: true | |
| }, | |
| _rootHandleUncaughtError_closure: {"": "Closure;error_0,stackTrace_1", | |
| call$0: function() { | |
| P._scheduleAsyncCallback(new P._rootHandleUncaughtError__closure(this.error_0, this.stackTrace_1)); | |
| } | |
| }, | |
| _rootHandleUncaughtError__closure: {"": "Closure;error_2,stackTrace_3", | |
| call$0: function() { | |
| var t1, trace, t2; | |
| t1 = this.error_2; | |
| P.print("Uncaught Error: " + H.S(t1)); | |
| trace = this.stackTrace_3; | |
| if (trace == null) { | |
| t2 = J.getInterceptor(t1); | |
| t2 = typeof t1 === "object" && t1 !== null && !!t2.$isError; | |
| } else | |
| t2 = false; | |
| if (t2) | |
| trace = t1.get$stackTrace(); | |
| if (trace != null) | |
| P.print("Stack Trace: \n" + H.S(trace) + "\n"); | |
| throw H.wrapException(t1); | |
| } | |
| }, | |
| _RootZone: {"": "_BaseZone;", | |
| $index: function(_, key) { | |
| return; | |
| }, | |
| handleUncaughtError$2: function(error, stackTrace) { | |
| return P._rootHandleUncaughtError(this, null, this, error, stackTrace); | |
| }, | |
| run$1: function(f) { | |
| return P._rootRun(this, null, this, f); | |
| }, | |
| runUnary$2: function(f, arg) { | |
| return P._rootRunUnary(this, null, this, f, arg); | |
| }, | |
| runBinary$3: function(f, arg1, arg2) { | |
| return P._rootRunBinary(this, null, this, f, arg1, arg2); | |
| }, | |
| registerCallback$1: function(f) { | |
| return f; | |
| }, | |
| registerUnaryCallback$1: function(f) { | |
| return f; | |
| } | |
| }}], | |
| ["dart.collection", "dart:collection", , P, { | |
| _defaultEquals: function(a, b) { | |
| return J.$eq(a, b); | |
| }, | |
| _defaultHashCode: function(a) { | |
| return J.get$hashCode$(a); | |
| }, | |
| HashMap_HashMap: function(equals, hashCode, isValidKey, $K, $V) { | |
| var t1 = new P._HashMap(0, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$K, $V]); | |
| return t1; | |
| }, | |
| HashSet_HashSet$identity: function($E) { | |
| var t1 = new P._IdentityHashSet(0, null, null, null, null); | |
| H.setRuntimeTypeInfo(t1, [$E]); | |
| return t1; | |
| }, | |
| _iterableToString: function(iterable) { | |
| var parts, t1; | |
| t1 = $.get$_toStringVisiting(); | |
| if (t1.contains$1(t1, iterable)) | |
| return "(...)"; | |
| t1 = $.get$_toStringVisiting(); | |
| t1.add$1(t1, iterable); | |
| parts = []; | |
| try { | |
| P._iterablePartsToStrings(iterable, parts); | |
| } finally { | |
| t1 = $.get$_toStringVisiting(); | |
| t1.remove$1(t1, iterable); | |
| } | |
| t1 = P.StringBuffer$("("); | |
| t1.writeAll$2(parts, ", "); | |
| t1.write$1(")"); | |
| return t1._contents; | |
| }, | |
| _iterablePartsToStrings: function(iterable, parts) { | |
| var it, $length, count, 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 = H.S(it.get$current()); | |
| parts.push(next); | |
| $length += next.length + 2; | |
| ++count; | |
| } | |
| if (!it.moveNext$0()) { | |
| if (count <= 5) | |
| return; | |
| if (0 >= parts.length) | |
| throw H.ioore(parts, 0); | |
| ultimateString = parts.pop(); | |
| if (0 >= parts.length) | |
| throw H.ioore(parts, 0); | |
| penultimateString = parts.pop(); | |
| } else { | |
| penultimate = it.get$current(); | |
| ++count; | |
| if (!it.moveNext$0()) { | |
| if (count <= 4) { | |
| parts.push(H.S(penultimate)); | |
| return; | |
| } | |
| ultimateString = H.S(penultimate); | |
| if (0 >= parts.length) | |
| throw H.ioore(parts, 0); | |
| penultimateString = parts.pop(); | |
| $length += ultimateString.length + 2; | |
| } else { | |
| ultimate = it.get$current(); | |
| ++count; | |
| for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { | |
| ultimate0 = it.get$current(); | |
| ++count; | |
| if (count > 100) { | |
| while (true) { | |
| if (!($length > 75 && count > 3)) | |
| break; | |
| if (0 >= parts.length) | |
| throw H.ioore(parts, 0); | |
| $length -= parts.pop().length + 2; | |
| --count; | |
| } | |
| parts.push("..."); | |
| return; | |
| } | |
| } | |
| penultimateString = H.S(penultimate); | |
| ultimateString = H.S(ultimate); | |
| $length += ultimateString.length + penultimateString.length + 4; | |
| } | |
| } | |
| if (count > parts.length + 2) { | |
| $length += 5; | |
| elision = "..."; | |
| } else | |
| elision = null; | |
| while (true) { | |
| if (!($length > 80 && parts.length > 3)) | |
| break; | |
| if (0 >= parts.length) | |
| throw H.ioore(parts, 0); | |
| $length -= parts.pop().length + 2; | |
| if (elision == null) { | |
| $length += 5; | |
| elision = "..."; | |
| } | |
| } | |
| if (elision != null) | |
| parts.push(elision); | |
| parts.push(penultimateString); | |
| parts.push(ultimateString); | |
| }, | |
| LinkedHashMap_LinkedHashMap: function(equals, hashCode, isValidKey, $K, $V) { | |
| var t1 = new P._LinkedHashMap(0, null, null, null, null, null, 0); | |
| H.setRuntimeTypeInfo(t1, [$K, $V]); | |
| return t1; | |
| }, | |
| LinkedHashSet_LinkedHashSet: function(equals, hashCode, isValidKey, $E) { | |
| var t1 = new P._LinkedHashSet(0, null, null, null, null, null, 0); | |
| H.setRuntimeTypeInfo(t1, [$E]); | |
| return t1; | |
| }, | |
| Maps_mapToString: function(m) { | |
| var t1, result, i, t2; | |
| t1 = {}; | |
| for (i = 0; i < $.get$Maps__toStringList().length; ++i) { | |
| t2 = $.get$Maps__toStringList(); | |
| if (i >= t2.length) | |
| throw H.ioore(t2, i); | |
| if (t2[i] === m) | |
| return "{...}"; | |
| } | |
| result = P.StringBuffer$(""); | |
| try { | |
| $.get$Maps__toStringList().push(m); | |
| result.write$1("{"); | |
| t1.first_0 = true; | |
| J.forEach$1$ax(m, new P.Maps_mapToString_closure(t1, result)); | |
| result.write$1("}"); | |
| } finally { | |
| t1 = $.get$Maps__toStringList(); | |
| if (0 >= t1.length) | |
| throw H.ioore(t1, 0); | |
| t1.pop(); | |
| } | |
| return result.get$_contents(); | |
| }, | |
| _HashMap: {"": "Object;_collection$_length,_strings,_nums,_rest,_keys", | |
| get$length: function(_) { | |
| return this._collection$_length; | |
| }, | |
| get$keys: function() { | |
| var t1 = new P.HashMapKeyIterable(this); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_HashMap", 0)]); | |
| return t1; | |
| }, | |
| get$values: function(_) { | |
| var t1 = new P.HashMapKeyIterable(this); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_HashMap", 0)]); | |
| return H.MappedIterable_MappedIterable(t1, new P._HashMap_values_closure(this), H.getRuntimeTypeArgument(t1, "IterableBase", 0), null); | |
| }, | |
| $index: function(_, key) { | |
| var strings, t1, entry, nums, rest, bucket, index; | |
| if (typeof key === "string" && key !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) | |
| t1 = null; | |
| else { | |
| entry = strings[key]; | |
| t1 = entry === strings ? null : entry; | |
| } | |
| return t1; | |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| nums = this._nums; | |
| if (nums == null) | |
| t1 = null; | |
| else { | |
| entry = nums[key]; | |
| t1 = entry === nums ? null : entry; | |
| } | |
| return t1; | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return; | |
| bucket = rest[this._computeHashCode$1(key)]; | |
| index = this._findBucketIndex$2(bucket, key); | |
| return index < 0 ? null : bucket[index + 1]; | |
| } | |
| }, | |
| $indexSet: function(_, key, value) { | |
| var strings, nums, rest, hash, bucket, index; | |
| if (typeof key === "string" && key !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) { | |
| strings = P._HashMap__newHashTable(); | |
| this._strings = strings; | |
| } | |
| this._addHashTableEntry$3(strings, key, value); | |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| nums = this._nums; | |
| if (nums == null) { | |
| nums = P._HashMap__newHashTable(); | |
| this._nums = nums; | |
| } | |
| this._addHashTableEntry$3(nums, key, value); | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) { | |
| rest = P._HashMap__newHashTable(); | |
| this._rest = rest; | |
| } | |
| hash = this._computeHashCode$1(key); | |
| bucket = rest[hash]; | |
| if (bucket == null) { | |
| P._HashMap__setTableEntry(rest, hash, [key, value]); | |
| this._collection$_length = this._collection$_length + 1; | |
| this._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$_length + 1; | |
| this._keys = null; | |
| } | |
| } | |
| } | |
| }, | |
| forEach$1: function(_, action) { | |
| var keys, $length, i, key; | |
| keys = this._computeKeys$0(); | |
| for ($length = keys.length, i = 0; i < $length; ++i) { | |
| key = keys[i]; | |
| action.call$2(key, this.$index(this, key)); | |
| if (keys !== this._keys) | |
| throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| } | |
| }, | |
| _computeKeys$0: function() { | |
| var t1, result, strings, names, entries, index, i, nums, rest, bucket, $length, i0; | |
| t1 = this._keys; | |
| if (t1 != null) | |
| return t1; | |
| result = P.List_List(this._collection$_length, null); | |
| strings = this._strings; | |
| if (strings != null) { | |
| names = Object.getOwnPropertyNames(strings); | |
| entries = names.length; | |
| for (index = 0, i = 0; i < entries; ++i) { | |
| result[index] = names[i]; | |
| ++index; | |
| } | |
| } else | |
| index = 0; | |
| nums = this._nums; | |
| if (nums != null) { | |
| names = Object.getOwnPropertyNames(nums); | |
| entries = names.length; | |
| for (i = 0; i < entries; ++i) { | |
| result[index] = +names[i]; | |
| ++index; | |
| } | |
| } | |
| rest = this._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; | |
| } | |
| } | |
| } | |
| this._keys = result; | |
| return result; | |
| }, | |
| _addHashTableEntry$3: function(table, key, value) { | |
| if (table[key] == null) { | |
| this._collection$_length = this._collection$_length + 1; | |
| this._keys = null; | |
| } | |
| P._HashMap__setTableEntry(table, key, value); | |
| }, | |
| _computeHashCode$1: function(key) { | |
| return J.get$hashCode$(key) & 0x3ffffff; | |
| }, | |
| _findBucketIndex$2: function(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; | |
| }, | |
| $isMap: true, | |
| static: { | |
| _HashMap__setTableEntry: function(table, key, value) { | |
| if (value == null) | |
| table[key] = table; | |
| else | |
| table[key] = value; | |
| }, | |
| _HashMap__newHashTable: function() { | |
| var table = Object.create(null); | |
| P._HashMap__setTableEntry(table, "<non-identifier-key>", table); | |
| delete table["<non-identifier-key>"]; | |
| return table; | |
| }} | |
| }, | |
| _HashMap_values_closure: {"": "Closure;this_0", | |
| call$1: function(each) { | |
| var t1 = this.this_0; | |
| return t1.$index(t1, each); | |
| }, | |
| $is_args1: true | |
| }, | |
| HashMapKeyIterable: {"": "IterableBase;_map", | |
| get$length: function(_) { | |
| return this._map._collection$_length; | |
| }, | |
| get$iterator: function(_) { | |
| var t1 = this._map; | |
| return new P.HashMapKeyIterator(t1, t1._computeKeys$0(), 0, null); | |
| }, | |
| forEach$1: function(_, f) { | |
| var t1, keys, $length, i; | |
| t1 = this._map; | |
| keys = t1._computeKeys$0(); | |
| for ($length = keys.length, i = 0; i < $length; ++i) { | |
| f.call$1(keys[i]); | |
| if (keys !== t1._keys) | |
| throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| } | |
| }, | |
| $asIterableBase: null, | |
| $isEfficientLength: true | |
| }, | |
| HashMapKeyIterator: {"": "Object;_map,_keys,_offset,_collection$_current", | |
| get$current: function() { | |
| return this._collection$_current; | |
| }, | |
| moveNext$0: function() { | |
| var keys, offset, t1; | |
| keys = this._keys; | |
| offset = this._offset; | |
| t1 = this._map; | |
| if (keys !== t1._keys) | |
| throw H.wrapException(P.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; | |
| } | |
| } | |
| }, | |
| _LinkedHashMap: {"": "Object;_collection$_length,_strings,_nums,_rest,_first,_last,_modifications", | |
| get$length: function(_) { | |
| return this._collection$_length; | |
| }, | |
| get$keys: function() { | |
| var t1 = new P.LinkedHashMapKeyIterable(this); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_LinkedHashMap", 0)]); | |
| return t1; | |
| }, | |
| get$values: function(_) { | |
| var t1 = new P.LinkedHashMapKeyIterable(this); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_LinkedHashMap", 0)]); | |
| return H.MappedIterable_MappedIterable(t1, new P._LinkedHashMap_values_closure(this), H.getRuntimeTypeArgument(t1, "IterableBase", 0), null); | |
| }, | |
| containsKey$1: function(key) { | |
| var strings, nums, rest; | |
| if (typeof key === "string" && key !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) | |
| return false; | |
| return strings[key] != null; | |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| nums = this._nums; | |
| if (nums == null) | |
| return false; | |
| return nums[key] != null; | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return false; | |
| return this._findBucketIndex$2(rest[this._computeHashCode$1(key)], key) >= 0; | |
| } | |
| }, | |
| $index: function(_, key) { | |
| var strings, cell, nums, rest, bucket, index; | |
| if (typeof key === "string" && key !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) | |
| return; | |
| cell = strings[key]; | |
| return cell == null ? null : cell.get$_collection$_value(); | |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| nums = this._nums; | |
| if (nums == null) | |
| return; | |
| cell = nums[key]; | |
| return cell == null ? null : cell.get$_collection$_value(); | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return; | |
| bucket = rest[this._computeHashCode$1(key)]; | |
| index = this._findBucketIndex$2(bucket, key); | |
| if (index < 0) | |
| return; | |
| return bucket[index].get$_collection$_value(); | |
| } | |
| }, | |
| $indexSet: function(_, key, value) { | |
| var strings, nums, rest, hash, bucket, index; | |
| if (typeof key === "string" && key !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) { | |
| strings = P._LinkedHashMap__newHashTable(); | |
| this._strings = strings; | |
| } | |
| this._addHashTableEntry$3(strings, key, value); | |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| nums = this._nums; | |
| if (nums == null) { | |
| nums = P._LinkedHashMap__newHashTable(); | |
| this._nums = nums; | |
| } | |
| this._addHashTableEntry$3(nums, key, value); | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) { | |
| rest = P._LinkedHashMap__newHashTable(); | |
| this._rest = rest; | |
| } | |
| hash = this._computeHashCode$1(key); | |
| bucket = rest[hash]; | |
| if (bucket == null) | |
| rest[hash] = [this._newLinkedCell$2(key, value)]; | |
| else { | |
| index = this._findBucketIndex$2(bucket, key); | |
| if (index >= 0) | |
| bucket[index].set$_collection$_value(value); | |
| else | |
| bucket.push(this._newLinkedCell$2(key, value)); | |
| } | |
| } | |
| }, | |
| remove$1: function(_, key) { | |
| var rest, bucket, index, cell; | |
| if (typeof key === "string" && key !== "__proto__") | |
| return this._removeHashTableEntry$2(this._strings, key); | |
| else if (typeof key === "number" && (key & 0x3ffffff) === key) | |
| return this._removeHashTableEntry$2(this._nums, key); | |
| else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return; | |
| bucket = rest[this._computeHashCode$1(key)]; | |
| index = this._findBucketIndex$2(bucket, key); | |
| if (index < 0) | |
| return; | |
| cell = bucket.splice(index, 1)[0]; | |
| this._unlinkCell$1(cell); | |
| return cell.get$_collection$_value(); | |
| } | |
| }, | |
| clear$0: function(_) { | |
| if (this._collection$_length > 0) { | |
| this._last = null; | |
| this._first = null; | |
| this._rest = null; | |
| this._nums = null; | |
| this._strings = null; | |
| this._collection$_length = 0; | |
| this._modifications = this._modifications + 1 & 67108863; | |
| } | |
| }, | |
| forEach$1: function(_, action) { | |
| var cell, modifications; | |
| cell = this._first; | |
| modifications = this._modifications; | |
| for (; cell != null;) { | |
| action.call$2(cell.get$_key(), cell._collection$_value); | |
| if (modifications !== this._modifications) | |
| throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| cell = cell._next; | |
| } | |
| }, | |
| _addHashTableEntry$3: function(table, key, value) { | |
| var cell = table[key]; | |
| if (cell == null) | |
| table[key] = this._newLinkedCell$2(key, value); | |
| else | |
| cell.set$_collection$_value(value); | |
| }, | |
| _removeHashTableEntry$2: function(table, key) { | |
| var cell; | |
| if (table == null) | |
| return; | |
| cell = table[key]; | |
| if (cell == null) | |
| return; | |
| this._unlinkCell$1(cell); | |
| delete table[key]; | |
| return cell.get$_collection$_value(); | |
| }, | |
| _newLinkedCell$2: function(key, value) { | |
| var cell, last; | |
| cell = new P.LinkedHashMapCell(key, value, null, null); | |
| if (this._first == null) { | |
| this._last = cell; | |
| this._first = cell; | |
| } else { | |
| last = this._last; | |
| cell._previous = last; | |
| last.set$_next(cell); | |
| this._last = cell; | |
| } | |
| this._collection$_length = this._collection$_length + 1; | |
| this._modifications = this._modifications + 1 & 67108863; | |
| return cell; | |
| }, | |
| _unlinkCell$1: function(cell) { | |
| var previous, next; | |
| previous = cell.get$_previous(); | |
| next = cell.get$_next(); | |
| if (previous == null) | |
| this._first = next; | |
| else | |
| previous.set$_next(next); | |
| if (next == null) | |
| this._last = previous; | |
| else | |
| next.set$_previous(previous); | |
| this._collection$_length = this._collection$_length - 1; | |
| this._modifications = this._modifications + 1 & 67108863; | |
| }, | |
| _computeHashCode$1: function(key) { | |
| return J.get$hashCode$(key) & 0x3ffffff; | |
| }, | |
| _findBucketIndex$2: function(bucket, key) { | |
| var $length, i; | |
| if (bucket == null) | |
| return -1; | |
| $length = bucket.length; | |
| for (i = 0; i < $length; ++i) | |
| if (J.$eq(bucket[i].get$_key(), key)) | |
| return i; | |
| return -1; | |
| }, | |
| toString$0: function(_) { | |
| return P.Maps_mapToString(this); | |
| }, | |
| $isMap: true, | |
| static: { | |
| _LinkedHashMap__newHashTable: function() { | |
| var table = Object.create(null); | |
| table["<non-identifier-key>"] = table; | |
| delete table["<non-identifier-key>"]; | |
| return table; | |
| }} | |
| }, | |
| _LinkedHashMap_values_closure: {"": "Closure;this_0", | |
| call$1: function(each) { | |
| var t1 = this.this_0; | |
| return t1.$index(t1, each); | |
| }, | |
| $is_args1: true | |
| }, | |
| LinkedHashMapCell: {"": "Object;_key<,_collection$_value@,_next@,_previous@"}, | |
| LinkedHashMapKeyIterable: {"": "IterableBase;_map", | |
| get$length: function(_) { | |
| return this._map._collection$_length; | |
| }, | |
| get$iterator: function(_) { | |
| var t1 = this._map; | |
| t1 = new P.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); | |
| t1._cell = t1._map._first; | |
| return t1; | |
| }, | |
| forEach$1: function(_, f) { | |
| var t1, cell, modifications; | |
| t1 = this._map; | |
| cell = t1._first; | |
| modifications = t1._modifications; | |
| for (; cell != null;) { | |
| f.call$1(cell.get$_key()); | |
| if (modifications !== t1._modifications) | |
| throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| cell = cell._next; | |
| } | |
| }, | |
| $asIterableBase: null, | |
| $isEfficientLength: true | |
| }, | |
| LinkedHashMapKeyIterator: {"": "Object;_map,_modifications,_cell,_collection$_current", | |
| get$current: function() { | |
| return this._collection$_current; | |
| }, | |
| moveNext$0: function() { | |
| var t1 = this._map; | |
| if (this._modifications !== t1._modifications) | |
| throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| else { | |
| t1 = this._cell; | |
| if (t1 == null) { | |
| this._collection$_current = null; | |
| return false; | |
| } else { | |
| this._collection$_current = t1.get$_key(); | |
| this._cell = this._cell.get$_next(); | |
| return true; | |
| } | |
| } | |
| } | |
| }, | |
| _HashSet: {"": "_HashSetBase;", | |
| get$iterator: function(_) { | |
| return new P.HashSetIterator(this, this._computeElements$0(), 0, null); | |
| }, | |
| get$length: function(_) { | |
| return this._collection$_length; | |
| }, | |
| contains$1: function(_, object) { | |
| var strings, nums, rest; | |
| if (typeof object === "string" && object !== "__proto__") { | |
| strings = this._strings; | |
| return strings == null ? false : strings[object] != null; | |
| } else if (typeof object === "number" && (object & 0x3ffffff) === object) { | |
| nums = this._nums; | |
| return nums == null ? false : nums[object] != null; | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return false; | |
| return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; | |
| } | |
| }, | |
| lookup$1: function(object) { | |
| var t1, rest, bucket, index; | |
| if (!(typeof object === "string" && object !== "__proto__")) | |
| t1 = typeof object === "number" && (object & 0x3ffffff) === object; | |
| else | |
| t1 = true; | |
| if (t1) | |
| return this.contains$1(this, object) ? object : null; | |
| rest = this._rest; | |
| if (rest == null) | |
| return; | |
| bucket = rest[this._computeHashCode$1(object)]; | |
| index = this._findBucketIndex$2(bucket, object); | |
| if (index < 0) | |
| return; | |
| return J.$index$asx(bucket, index); | |
| }, | |
| add$1: function(_, element) { | |
| var strings, table, rest, hash, bucket; | |
| if (typeof element === "string" && element !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) { | |
| table = Object.create(null); | |
| table["<non-identifier-key>"] = table; | |
| delete table["<non-identifier-key>"]; | |
| this._strings = table; | |
| strings = table; | |
| } | |
| return this._addHashTableEntry$2(strings, element); | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) { | |
| table = Object.create(null); | |
| table["<non-identifier-key>"] = table; | |
| delete table["<non-identifier-key>"]; | |
| this._rest = table; | |
| rest = table; | |
| } | |
| 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._collection$_length + 1; | |
| this._elements = null; | |
| return true; | |
| } | |
| }, | |
| remove$1: function(_, object) { | |
| var rest, bucket, index; | |
| rest = this._rest; | |
| if (rest == null) | |
| return false; | |
| bucket = rest[this._computeHashCode$1(object)]; | |
| index = this._findBucketIndex$2(bucket, object); | |
| if (index < 0) | |
| return false; | |
| this._collection$_length = this._collection$_length - 1; | |
| this._elements = null; | |
| bucket.splice(index, 1); | |
| return true; | |
| }, | |
| _computeElements$0: function() { | |
| var t1, result, strings, names, entries, index, i, nums, rest, bucket, $length, i0; | |
| t1 = this._elements; | |
| if (t1 != null) | |
| return t1; | |
| result = P.List_List(this._collection$_length, null); | |
| strings = this._strings; | |
| if (strings != null) { | |
| names = Object.getOwnPropertyNames(strings); | |
| entries = names.length; | |
| for (index = 0, i = 0; i < entries; ++i) { | |
| result[index] = names[i]; | |
| ++index; | |
| } | |
| } else | |
| index = 0; | |
| nums = this._nums; | |
| if (nums != null) { | |
| names = Object.getOwnPropertyNames(nums); | |
| entries = names.length; | |
| for (i = 0; i < entries; ++i) { | |
| result[index] = +names[i]; | |
| ++index; | |
| } | |
| } | |
| rest = this._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; | |
| } | |
| } | |
| } | |
| this._elements = result; | |
| return result; | |
| }, | |
| _addHashTableEntry$2: function(table, element) { | |
| if (table[element] != null) | |
| return false; | |
| table[element] = 0; | |
| this._collection$_length = this._collection$_length + 1; | |
| this._elements = null; | |
| return true; | |
| }, | |
| _computeHashCode$1: function(element) { | |
| return J.get$hashCode$(element) & 0x3ffffff; | |
| }, | |
| _findBucketIndex$2: function(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; | |
| }, | |
| $as_HashSetBase: null, | |
| $isEfficientLength: true | |
| }, | |
| _IdentityHashSet: {"": "_HashSet;_collection$_length,_strings,_nums,_rest,_elements", | |
| _computeHashCode$1: function(key) { | |
| return H.objectHashCode(key) & 0x3ffffff; | |
| }, | |
| _findBucketIndex$2: function(bucket, element) { | |
| var $length, i, t1; | |
| if (bucket == null) | |
| return -1; | |
| $length = bucket.length; | |
| for (i = 0; i < $length; ++i) { | |
| t1 = bucket[i]; | |
| if (t1 == null ? element == null : t1 === element) | |
| return i; | |
| } | |
| return -1; | |
| }, | |
| $as_HashSet: null | |
| }, | |
| HashSetIterator: {"": "Object;_set,_elements,_offset,_collection$_current", | |
| get$current: function() { | |
| return this._collection$_current; | |
| }, | |
| moveNext$0: function() { | |
| var elements, offset, t1; | |
| elements = this._elements; | |
| offset = this._offset; | |
| t1 = this._set; | |
| if (elements !== t1._elements) | |
| throw H.wrapException(P.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; | |
| } | |
| } | |
| }, | |
| _LinkedHashSet: {"": "_HashSetBase;_collection$_length,_strings,_nums,_rest,_first,_last,_modifications", | |
| get$iterator: function(_) { | |
| var t1 = new P.LinkedHashSetIterator(this, this._modifications, null, null); | |
| t1._cell = t1._set._first; | |
| return t1; | |
| }, | |
| get$length: function(_) { | |
| return this._collection$_length; | |
| }, | |
| contains$1: function(_, object) { | |
| var strings, nums, rest; | |
| if (typeof object === "string" && object !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) | |
| return false; | |
| return strings[object] != null; | |
| } else if (typeof object === "number" && (object & 0x3ffffff) === object) { | |
| nums = this._nums; | |
| if (nums == null) | |
| return false; | |
| return nums[object] != null; | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return false; | |
| return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; | |
| } | |
| }, | |
| lookup$1: function(object) { | |
| var t1, rest, bucket, index; | |
| if (!(typeof object === "string" && object !== "__proto__")) | |
| t1 = typeof object === "number" && (object & 0x3ffffff) === object; | |
| else | |
| t1 = true; | |
| if (t1) | |
| return this.contains$1(this, object) ? object : null; | |
| else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return; | |
| bucket = rest[this._computeHashCode$1(object)]; | |
| index = this._findBucketIndex$2(bucket, object); | |
| if (index < 0) | |
| return; | |
| return J.$index$asx(bucket, index).get$_collection$_element(); | |
| } | |
| }, | |
| forEach$1: function(_, action) { | |
| var cell, modifications; | |
| cell = this._first; | |
| modifications = this._modifications; | |
| for (; cell != null;) { | |
| action.call$1(cell.get$_collection$_element()); | |
| if (modifications !== this._modifications) | |
| throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| cell = cell._next; | |
| } | |
| }, | |
| add$1: function(_, element) { | |
| var strings, table, rest, hash, bucket; | |
| if (typeof element === "string" && element !== "__proto__") { | |
| strings = this._strings; | |
| if (strings == null) { | |
| table = Object.create(null); | |
| table["<non-identifier-key>"] = table; | |
| delete table["<non-identifier-key>"]; | |
| this._strings = table; | |
| strings = table; | |
| } | |
| return this._addHashTableEntry$2(strings, element); | |
| } else { | |
| rest = this._rest; | |
| if (rest == null) { | |
| table = Object.create(null); | |
| table["<non-identifier-key>"] = table; | |
| delete table["<non-identifier-key>"]; | |
| this._rest = table; | |
| rest = table; | |
| } | |
| hash = this._computeHashCode$1(element); | |
| bucket = rest[hash]; | |
| if (bucket == null) | |
| rest[hash] = [this._newLinkedCell$1(element)]; | |
| else { | |
| if (this._findBucketIndex$2(bucket, element) >= 0) | |
| return false; | |
| bucket.push(this._newLinkedCell$1(element)); | |
| } | |
| return true; | |
| } | |
| }, | |
| addAll$1: function(_, objects) { | |
| var t1; | |
| for (t1 = new P.LinkedHashSetIterator(objects, objects._modifications, null, null), t1._cell = t1._set._first; t1.moveNext$0();) | |
| this.add$1(this, t1._collection$_current); | |
| }, | |
| remove$1: function(_, object) { | |
| var rest, bucket, index; | |
| if (object !== "__proto__") | |
| return this._removeHashTableEntry$2(this._strings, object); | |
| else { | |
| rest = this._rest; | |
| if (rest == null) | |
| return false; | |
| bucket = rest[this._computeHashCode$1(object)]; | |
| index = this._findBucketIndex$2(bucket, object); | |
| if (index < 0) | |
| return false; | |
| this._unlinkCell$1(bucket.splice(index, 1)[0]); | |
| return true; | |
| } | |
| }, | |
| _addHashTableEntry$2: function(table, element) { | |
| if (table[element] != null) | |
| return false; | |
| table[element] = this._newLinkedCell$1(element); | |
| return true; | |
| }, | |
| _removeHashTableEntry$2: function(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; | |
| }, | |
| _newLinkedCell$1: function(element) { | |
| var cell, last; | |
| cell = new P.LinkedHashSetCell(element, null, null); | |
| if (this._first == null) { | |
| this._last = cell; | |
| this._first = cell; | |
| } else { | |
| last = this._last; | |
| cell._previous = last; | |
| last.set$_next(cell); | |
| this._last = cell; | |
| } | |
| this._collection$_length = this._collection$_length + 1; | |
| this._modifications = this._modifications + 1 & 67108863; | |
| return cell; | |
| }, | |
| _unlinkCell$1: function(cell) { | |
| var previous, next; | |
| previous = cell.get$_previous(); | |
| next = cell.get$_next(); | |
| if (previous == null) | |
| this._first = next; | |
| else | |
| previous.set$_next(next); | |
| if (next == null) | |
| this._last = previous; | |
| else | |
| next.set$_previous(previous); | |
| this._collection$_length = this._collection$_length - 1; | |
| this._modifications = this._modifications + 1 & 67108863; | |
| }, | |
| _computeHashCode$1: function(element) { | |
| return J.get$hashCode$(element) & 0x3ffffff; | |
| }, | |
| _findBucketIndex$2: function(bucket, element) { | |
| var $length, i, t1; | |
| if (bucket == null) | |
| return -1; | |
| $length = bucket.length; | |
| for (i = 0; i < $length; ++i) { | |
| t1 = bucket[i].get$_collection$_element(); | |
| if (t1 == null ? element == null : t1 === element) | |
| return i; | |
| } | |
| return -1; | |
| }, | |
| $as_HashSetBase: null, | |
| $isEfficientLength: true | |
| }, | |
| LinkedHashSetCell: {"": "Object;_collection$_element<,_next@,_previous@"}, | |
| LinkedHashSetIterator: {"": "Object;_set,_modifications,_cell,_collection$_current", | |
| get$current: function() { | |
| return this._collection$_current; | |
| }, | |
| moveNext$0: function() { | |
| var t1 = this._set; | |
| if (this._modifications !== t1._modifications) | |
| throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| else { | |
| t1 = this._cell; | |
| if (t1 == null) { | |
| this._collection$_current = null; | |
| return false; | |
| } else { | |
| this._collection$_current = t1.get$_collection$_element(); | |
| this._cell = this._cell.get$_next(); | |
| return true; | |
| } | |
| } | |
| } | |
| }, | |
| _HashSetBase: {"": "IterableBase;", | |
| toString$0: function(_) { | |
| return H.IterableMixinWorkaround_toStringIterable(this, "{", "}"); | |
| }, | |
| $asIterableBase: null, | |
| $isEfficientLength: true | |
| }, | |
| IterableBase: {"": "Object;", | |
| forEach$1: function(_, f) { | |
| var t1; | |
| for (t1 = this.get$iterator(this); t1.moveNext$0();) | |
| f.call$1(t1.get$current()); | |
| }, | |
| join$1: function(_, separator) { | |
| var iterator, buffer, t1; | |
| iterator = this.get$iterator(this); | |
| if (!iterator.moveNext$0()) | |
| return ""; | |
| buffer = P.StringBuffer$(""); | |
| if (separator === "") | |
| do { | |
| t1 = H.S(iterator.get$current()); | |
| buffer._contents = buffer._contents + t1; | |
| } while (iterator.moveNext$0()); | |
| else { | |
| buffer.write$1(H.S(iterator.get$current())); | |
| for (; iterator.moveNext$0();) { | |
| buffer._contents = buffer._contents + separator; | |
| t1 = H.S(iterator.get$current()); | |
| buffer._contents = buffer._contents + t1; | |
| } | |
| } | |
| return buffer._contents; | |
| }, | |
| toList$1$growable: function(_, growable) { | |
| return P.List_List$from(this, growable, H.getRuntimeTypeArgument(this, "IterableBase", 0)); | |
| }, | |
| toList$0: function($receiver) { | |
| return this.toList$1$growable($receiver, true); | |
| }, | |
| get$length: function(_) { | |
| var it, count; | |
| it = this.get$iterator(this); | |
| for (count = 0; it.moveNext$0();) | |
| ++count; | |
| return count; | |
| }, | |
| elementAt$1: function(_, index) { | |
| var t1, remaining, element; | |
| if (index < 0) | |
| throw H.wrapException(P.RangeError$value(index)); | |
| for (t1 = this.get$iterator(this), remaining = index; t1.moveNext$0();) { | |
| element = t1.get$current(); | |
| if (remaining === 0) | |
| return element; | |
| --remaining; | |
| } | |
| throw H.wrapException(P.RangeError$value(index)); | |
| }, | |
| toString$0: function(_) { | |
| return P._iterableToString(this); | |
| } | |
| }, | |
| ListBase: {"": "Object+ListMixin;", $isList: true, $asList: null, $isEfficientLength: true}, | |
| ListMixin: {"": "Object;", | |
| get$iterator: function(receiver) { | |
| return new H.ListIterator(receiver, this.get$length(receiver), 0, null); | |
| }, | |
| elementAt$1: function(receiver, index) { | |
| return this.$index(receiver, index); | |
| }, | |
| forEach$1: function(receiver, action) { | |
| var $length, i; | |
| $length = this.get$length(receiver); | |
| for (i = 0; i < $length; ++i) { | |
| action.call$1(this.$index(receiver, i)); | |
| if ($length !== this.get$length(receiver)) | |
| throw H.wrapException(P.ConcurrentModificationError$(receiver)); | |
| } | |
| }, | |
| where$1: function(receiver, test) { | |
| var t1 = new H.WhereIterable(receiver, test); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(receiver, "ListMixin", 0)]); | |
| return t1; | |
| }, | |
| add$1: function(receiver, element) { | |
| var t1 = this.get$length(receiver); | |
| this.set$length(receiver, t1 + 1); | |
| this.$indexSet(receiver, t1, element); | |
| }, | |
| toString$0: function(receiver) { | |
| var result, t1; | |
| t1 = $.get$_toStringVisiting(); | |
| if (t1.contains$1(t1, receiver)) | |
| return "[...]"; | |
| result = P.StringBuffer$(""); | |
| try { | |
| t1 = $.get$_toStringVisiting(); | |
| t1.add$1(t1, receiver); | |
| result.write$1("["); | |
| result.writeAll$2(receiver, ", "); | |
| result.write$1("]"); | |
| } finally { | |
| t1 = $.get$_toStringVisiting(); | |
| t1.remove$1(t1, receiver); | |
| } | |
| return result.get$_contents(); | |
| }, | |
| $isList: true, | |
| $asList: null, | |
| $isEfficientLength: true | |
| }, | |
| Maps_mapToString_closure: {"": "Closure;box_0,result_1", | |
| call$2: function(k, v) { | |
| var t1 = this.box_0; | |
| if (!t1.first_0) | |
| this.result_1.write$1(", "); | |
| t1.first_0 = false; | |
| t1 = this.result_1; | |
| t1.write$1(k); | |
| t1.write$1(": "); | |
| t1.write$1(v); | |
| }, | |
| $is_args2: true | |
| }, | |
| ListQueue: {"": "IterableBase;_table,_head,_tail,_modificationCount", | |
| get$iterator: function(_) { | |
| return P._ListQueueIterator$(this); | |
| }, | |
| forEach$1: function(_, action) { | |
| var modificationCount, i, t1; | |
| modificationCount = this._modificationCount; | |
| for (i = this._head; i !== this._tail; i = (i + 1 & this._table.length - 1) >>> 0) { | |
| t1 = this._table; | |
| if (i < 0 || i >= t1.length) | |
| throw H.ioore(t1, i); | |
| action.call$1(t1[i]); | |
| if (modificationCount !== this._modificationCount) | |
| H.throwExpression(P.ConcurrentModificationError$(this)); | |
| } | |
| }, | |
| get$length: function(_) { | |
| return (this._tail - this._head & this._table.length - 1) >>> 0; | |
| }, | |
| add$1: function(_, element) { | |
| this._add$1(element); | |
| }, | |
| toString$0: function(_) { | |
| return H.IterableMixinWorkaround_toStringIterable(this, "{", "}"); | |
| }, | |
| removeFirst$0: function() { | |
| var t1, t2, t3, result; | |
| if (this._head === this._tail) | |
| throw H.wrapException(P.StateError$("No elements")); | |
| this._modificationCount = this._modificationCount + 1; | |
| t1 = this._table; | |
| t2 = this._head; | |
| t3 = t1.length; | |
| if (t2 < 0 || t2 >= t3) | |
| throw H.ioore(t1, t2); | |
| result = t1[t2]; | |
| this._head = (t2 + 1 & t3 - 1) >>> 0; | |
| return result; | |
| }, | |
| _add$1: function(element) { | |
| var t1, t2, t3; | |
| t1 = this._table; | |
| t2 = this._tail; | |
| t3 = t1.length; | |
| if (t2 < 0 || t2 >= t3) | |
| throw H.ioore(t1, t2); | |
| t1[t2] = element; | |
| this._tail = (t2 + 1 & t3 - 1) >>> 0; | |
| if (this._head === this._tail) | |
| this._grow$0(); | |
| this._modificationCount = this._modificationCount + 1; | |
| }, | |
| _grow$0: function() { | |
| var newTable, t1, t2, split; | |
| newTable = P.List_List(this._table.length * 2, H.getRuntimeTypeArgument(this, "ListQueue", 0)); | |
| H.setRuntimeTypeInfo(newTable, [H.getRuntimeTypeArgument(this, "ListQueue", 0)]); | |
| t1 = this._table; | |
| t2 = this._head; | |
| split = t1.length - t2; | |
| H.IterableMixinWorkaround_setRangeList(newTable, 0, split, t1, t2); | |
| t1 = this._head; | |
| t2 = this._table; | |
| H.IterableMixinWorkaround_setRangeList(newTable, split, split + t1, t2, 0); | |
| this._head = 0; | |
| this._tail = this._table.length; | |
| this._table = newTable; | |
| }, | |
| ListQueue$1: function(initialCapacity, $E) { | |
| var t1 = P.List_List(8, $E); | |
| H.setRuntimeTypeInfo(t1, [$E]); | |
| this._table = t1; | |
| }, | |
| $asIterableBase: null, | |
| $isEfficientLength: true, | |
| static: { | |
| "": "ListQueue__INITIAL_CAPACITY", | |
| ListQueue$: function(initialCapacity, $E) { | |
| var t1 = new P.ListQueue(null, 0, 0, 0); | |
| H.setRuntimeTypeInfo(t1, [$E]); | |
| t1.ListQueue$1(initialCapacity, $E); | |
| return t1; | |
| }} | |
| }, | |
| _ListQueueIterator: {"": "Object;_queue,_end,_modificationCount,_collection$_position,_collection$_current", | |
| get$current: function() { | |
| return this._collection$_current; | |
| }, | |
| moveNext$0: function() { | |
| var t1, t2, t3; | |
| t1 = this._queue; | |
| if (this._modificationCount !== t1._modificationCount) | |
| H.throwExpression(P.ConcurrentModificationError$(t1)); | |
| t2 = this._collection$_position; | |
| if (t2 === this._end) { | |
| this._collection$_current = null; | |
| return false; | |
| } | |
| t3 = t1._table; | |
| if (t2 < 0 || t2 >= t3.length) | |
| throw H.ioore(t3, t2); | |
| this._collection$_current = t3[t2]; | |
| this._collection$_position = (this._collection$_position + 1 & t1._table.length - 1) >>> 0; | |
| return true; | |
| }, | |
| static: { | |
| _ListQueueIterator$: function(queue) { | |
| return new P._ListQueueIterator(queue, queue._tail, queue._modificationCount, queue._head, null); | |
| }} | |
| }}], | |
| ["dart.core", "dart:core", , P, { | |
| _symbolToString: function(symbol) { | |
| return H.Symbol_getName(symbol); | |
| }, | |
| Error_safeToString: function(object) { | |
| var buffer, t1, i, codeUnit, t2, charCodes; | |
| if (typeof object === "number" || typeof object === "boolean" || null == object) | |
| return J.toString$0(object); | |
| if (typeof object === "string") { | |
| buffer = new P.StringBuffer(""); | |
| buffer._contents = "\""; | |
| for (t1 = object.length, i = 0; i < t1; ++i) { | |
| codeUnit = C.JSString_methods.codeUnitAt$1(object, i); | |
| if (codeUnit <= 31) | |
| if (codeUnit === 10) | |
| buffer._contents = buffer._contents + "\\n"; | |
| else if (codeUnit === 13) | |
| buffer._contents = buffer._contents + "\\r"; | |
| else if (codeUnit === 9) | |
| buffer._contents = buffer._contents + "\\t"; | |
| else { | |
| buffer._contents = buffer._contents + "\\x"; | |
| if (codeUnit < 16) | |
| buffer._contents = buffer._contents + "0"; | |
| else { | |
| buffer._contents = buffer._contents + "1"; | |
| codeUnit -= 16; | |
| } | |
| t2 = codeUnit < 10 ? 48 + codeUnit : 87 + codeUnit; | |
| charCodes = P.List_List$filled(1, t2, J.JSInt); | |
| charCodes.$builtinTypeInfo = [J.JSInt]; | |
| t2 = H.Primitives_stringFromCharCodes(charCodes); | |
| buffer._contents = buffer._contents + t2; | |
| } | |
| else if (codeUnit === 92) | |
| buffer._contents = buffer._contents + "\\\\"; | |
| else if (codeUnit === 34) | |
| buffer._contents = buffer._contents + "\\\""; | |
| else { | |
| charCodes = P.List_List$filled(1, codeUnit, J.JSInt); | |
| charCodes.$builtinTypeInfo = [J.JSInt]; | |
| t2 = H.Primitives_stringFromCharCodes(charCodes); | |
| buffer._contents = buffer._contents + t2; | |
| } | |
| } | |
| buffer._contents = buffer._contents + "\""; | |
| return buffer._contents; | |
| } | |
| return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
| }, | |
| Exception_Exception: function(message) { | |
| return new P._ExceptionImplementation(message); | |
| }, | |
| identical: function(a, b) { | |
| return a == null ? b == null : a === b; | |
| }, | |
| identityHashCode: function(object) { | |
| return H.objectHashCode(object); | |
| }, | |
| List_List: function($length, $E) { | |
| if ($length == null) | |
| return new Array(0); | |
| if (typeof $length !== "number" || Math.floor($length) !== $length || $length < 0) | |
| throw H.wrapException(P.ArgumentError$("Length must be a positive integer: " + H.S($length) + ".")); | |
| return H.Primitives_newFixedList($length); | |
| }, | |
| List_List$filled: function($length, fill, $E) { | |
| var result, t1, i; | |
| if ($length < 0) | |
| throw H.wrapException(P.ArgumentError$("Length must be a positive integer: " + $length + ".")); | |
| result = H.Primitives_newFixedList($length); | |
| if ($length !== 0 && true) | |
| for (t1 = result.length, i = 0; i < t1; ++i) | |
| result[i] = fill; | |
| return result; | |
| }, | |
| List_List$from: function(other, growable, $E) { | |
| var list, t1, $length, fixedList, i; | |
| list = P.List_List(null, $E); | |
| H.setRuntimeTypeInfo(list, [$E]); | |
| for (t1 = J.get$iterator$ax(other); t1.moveNext$0();) | |
| list.push(t1.get$current()); | |
| if (growable) | |
| return list; | |
| $length = list.length; | |
| fixedList = P.List_List($length, $E); | |
| H.setRuntimeTypeInfo(fixedList, [$E]); | |
| for (t1 = list.length, i = 0; i < $length; ++i) { | |
| if (i >= t1) | |
| throw H.ioore(list, i); | |
| fixedList[i] = list[i]; | |
| } | |
| return fixedList; | |
| }, | |
| print: function(object) { | |
| var line = J.toString$0(object); | |
| H.printToConsole(line); | |
| }, | |
| NoSuchMethodError_toString_closure: {"": "Closure;box_0", | |
| call$2: function(key, value) { | |
| var t1 = this.box_0; | |
| if (t1.i_1 > 0) | |
| t1.sb_0.write$1(", "); | |
| t1.sb_0.write$1(P._symbolToString(key)); | |
| }, | |
| $is_args2: true | |
| }, | |
| Duration: {"": "Object;_duration", | |
| $lt: function(_, other) { | |
| return C.JSNumber_methods.$lt(this._duration, other.get$_duration()); | |
| }, | |
| $gt: function(_, other) { | |
| return C.JSNumber_methods.$gt(this._duration, other.get$_duration()); | |
| }, | |
| $ge: function(_, other) { | |
| return C.JSNumber_methods.$ge(this._duration, other.get$_duration()); | |
| }, | |
| $eq: function(_, other) { | |
| var t1; | |
| if (other == null) | |
| return false; | |
| t1 = J.getInterceptor(other); | |
| if (typeof other !== "object" || other === null || !t1.$isDuration) | |
| return false; | |
| return this._duration === other._duration; | |
| }, | |
| get$hashCode: function(_) { | |
| return this._duration & 0x1FFFFFFF; | |
| }, | |
| toString$0: function(_) { | |
| var t1, t2, twoDigitMinutes, twoDigitSeconds, sixDigitUs; | |
| t1 = new P.Duration_toString_twoDigits(); | |
| t2 = this._duration; | |
| if (t2 < 0) | |
| return "-" + H.S(P.Duration$(0, 0, -t2, 0, 0, 0)); | |
| twoDigitMinutes = t1.call$1(C.JSNumber_methods.remainder$1(C.JSNumber_methods.$tdiv(t2, 60000000), 60)); | |
| twoDigitSeconds = t1.call$1(C.JSNumber_methods.remainder$1(C.JSNumber_methods.$tdiv(t2, 1000000), 60)); | |
| sixDigitUs = new P.Duration_toString_sixDigits().call$1(C.JSNumber_methods.remainder$1(t2, 1000000)); | |
| return H.S(C.JSNumber_methods.$tdiv(t2, 3600000000)) + ":" + H.S(twoDigitMinutes) + ":" + H.S(twoDigitSeconds) + "." + H.S(sixDigitUs); | |
| }, | |
| $isDuration: true, | |
| static: { | |
| "": "Duration_MICROSECONDS_PER_MILLISECOND,Duration_MILLISECONDS_PER_SECOND,Duration_SECONDS_PER_MINUTE,Duration_MINUTES_PER_HOUR,Duration_HOURS_PER_DAY,Duration_MICROSECONDS_PER_SECOND,Duration_MICROSECONDS_PER_MINUTE,Duration_MICROSECONDS_PER_HOUR,Duration_MICROSECONDS_PER_DAY,Duration_MILLISECONDS_PER_MINUTE,Duration_MILLISECONDS_PER_HOUR,Duration_MILLISECONDS_PER_DAY,Duration_SECONDS_PER_HOUR,Duration_SECONDS_PER_DAY,Duration_MINUTES_PER_DAY,Duration_ZERO", | |
| Duration$: function(days, hours, microseconds, milliseconds, minutes, seconds) { | |
| return new P.Duration(days * 86400000000 + hours * 3600000000 + minutes * 60000000 + seconds * 1000000 + milliseconds * 1000 + microseconds); | |
| }} | |
| }, | |
| Duration_toString_sixDigits: {"": "Closure;", | |
| call$1: function(n) { | |
| var t1 = J.getInterceptor$n(n); | |
| if (t1.$ge(n, 100000)) | |
| return H.S(n); | |
| if (t1.$ge(n, 10000)) | |
| return "0" + H.S(n); | |
| if (t1.$ge(n, 1000)) | |
| return "00" + H.S(n); | |
| if (t1.$ge(n, 100)) | |
| return "000" + H.S(n); | |
| if (t1.$gt(n, 10)) | |
| return "0000" + H.S(n); | |
| return "00000" + H.S(n); | |
| }, | |
| $is_args1: true | |
| }, | |
| Duration_toString_twoDigits: {"": "Closure;", | |
| call$1: function(n) { | |
| if (J.$ge$n(n, 10)) | |
| return H.S(n); | |
| return "0" + H.S(n); | |
| }, | |
| $is_args1: true | |
| }, | |
| Error: {"": "Object;", | |
| get$stackTrace: function() { | |
| return new H._StackTrace(this.$thrownJsError, null); | |
| }, | |
| $isError: true | |
| }, | |
| NullThrownError: {"": "Error;", | |
| toString$0: function(_) { | |
| return "Throw of null."; | |
| } | |
| }, | |
| ArgumentError: {"": "Error;message", | |
| toString$0: function(_) { | |
| var t1 = this.message; | |
| if (t1 != null) | |
| return "Illegal argument(s): " + H.S(t1); | |
| return "Illegal argument(s)"; | |
| }, | |
| static: { | |
| ArgumentError$: function(message) { | |
| return new P.ArgumentError(message); | |
| }} | |
| }, | |
| RangeError: {"": "ArgumentError;message", | |
| toString$0: function(_) { | |
| return "RangeError: " + H.S(this.message); | |
| }, | |
| static: { | |
| RangeError$value: function(value) { | |
| return new P.RangeError("value " + H.S(value)); | |
| }, | |
| RangeError$range: function(value, start, end) { | |
| return new P.RangeError("value " + H.S(value) + " not in range " + start + ".." + H.S(end)); | |
| }} | |
| }, | |
| UnsupportedError: {"": "Error;message", | |
| toString$0: function(_) { | |
| return "Unsupported operation: " + this.message; | |
| }, | |
| static: { | |
| UnsupportedError$: function(message) { | |
| return new P.UnsupportedError(message); | |
| }} | |
| }, | |
| UnimplementedError: {"": "Error;message", | |
| toString$0: function(_) { | |
| var t1 = this.message; | |
| return t1 != null ? "UnimplementedError: " + H.S(t1) : "UnimplementedError"; | |
| }, | |
| $isError: true, | |
| static: { | |
| UnimplementedError$: function(message) { | |
| return new P.UnimplementedError(message); | |
| }} | |
| }, | |
| StateError: {"": "Error;message", | |
| toString$0: function(_) { | |
| return "Bad state: " + this.message; | |
| }, | |
| static: { | |
| StateError$: function(message) { | |
| return new P.StateError(message); | |
| }} | |
| }, | |
| ConcurrentModificationError: {"": "Error;modifiedObject", | |
| toString$0: function(_) { | |
| var t1 = this.modifiedObject; | |
| if (t1 == null) | |
| return "Concurrent modification during iteration."; | |
| return "Concurrent modification during iteration: " + H.S(P.Error_safeToString(t1)) + "."; | |
| }, | |
| static: { | |
| ConcurrentModificationError$: function(modifiedObject) { | |
| return new P.ConcurrentModificationError(modifiedObject); | |
| }} | |
| }, | |
| StackOverflowError: {"": "Object;", | |
| toString$0: function(_) { | |
| return "Stack Overflow"; | |
| }, | |
| get$stackTrace: function() { | |
| return; | |
| }, | |
| $isError: true | |
| }, | |
| CyclicInitializationError: {"": "Error;variableName", | |
| toString$0: function(_) { | |
| return "Reading static variable '" + this.variableName + "' during its initialization"; | |
| }, | |
| static: { | |
| CyclicInitializationError$: function(variableName) { | |
| return new P.CyclicInitializationError(variableName); | |
| }} | |
| }, | |
| _ExceptionImplementation: {"": "Object;message", | |
| toString$0: function(_) { | |
| var t1 = this.message; | |
| if (t1 == null) | |
| return "Exception"; | |
| return "Exception: " + H.S(t1); | |
| } | |
| }, | |
| Expando: {"": "Object;name", | |
| toString$0: function(_) { | |
| return "Expando:" + H.S(this.name); | |
| }, | |
| $index: function(_, object) { | |
| var values = H.Primitives_getProperty(object, "expando$values"); | |
| return values == null ? null : H.Primitives_getProperty(values, this._getKey$0()); | |
| }, | |
| $indexSet: function(_, object, value) { | |
| var values = H.Primitives_getProperty(object, "expando$values"); | |
| if (values == null) { | |
| values = new P.Object(); | |
| H.Primitives_setProperty(object, "expando$values", values); | |
| } | |
| H.Primitives_setProperty(values, this._getKey$0(), value); | |
| }, | |
| _getKey$0: function() { | |
| var key, t1; | |
| key = H.Primitives_getProperty(this, "expando$key"); | |
| if (key == null) { | |
| t1 = $.Expando__keyCount; | |
| $.Expando__keyCount = t1 + 1; | |
| key = "expando$key$" + t1; | |
| H.Primitives_setProperty(this, "expando$key", key); | |
| } | |
| return key; | |
| }, | |
| static: { | |
| "": "Expando__KEY_PROPERTY_NAME,Expando__EXPANDO_PROPERTY_NAME,Expando__keyCount", | |
| } | |
| }, | |
| Function: {"": "Object;"}, | |
| Iterator: {"": "Object;"}, | |
| Null: {"": "Object;", | |
| toString$0: function(_) { | |
| return "null"; | |
| } | |
| }, | |
| Object: {"": ";", | |
| $eq: function(_, other) { | |
| return this === other; | |
| }, | |
| get$hashCode: function(_) { | |
| return H.Primitives_objectHashCode(this); | |
| }, | |
| toString$0: function(_) { | |
| return H.Primitives_objectToString(this); | |
| } | |
| }, | |
| StackTrace: {"": "Object;"}, | |
| StringBuffer: {"": "Object;_contents<", | |
| get$length: function(_) { | |
| return this._contents.length; | |
| }, | |
| write$1: function(obj) { | |
| var str = typeof obj === "string" ? obj : H.S(obj); | |
| this._contents = this._contents + str; | |
| }, | |
| writeAll$2: function(objects, separator) { | |
| var iterator, str; | |
| iterator = J.get$iterator$ax(objects); | |
| if (!iterator.moveNext$0()) | |
| return; | |
| if (separator.length === 0) | |
| do { | |
| str = iterator.get$current(); | |
| str = typeof str === "string" ? str : H.S(str); | |
| this._contents = this._contents + str; | |
| } while (iterator.moveNext$0()); | |
| else { | |
| this.write$1(iterator.get$current()); | |
| for (; iterator.moveNext$0();) { | |
| this._contents = this._contents + separator; | |
| str = iterator.get$current(); | |
| str = typeof str === "string" ? str : H.S(str); | |
| this._contents = this._contents + str; | |
| } | |
| } | |
| }, | |
| toString$0: function(_) { | |
| return this._contents; | |
| }, | |
| StringBuffer$1: function($content) { | |
| this._contents = $content; | |
| }, | |
| static: { | |
| StringBuffer$: function($content) { | |
| var t1 = new P.StringBuffer(""); | |
| t1.StringBuffer$1($content); | |
| return t1; | |
| }} | |
| }, | |
| Symbol: {"": "Object;"}}], | |
| ["dart.dom.html", "dart:html", , W, { | |
| _wrapZone: function(callback) { | |
| var t1 = $.Zone__current; | |
| if (t1 === C.C__RootZone) | |
| return callback; | |
| return t1.bindUnaryCallback$2$runGuarded(callback, true); | |
| }, | |
| HtmlElement: {"": "Element;", "%": "HTMLAppletElement|HTMLAreaElement|HTMLBRElement|HTMLBaseElement|HTMLBaseFontElement|HTMLBodyElement|HTMLCanvasElement|HTMLContentElement|HTMLDListElement|HTMLDataListElement|HTMLDetailsElement|HTMLDialogElement|HTMLDirectoryElement|HTMLDivElement|HTMLFontElement|HTMLFrameElement|HTMLFrameSetElement|HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLImageElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMarqueeElement|HTMLMenuElement|HTMLModElement|HTMLOListElement|HTMLOptGroupElement|HTMLParagraphElement|HTMLPreElement|HTMLQuoteElement|HTMLScriptElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement|HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement|HTMLTableRowElement|HTMLTableSectionElement|HTMLTemplateElement|HTMLTitleElement|HTMLTrackElement|HTMLUListElement|HTMLUnknownElement;HTMLElement"}, | |
| AnchorElement: {"": "HtmlElement;", | |
| toString$0: function(receiver) { | |
| return receiver.toString(); | |
| }, | |
| "%": "HTMLAnchorElement" | |
| }, | |
| ButtonElement: {"": "HtmlElement;name=,value=", "%": "HTMLButtonElement"}, | |
| CharacterData: {"": "Node;length=", "%": "CDATASection|CharacterData|Comment|ProcessingInstruction|Text"}, | |
| Document: {"": "Node;", | |
| get$onInput: function(receiver) { | |
| var t1 = new W._EventStream(receiver, C.EventStreamProvider_input._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| get$onKeyUp: function(receiver) { | |
| var t1 = new W._EventStream(receiver, C.EventStreamProvider_keyup._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| "%": "Document|HTMLDocument|SVGDocument" | |
| }, | |
| DomException: {"": "Interceptor;", | |
| toString$0: function(receiver) { | |
| return receiver.toString(); | |
| }, | |
| "%": "DOMException" | |
| }, | |
| Element: {"": "Node;className%", | |
| get$classes: function(receiver) { | |
| return new W._ElementCssClassSet(receiver); | |
| }, | |
| toString$0: function(receiver) { | |
| return receiver.localName; | |
| }, | |
| get$onInput: function(receiver) { | |
| var t1 = new W._ElementEventStreamImpl(receiver, C.EventStreamProvider_input._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| get$onKeyUp: function(receiver) { | |
| var t1 = new W._ElementEventStreamImpl(receiver, C.EventStreamProvider_keyup._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| $isElement: true, | |
| "%": ";Element" | |
| }, | |
| EmbedElement: {"": "HtmlElement;name=", "%": "HTMLEmbedElement"}, | |
| ErrorEvent: {"": "Event;error=", "%": "ErrorEvent"}, | |
| Event: {"": "Interceptor;", "%": "AudioProcessingEvent|AutocompleteErrorEvent|BeforeLoadEvent|BeforeUnloadEvent|CSSFontFaceLoadEvent|CloseEvent|CustomEvent|DeviceMotionEvent|DeviceOrientationEvent|HashChangeEvent|IDBVersionChangeEvent|MIDIConnectionEvent|MIDIMessageEvent|MediaKeyEvent|MediaKeyMessageEvent|MediaKeyNeededEvent|MediaStreamEvent|MediaStreamTrackEvent|MessageEvent|MutationEvent|OfflineAudioCompletionEvent|OverflowEvent|PageTransitionEvent|PopStateEvent|ProgressEvent|RTCDTMFToneChangeEvent|RTCDataChannelEvent|RTCIceCandidateEvent|ResourceProgressEvent|SecurityPolicyViolationEvent|SpeechInputEvent|SpeechRecognitionEvent|SpeechSynthesisEvent|StorageEvent|TrackEvent|TransitionEvent|WebGLContextEvent|WebKitAnimationEvent|WebKitTransitionEvent|XMLHttpRequestProgressEvent;Event"}, | |
| EventTarget: {"": "Interceptor;", | |
| addEventListener$3: function(receiver, type, listener, useCapture) { | |
| return receiver.addEventListener(type, H.convertDartClosureToJS(listener, 1), useCapture); | |
| }, | |
| removeEventListener$3: function(receiver, type, listener, useCapture) { | |
| return receiver.removeEventListener(type, H.convertDartClosureToJS(listener, 1), useCapture); | |
| }, | |
| "%": "MediaStream;EventTarget" | |
| }, | |
| FieldSetElement: {"": "HtmlElement;name=", "%": "HTMLFieldSetElement"}, | |
| FormElement: {"": "HtmlElement;length=,name=", "%": "HTMLFormElement"}, | |
| IFrameElement: {"": "HtmlElement;name=", "%": "HTMLIFrameElement"}, | |
| InputElement: {"": "HtmlElement;name=,value=", $isElement: true, "%": "HTMLInputElement"}, | |
| KeyboardEvent: {"": "UIEvent;", "%": "KeyboardEvent"}, | |
| KeygenElement: {"": "HtmlElement;name=", "%": "HTMLKeygenElement"}, | |
| LIElement: {"": "HtmlElement;value=", "%": "HTMLLIElement"}, | |
| MapElement: {"": "HtmlElement;name=", "%": "HTMLMapElement"}, | |
| MediaElement: {"": "HtmlElement;error=", "%": "HTMLAudioElement|HTMLMediaElement|HTMLVideoElement"}, | |
| MetaElement: {"": "HtmlElement;name=", "%": "HTMLMetaElement"}, | |
| MeterElement: {"": "HtmlElement;value=", "%": "HTMLMeterElement"}, | |
| Node: {"": "EventTarget;", | |
| toString$0: function(receiver) { | |
| var t1 = receiver.nodeValue; | |
| return t1 == null ? J.Interceptor.prototype.toString$0.call(this, receiver) : t1; | |
| }, | |
| "%": "DocumentFragment|DocumentType|Entity|Notation|ShadowRoot;Node" | |
| }, | |
| NodeList: {"": "Interceptor_ListMixin_ImmutableListMixin;", | |
| get$length: function(receiver) { | |
| return receiver.length; | |
| }, | |
| $index: function(receiver, index) { | |
| var t1 = receiver.length; | |
| if (index >>> 0 !== index || index >= t1) | |
| throw H.wrapException(P.RangeError$range(index, 0, t1)); | |
| return receiver[index]; | |
| }, | |
| $indexSet: function(receiver, index, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot assign element of immutable List.")); | |
| }, | |
| set$length: function(receiver, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot resize immutable List.")); | |
| }, | |
| elementAt$1: function(receiver, index) { | |
| if (index < 0 || index >= receiver.length) | |
| throw H.ioore(receiver, index); | |
| return receiver[index]; | |
| }, | |
| $asList: function() { | |
| return [W.Node]; | |
| }, | |
| $isList: true, | |
| $isEfficientLength: true, | |
| $isJavaScriptIndexingBehavior: true, | |
| "%": "NodeList|RadioNodeList" | |
| }, | |
| ObjectElement: {"": "HtmlElement;name=", "%": "HTMLObjectElement"}, | |
| OptionElement: {"": "HtmlElement;value=", "%": "HTMLOptionElement"}, | |
| OutputElement: {"": "HtmlElement;name=,value=", "%": "HTMLOutputElement"}, | |
| ParamElement: {"": "HtmlElement;name=,value=", "%": "HTMLParamElement"}, | |
| ProgressElement: {"": "HtmlElement;value=", "%": "HTMLProgressElement"}, | |
| SelectElement: {"": "HtmlElement;length=,name=,value=", "%": "HTMLSelectElement"}, | |
| SpeechRecognitionError: {"": "Event;error=", "%": "SpeechRecognitionError"}, | |
| TextAreaElement: {"": "HtmlElement;name=,value=", "%": "HTMLTextAreaElement"}, | |
| UIEvent: {"": "Event;", "%": "CompositionEvent|DragEvent|FocusEvent|MSPointerEvent|MouseEvent|MouseScrollEvent|MouseWheelEvent|PointerEvent|SVGZoomEvent|TextEvent|TouchEvent|WheelEvent;UIEvent"}, | |
| Window: {"": "EventTarget;", | |
| toString$0: function(receiver) { | |
| return receiver.toString(); | |
| }, | |
| get$onInput: function(receiver) { | |
| var t1 = new W._EventStream(receiver, C.EventStreamProvider_input._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| get$onKeyUp: function(receiver) { | |
| var t1 = new W._EventStream(receiver, C.EventStreamProvider_keyup._eventType, false); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| "%": "DOMWindow|Window" | |
| }, | |
| _Attr: {"": "Node;name=,value=", "%": "Attr"}, | |
| _NamedNodeMap: {"": "Interceptor_ListMixin_ImmutableListMixin0;", | |
| get$length: function(receiver) { | |
| return receiver.length; | |
| }, | |
| $index: function(receiver, index) { | |
| var t1 = receiver.length; | |
| if (index >>> 0 !== index || index >= t1) | |
| throw H.wrapException(P.RangeError$range(index, 0, t1)); | |
| return receiver[index]; | |
| }, | |
| $indexSet: function(receiver, index, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot assign element of immutable List.")); | |
| }, | |
| set$length: function(receiver, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot resize immutable List.")); | |
| }, | |
| elementAt$1: function(receiver, index) { | |
| if (index < 0 || index >= receiver.length) | |
| throw H.ioore(receiver, index); | |
| return receiver[index]; | |
| }, | |
| $asList: function() { | |
| return [W.Node]; | |
| }, | |
| $isList: true, | |
| $isEfficientLength: true, | |
| $isJavaScriptIndexingBehavior: true, | |
| "%": "MozNamedAttrMap|NamedNodeMap" | |
| }, | |
| _FrozenElementList: {"": "ListBase;_nodeList,_elementList", | |
| get$length: function(_) { | |
| return this._nodeList.length; | |
| }, | |
| $index: function(_, index) { | |
| var t1 = this._nodeList; | |
| if (index >>> 0 !== index || index >= t1.length) | |
| throw H.ioore(t1, index); | |
| return t1[index]; | |
| }, | |
| $indexSet: function(_, index, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot modify list")); | |
| }, | |
| set$length: function(_, newLength) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot modify list")); | |
| }, | |
| get$classes: function(_) { | |
| return W._MultiElementCssClassSet$(this._elementList); | |
| }, | |
| get$onInput: function(_) { | |
| var t1 = new W._ElementListEventStreamImpl(this, false, C.EventStreamProvider_input._eventType); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| get$onKeyUp: function(_) { | |
| var t1 = new W._ElementListEventStreamImpl(this, false, C.EventStreamProvider_keyup._eventType); | |
| H.setRuntimeTypeInfo(t1, [null]); | |
| return t1; | |
| }, | |
| _html$_FrozenElementList$_wrap$1: function(_nodeList, $T) { | |
| var t1 = C.NodeList_methods.where$1(this._nodeList, new W._FrozenElementList$_wrap_closure()); | |
| this._elementList = P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "IterableBase", 0)); | |
| }, | |
| $asListBase: null, | |
| $asList: null, | |
| $isList: true, | |
| $isEfficientLength: true, | |
| static: { | |
| _FrozenElementList$_wrap: function(_nodeList, $T) { | |
| var t1 = new W._FrozenElementList(_nodeList, null); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| t1._html$_FrozenElementList$_wrap$1(_nodeList, $T); | |
| return t1; | |
| }} | |
| }, | |
| _FrozenElementList$_wrap_closure: {"": "Closure;", | |
| call$1: function(e) { | |
| var t1 = J.getInterceptor(e); | |
| return typeof e === "object" && e !== null && !!t1.$isElement; | |
| }, | |
| $is_args1: true | |
| }, | |
| Interceptor_ListMixin: {"": "Interceptor+ListMixin;", $isList: true, $asList: null, $isEfficientLength: true}, | |
| Interceptor_ListMixin_ImmutableListMixin: {"": "Interceptor_ListMixin+ImmutableListMixin;", $asList: null, $isList: true, $isEfficientLength: true}, | |
| Interceptor_ListMixin0: {"": "Interceptor+ListMixin;", $isList: true, $asList: null, $isEfficientLength: true}, | |
| Interceptor_ListMixin_ImmutableListMixin0: {"": "Interceptor_ListMixin0+ImmutableListMixin;", $asList: null, $isList: true, $isEfficientLength: true}, | |
| _AttributeMap: {"": "Object;", | |
| forEach$1: function(_, f) { | |
| var t1, key; | |
| for (t1 = this.get$keys(), t1 = new H.ListIterator(t1, t1.length, 0, null); t1.moveNext$0();) { | |
| key = t1._dev$_current; | |
| f.call$2(key, this.$index(this, key)); | |
| } | |
| }, | |
| get$keys: function() { | |
| var attributes, keys, len, i, t1; | |
| attributes = this._element.attributes; | |
| keys = P.List_List(null, J.JSString); | |
| H.setRuntimeTypeInfo(keys, [J.JSString]); | |
| for (len = attributes.length, i = 0; i < len; ++i) { | |
| if (i >= attributes.length) | |
| throw H.ioore(attributes, i); | |
| t1 = attributes[i]; | |
| if (this._matches$1(t1)) | |
| keys.push(J.get$name$x(t1)); | |
| } | |
| return keys; | |
| }, | |
| get$values: function(_) { | |
| var attributes, values, len, i, t1; | |
| attributes = this._element.attributes; | |
| values = P.List_List(null, J.JSString); | |
| H.setRuntimeTypeInfo(values, [J.JSString]); | |
| for (len = attributes.length, i = 0; i < len; ++i) { | |
| if (i >= attributes.length) | |
| throw H.ioore(attributes, i); | |
| t1 = attributes[i]; | |
| if (this._matches$1(t1)) | |
| values.push(J.get$value$x(t1)); | |
| } | |
| return values; | |
| }, | |
| $isMap: true, | |
| $asMap: function() { | |
| return [J.JSString, J.JSString]; | |
| } | |
| }, | |
| _ElementAttributeMap: {"": "_AttributeMap;_element", | |
| $index: function(_, key) { | |
| return this._element.getAttribute(key); | |
| }, | |
| $indexSet: function(_, key, value) { | |
| this._element.setAttribute(key, value); | |
| }, | |
| get$length: function(_) { | |
| return this.get$keys().length; | |
| }, | |
| _matches$1: function(node) { | |
| return node.namespaceURI == null; | |
| } | |
| }, | |
| _MultiElementCssClassSet: {"": "CssClassSetImpl;_elementIterable,_elementCssClassSetIterable", | |
| readClasses$0: function() { | |
| var s, t1; | |
| s = P.LinkedHashSet_LinkedHashSet(null, null, null, J.JSString); | |
| t1 = this._elementCssClassSetIterable; | |
| t1.forEach$1(t1, new W._MultiElementCssClassSet_readClasses_closure(s)); | |
| return s; | |
| }, | |
| writeClasses$1: function(s) { | |
| var classes, t1; | |
| classes = C.JSArray_methods.join$1(P.List_List$from(s, true, null), " "); | |
| for (t1 = this._elementIterable, t1 = new H.ListIterator(t1, t1.length, 0, null); t1.moveNext$0();) | |
| J.set$className$x(t1._dev$_current, classes); | |
| }, | |
| modify$1: function(f) { | |
| var t1 = this._elementCssClassSetIterable; | |
| t1.forEach$1(t1, new W._MultiElementCssClassSet_modify_closure(f)); | |
| }, | |
| toggle$2: function(value, shouldAdd) { | |
| return this._modifyWithReturnValue$1(new W._MultiElementCssClassSet_toggle_closure(value, shouldAdd)); | |
| }, | |
| _modifyWithReturnValue$1: function(f) { | |
| var t1 = this._elementCssClassSetIterable; | |
| return t1.fold$2(t1, false, new W._MultiElementCssClassSet__modifyWithReturnValue_closure(f)); | |
| }, | |
| _MultiElementCssClassSet$1: function(_elementIterable) { | |
| var t1 = new H.MappedListIterable(P.List_List$from(this._elementIterable, true, null), new W._MultiElementCssClassSet_closure()); | |
| H.setRuntimeTypeInfo(t1, [null, null]); | |
| this._elementCssClassSetIterable = t1; | |
| }, | |
| static: { | |
| _MultiElementCssClassSet$: function(_elementIterable) { | |
| var t1 = new W._MultiElementCssClassSet(_elementIterable, null); | |
| t1._MultiElementCssClassSet$1(_elementIterable); | |
| return t1; | |
| }} | |
| }, | |
| _MultiElementCssClassSet_closure: {"": "Closure;", | |
| call$1: function(e) { | |
| return new W._ElementCssClassSet(e); | |
| }, | |
| $is_args1: true | |
| }, | |
| _MultiElementCssClassSet_readClasses_closure: {"": "Closure;s_0", | |
| call$1: function(e) { | |
| var t1 = this.s_0; | |
| return t1.addAll$1(t1, e.readClasses$0()); | |
| }, | |
| $is_args1: true | |
| }, | |
| _MultiElementCssClassSet_modify_closure: {"": "Closure;f_0", | |
| call$1: function(e) { | |
| return e.modify$1(this.f_0); | |
| }, | |
| $is_args1: true | |
| }, | |
| _MultiElementCssClassSet_toggle_closure: {"": "Closure;value_0,shouldAdd_1", | |
| call$1: function(e) { | |
| return e.toggle$2(this.value_0, this.shouldAdd_1); | |
| }, | |
| $is_args1: true | |
| }, | |
| _MultiElementCssClassSet__modifyWithReturnValue_closure: {"": "Closure;f_0", | |
| call$2: function(prevValue, element) { | |
| return this.f_0.call$1(element) === true || prevValue === true; | |
| }, | |
| $is_args2: true | |
| }, | |
| _ElementCssClassSet: {"": "CssClassSetImpl;_element", | |
| readClasses$0: function() { | |
| var s, t1, trimmed; | |
| s = P.LinkedHashSet_LinkedHashSet(null, null, null, J.JSString); | |
| for (t1 = J.get$className$x(this._element).split(" "), t1 = new H.ListIterator(t1, t1.length, 0, null); t1.moveNext$0();) { | |
| trimmed = J.trim$0$s(t1._dev$_current); | |
| if (trimmed.length !== 0) | |
| s.add$1(s, trimmed); | |
| } | |
| return s; | |
| }, | |
| writeClasses$1: function(s) { | |
| P.List_List$from(s, true, null); | |
| J.set$className$x(this._element, s.join$1(s, " ")); | |
| } | |
| }, | |
| EventStreamProvider: {"": "Object;_eventType"}, | |
| _EventStream: {"": "Stream;_html$_target,_eventType,_useCapture", | |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { | |
| var t1 = new W._EventStreamSubscription(0, this._html$_target, this._eventType, W._wrapZone(onData), this._useCapture); | |
| H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_EventStream", 0)]); | |
| t1._tryResume$0(); | |
| return t1; | |
| }, | |
| listen$1: function(onData) { | |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); | |
| }, | |
| listen$3$onDone$onError: function(onData, onDone, onError) { | |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); | |
| }, | |
| $asStream: null | |
| }, | |
| _ElementEventStreamImpl: {"": "_EventStream;_html$_target,_eventType,_useCapture", $as_EventStream: null}, | |
| _ElementListEventStreamImpl: {"": "Stream;_targetList,_useCapture,_eventType", | |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { | |
| var pool, t1, t2, t3, t4; | |
| pool = W._StreamPool$broadcast(null); | |
| for (t1 = this._targetList, t1 = t1.get$iterator(t1), t2 = this._eventType, t3 = this._useCapture; t1.moveNext$0();) { | |
| t4 = new W._EventStream(t1._dev$_current, t2, t3); | |
| t4.$builtinTypeInfo = [null]; | |
| pool.add$1(pool, t4); | |
| } | |
| t1 = pool._controller; | |
| t1.toString; | |
| t2 = new P._BroadcastStream(t1); | |
| H.setRuntimeTypeInfo(t2, [H.getRuntimeTypeArgument(t1, "_BroadcastStreamController", 0)]); | |
| return t2.listen$4$cancelOnError$onDone$onError(onData, cancelOnError, onDone, onError); | |
| }, | |
| listen$1: function(onData) { | |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); | |
| }, | |
| $asStream: null | |
| }, | |
| _EventStreamSubscription: {"": "StreamSubscription;_pauseCount,_html$_target,_eventType,_onData,_useCapture", | |
| cancel$0: function() { | |
| if (this._html$_target == null) | |
| return; | |
| this._unlisten$0(); | |
| this._html$_target = null; | |
| this._onData = null; | |
| }, | |
| _tryResume$0: function() { | |
| var t1 = this._onData; | |
| if (t1 != null && this._pauseCount <= 0) | |
| J.addEventListener$3$x(this._html$_target, this._eventType, t1, this._useCapture); | |
| }, | |
| _unlisten$0: function() { | |
| var t1 = this._onData; | |
| if (t1 != null) | |
| J.removeEventListener$3$x(this._html$_target, this._eventType, t1, this._useCapture); | |
| }, | |
| $asStreamSubscription: null | |
| }, | |
| _StreamPool: {"": "Object;_controller,_subscriptions", | |
| add$1: function(_, stream) { | |
| var t1, t2; | |
| t1 = this._subscriptions; | |
| if (t1.containsKey$1(stream)) | |
| return; | |
| t2 = this._controller; | |
| t1.$indexSet(t1, stream, stream.listen$3$onDone$onError(t2.get$add(t2), new W._StreamPool_add_closure(this, stream), t2.get$addError())); | |
| }, | |
| remove$1: function(_, stream) { | |
| var t1, subscription; | |
| t1 = this._subscriptions; | |
| subscription = t1.remove$1(t1, stream); | |
| if (subscription != null) | |
| subscription.cancel$0(); | |
| }, | |
| close$0: function(_) { | |
| var t1, t2, t3; | |
| for (t1 = this._subscriptions, t2 = t1.get$values(t1), t3 = t2._iterable, t3 = t3.get$iterator(t3), t3 = new H.MappedIterator(null, t3, t2._f), H.setRuntimeTypeInfo(t3, [H.getRuntimeTypeArgument(t2, "MappedIterable", 0), H.getRuntimeTypeArgument(t2, "MappedIterable", 1)]); t3.moveNext$0();) | |
| t3._dev$_current.cancel$0(); | |
| t1.clear$0(t1); | |
| t1 = this._controller; | |
| t1.close$0(t1); | |
| }, | |
| get$close: function(_receiver) { | |
| return new H.BoundClosure$i0(this, W._StreamPool.prototype.close$0, _receiver, "close$0"); | |
| }, | |
| _html$_StreamPool$broadcast$0: function($T) { | |
| this._controller = P.StreamController_StreamController$broadcast(this.get$close(this), null, true, $T); | |
| }, | |
| static: { | |
| _StreamPool$broadcast: function($T) { | |
| var t1 = new W._StreamPool(null, P.LinkedHashMap_LinkedHashMap(null, null, null, [P.Stream, $T], [P.StreamSubscription, $T])); | |
| H.setRuntimeTypeInfo(t1, [$T]); | |
| t1._html$_StreamPool$broadcast$0($T); | |
| return t1; | |
| }} | |
| }, | |
| _StreamPool_add_closure: {"": "Closure;this_0,stream_1", | |
| call$0: function() { | |
| var t1 = this.this_0; | |
| return t1.remove$1(t1, this.stream_1); | |
| } | |
| }, | |
| ImmutableListMixin: {"": "Object;", | |
| get$iterator: function(receiver) { | |
| return W.FixedSizeListIterator$(receiver); | |
| }, | |
| add$1: function(receiver, value) { | |
| throw H.wrapException(P.UnsupportedError$("Cannot add to immutable List.")); | |
| }, | |
| $isList: true, | |
| $asList: null, | |
| $isEfficientLength: true | |
| }, | |
| FixedSizeListIterator: {"": "Object;_array,_length,_position,_current", | |
| moveNext$0: function() { | |
| var nextPosition, t1; | |
| nextPosition = this._position + 1; | |
| t1 = this._length; | |
| if (nextPosition < t1) { | |
| this._current = J.$index$asx(this._array, nextPosition); | |
| this._position = nextPosition; | |
| return true; | |
| } | |
| this._current = null; | |
| this._position = t1; | |
| return false; | |
| }, | |
| get$current: function() { | |
| return this._current; | |
| }, | |
| static: { | |
| FixedSizeListIterator$: function(array) { | |
| return new W.FixedSizeListIterator(array, J.get$length$asx(array), -1, null); | |
| }} | |
| }}], | |
| ["dart.dom.svg", "dart:svg", , P, { | |
| SvgElement: {"": "Element;", | |
| get$classes: function(receiver) { | |
| if (receiver._cssClassSet == null) | |
| receiver._cssClassSet = new P._AttributeClassSet(receiver); | |
| return receiver._cssClassSet; | |
| }, | |
| "%": "SVGAElement|SVGAltGlyphDefElement|SVGAltGlyphElement|SVGAltGlyphItemElement|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement|SVGAnimateTransformElement|SVGAnimationElement|SVGCircleElement|SVGClipPathElement|SVGComponentTransferFunctionElement|SVGCursorElement|SVGDefsElement|SVGDescElement|SVGElement|SVGEllipseElement|SVGFEBlendElement|SVGFEColorMatrixElement|SVGFEComponentTransferElement|SVGFECompositeElement|SVGFEConvolveMatrixElement|SVGFEDiffuseLightingElement|SVGFEDisplacementMapElement|SVGFEDistantLightElement|SVGFEDropShadowElement|SVGFEFloodElement|SVGFEFuncAElement|SVGFEFuncBElement|SVGFEFuncGElement|SVGFEFuncRElement|SVGFEGaussianBlurElement|SVGFEImageElement|SVGFEMergeElement|SVGFEMergeNodeElement|SVGFEMorphologyElement|SVGFEOffsetElement|SVGFEPointLightElement|SVGFESpecularLightingElement|SVGFESpotLightElement|SVGFETileElement|SVGFETurbulenceElement|SVGFilterElement|SVGFontElement|SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement|SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGlyphRefElement|SVGGradientElement|SVGGraphicsElement|SVGHKernElement|SVGImageElement|SVGLineElement|SVGLinearGradientElement|SVGMPathElement|SVGMarkerElement|SVGMaskElement|SVGMetadataElement|SVGMissingGlyphElement|SVGPathElement|SVGPatternElement|SVGPolygonElement|SVGPolylineElement|SVGRadialGradientElement|SVGRectElement|SVGSVGElement|SVGScriptElement|SVGSetElement|SVGStopElement|SVGStyleElement|SVGSwitchElement|SVGSymbolElement|SVGTSpanElement|SVGTextContentElement|SVGTextElement|SVGTextPathElement|SVGTextPositioningElement|SVGTitleElement|SVGUseElement|SVGVKernElement|SVGViewElement" | |
| }, | |
| _AttributeClassSet: {"": "CssClassSetImpl;_svg$_element", | |
| readClasses$0: function() { | |
| var classname, s, t1, trimmed; | |
| classname = new W._ElementAttributeMap(this._svg$_element)._element.getAttribute("class"); | |
| s = P.LinkedHashSet_LinkedHashSet(null, null, null, J.JSString); | |
| if (classname == null) | |
| return s; | |
| for (t1 = classname.split(" "), t1 = new H.ListIterator(t1, t1.length, 0, null); t1.moveNext$0();) { | |
| trimmed = J.trim$0$s(t1._dev$_current); | |
| if (trimmed.length !== 0) | |
| s.add$1(s, trimmed); | |
| } | |
| return s; | |
| }, | |
| writeClasses$1: function(s) { | |
| new W._ElementAttributeMap(this._svg$_element)._element.setAttribute("class", s.join$1(s, " ")); | |
| } | |
| }}], | |
| ["dart.isolate", "dart:isolate", , P, { | |
| ReceivePort: {"": "Object;"}}], | |
| ["dart.typed_data", "dart:typed_data", , P, { | |
| TypedData: {"": "Interceptor;", | |
| _invalidIndex$2: function(receiver, index, $length) { | |
| var t1 = J.getInterceptor$n(index); | |
| if (t1.$lt(index, 0) || t1.$ge(index, $length)) | |
| throw H.wrapException(P.RangeError$range(index, 0, $length)); | |
| else | |
| throw H.wrapException(P.ArgumentError$("Invalid list index " + H.S(index))); | |
| }, | |
| "%": ";ArrayBufferView;TypedData_ListMixin|TypedData_ListMixin_FixedLengthListMixin" | |
| }, | |
| Uint8List: {"": "TypedData_ListMixin_FixedLengthListMixin;", | |
| get$length: function(receiver) { | |
| return C.JS_CONST_ZYJ(receiver); | |
| }, | |
| $index: function(receiver, index) { | |
| var t1, t2; | |
| t1 = C.JS_CONST_ZYJ(receiver); | |
| if (!(index >>> 0 != index)) { | |
| if (typeof index !== "number") | |
| throw index.$ge(); | |
| t2 = index >= t1; | |
| } else | |
| t2 = true; | |
| if (t2) | |
| this._invalidIndex$2(receiver, index, t1); | |
| return receiver[index]; | |
| }, | |
| $indexSet: function(receiver, index, value) { | |
| var t1 = C.JS_CONST_ZYJ(receiver); | |
| if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| this._invalidIndex$2(receiver, index, t1); | |
| receiver[index] = value; | |
| }, | |
| $asList: function() { | |
| return [J.JSInt]; | |
| }, | |
| $isList: true, | |
| $isEfficientLength: true, | |
| $isJavaScriptIndexingBehavior: true, | |
| "%": ";Uint8Array" | |
| }, | |
| TypedData_ListMixin: {"": "TypedData+ListMixin;", $isList: true, $asList: null, $isEfficientLength: true}, | |
| TypedData_ListMixin_FixedLengthListMixin: {"": "TypedData_ListMixin+FixedLengthListMixin;", $asList: null}}], | |
| ["html_common", "dart:html_common", , P, { | |
| CssClassSetImpl: {"": "Object;", | |
| toString$0: function(_) { | |
| var t1 = this.readClasses$0(); | |
| return t1.join$1(t1, " "); | |
| }, | |
| toggle$2: function(value, shouldAdd) { | |
| var s, result; | |
| s = this.readClasses$0(); | |
| if (shouldAdd) { | |
| s.add$1(s, value); | |
| result = true; | |
| } else { | |
| s.remove$1(s, value); | |
| result = false; | |
| } | |
| this.writeClasses$1(s); | |
| return result; | |
| }, | |
| get$iterator: function(_) { | |
| var t1 = this.readClasses$0(); | |
| t1 = new P.LinkedHashSetIterator(t1, t1._modifications, null, null); | |
| t1._cell = t1._set._first; | |
| return t1; | |
| }, | |
| forEach$1: function(_, f) { | |
| var t1 = this.readClasses$0(); | |
| t1.forEach$1(t1, f); | |
| }, | |
| get$length: function(_) { | |
| return this.readClasses$0()._collection$_length; | |
| }, | |
| lookup$1: function(value) { | |
| var t1 = this.readClasses$0(); | |
| return t1.contains$1(t1, value) ? value : null; | |
| }, | |
| add$1: function(_, value) { | |
| return this.modify$1(new P.CssClassSetImpl_add_closure(value)); | |
| }, | |
| modify$1: function(f) { | |
| var s, ret; | |
| s = this.readClasses$0(); | |
| ret = f.call$1(s); | |
| this.writeClasses$1(s); | |
| return ret; | |
| }, | |
| $isEfficientLength: true | |
| }, | |
| CssClassSetImpl_add_closure: {"": "Closure;value_0", | |
| call$1: function(s) { | |
| return J.add$1$ax(s, this.value_0); | |
| }, | |
| $is_args1: true | |
| }}], | |
| ["", "paravictor.dart", , S, { | |
| main: function() { | |
| var t1 = W._FrozenElementList$_wrap(document.querySelectorAll("input:not([value]),input[value='']"), null); | |
| t1.forEach$1(t1, new S.main_closure()); | |
| t1 = W._FrozenElementList$_wrap(document.querySelectorAll("input"), null); | |
| t1.forEach$1(t1, new S.main_closure0()); | |
| }, | |
| main_closure: {"": "Closure;", | |
| call$1: function(e) { | |
| var t1 = J.get$classes$x(e); | |
| return t1.add$1(t1, "empty"); | |
| }, | |
| $is_args1: true | |
| }, | |
| main_closure0: {"": "Closure;", | |
| call$1: function(e) { | |
| var t1 = J.getInterceptor$x(e); | |
| t1.get$onInput(e).listen$1(new S.main__closure(e)); | |
| t1.get$onKeyUp(e).listen$1(new S.main__closure0(e)); | |
| }, | |
| $is_args1: true | |
| }, | |
| main__closure: {"": "Closure;e_0", | |
| call$1: function(ev) { | |
| var t1, t2; | |
| t1 = this.e_0; | |
| t2 = J.getInterceptor$x(t1); | |
| t2.get$classes(t1).toggle$2("empty", t2.get$value(t1) === ""); | |
| return; | |
| }, | |
| $is_args1: true | |
| }, | |
| main__closure0: {"": "Closure;e_1", | |
| call$1: function(ev) { | |
| var t1, t2; | |
| t1 = this.e_1; | |
| t2 = J.getInterceptor$x(t1); | |
| t2.get$classes(t1).toggle$2("empty", t2.get$value(t1) === ""); | |
| return; | |
| }, | |
| $is_args1: true | |
| }}, | |
| 1], | |
| ]); | |
| Isolate.$finishClasses($$, $, null); | |
| $$ = null; | |
| // Static function getters | |
| init.globalFunctions.IsolateNatives__processWorkerMessage$closure = H.IsolateNatives__processWorkerMessage$closure = new H.Closure$2(H.IsolateNatives__processWorkerMessage, "IsolateNatives__processWorkerMessage$closure"); | |
| init.globalFunctions.toStringWrapper$closure = H.toStringWrapper$closure = new H.Closure$0(H.toStringWrapper, "toStringWrapper$closure"); | |
| init.globalFunctions.invokeClosure$closure = H.invokeClosure$closure = new H.Closure$7(H.invokeClosure, "invokeClosure$closure"); | |
| init.globalFunctions._asyncRunCallback$closure = P._asyncRunCallback$closure = new H.Closure$0(P._asyncRunCallback, "_asyncRunCallback$closure"); | |
| init.globalFunctions._nullDataHandler$closure = P._nullDataHandler$closure = new P.Closure$1(P._nullDataHandler, "_nullDataHandler$closure"); | |
| init.globalFunctions._nullErrorHandler$closure = P._nullErrorHandler$closure = new P.Closure$20(P._nullErrorHandler, "_nullErrorHandler$closure"); | |
| init.globalFunctions._nullDoneHandler$closure = P._nullDoneHandler$closure = new H.Closure$0(P._nullDoneHandler, "_nullDoneHandler$closure"); | |
| init.globalFunctions._defaultEquals$closure = P._defaultEquals$closure = new H.Closure$2(P._defaultEquals, "_defaultEquals$closure"); | |
| init.globalFunctions._defaultHashCode$closure = P._defaultHashCode$closure = new P.Closure$1(P._defaultHashCode, "_defaultHashCode$closure"); | |
| init.globalFunctions.identical$closure = P.identical$closure = new H.Closure$2(P.identical, "identical$closure"); | |
| init.globalFunctions.identityHashCode$closure = P.identityHashCode$closure = new P.Closure$1(P.identityHashCode, "identityHashCode$closure"); | |
| init.globalFunctions.main$closure = S.main$closure = new H.Closure$0(S.main, "main$closure"); | |
| // Runtime type support | |
| W.Node.$isObject = true; | |
| J.JSInt.$isint = true; | |
| J.JSInt.$isObject = true; | |
| J.JSString.$isString = true; | |
| J.JSString.$isObject = true; | |
| J.JSNumber.$isObject = true; | |
| P.Duration.$isObject = true; | |
| W.KeyboardEvent.$isObject = true; | |
| P.Stream.$isStream = true; | |
| P.Stream.$isObject = true; | |
| P.StreamSubscription.$isStreamSubscription = true; | |
| P.StreamSubscription.$isObject = true; | |
| W.Event.$isObject = true; | |
| P.ReceivePort.$isStream = true; | |
| P.ReceivePort.$asStream = [null]; | |
| P.ReceivePort.$isObject = true; | |
| H._IsolateEvent.$isObject = true; | |
| H._IsolateContext.$isObject = true; | |
| J.JSArray.$isObject = true; | |
| W.Element.$isElement = true; | |
| W.Element.$isObject = true; | |
| W.InputElement.$isInputElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isElement = true; | |
| W.InputElement.$isObject = true; | |
| P.Symbol.$isSymbol = true; | |
| P.Symbol.$isObject = true; | |
| P._BroadcastSubscription.$is_BroadcastSubscription = true; | |
| P._BroadcastSubscription.$is_BufferingStreamSubscription = true; | |
| P._BroadcastSubscription.$is_EventSink = true; | |
| P._BroadcastSubscription.$isStreamSubscription = true; | |
| P._BroadcastSubscription.$isObject = true; | |
| P._BufferingStreamSubscription.$is_BufferingStreamSubscription = true; | |
| P._BufferingStreamSubscription.$is_EventSink = true; | |
| P._BufferingStreamSubscription.$isStreamSubscription = true; | |
| P._BufferingStreamSubscription.$isObject = true; | |
| P.StackTrace.$isStackTrace = true; | |
| P.StackTrace.$isObject = true; | |
| P.Object.$isObject = true; | |
| J.JSBool.$isbool = true; | |
| J.JSBool.$isObject = true; | |
| P.Function.$isFunction = true; | |
| P.Function.$isObject = true; | |
| P._EventSink.$is_EventSink = true; | |
| P._EventSink.$isObject = true; | |
| P.Future.$isFuture = true; | |
| P.Future.$isObject = true; | |
| P._DelayedEvent.$is_DelayedEvent = true; | |
| P._DelayedEvent.$isObject = true; | |
| // getInterceptor methods | |
| J.getInterceptor = function(receiver) { | |
| if (typeof receiver == "number") { | |
| if (Math.floor(receiver) == receiver) | |
| return J.JSInt.prototype; | |
| return J.JSDouble.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 (receiver.constructor == Array) | |
| return J.JSArray.prototype; | |
| if (typeof receiver != "object") | |
| return receiver; | |
| if (receiver instanceof P.Object) | |
| return receiver; | |
| return J.getNativeInterceptor(receiver); | |
| }; | |
| J.getInterceptor$asx = function(receiver) { | |
| if (typeof receiver == "string") | |
| return J.JSString.prototype; | |
| if (receiver == null) | |
| return receiver; | |
| if (receiver.constructor == Array) | |
| return J.JSArray.prototype; | |
| if (typeof receiver != "object") | |
| return receiver; | |
| if (receiver instanceof P.Object) | |
| return receiver; | |
| return J.getNativeInterceptor(receiver); | |
| }; | |
| J.getInterceptor$ax = function(receiver) { | |
| if (receiver == null) | |
| return receiver; | |
| if (receiver.constructor == Array) | |
| return J.JSArray.prototype; | |
| if (typeof receiver != "object") | |
| return receiver; | |
| if (receiver instanceof P.Object) | |
| return receiver; | |
| return J.getNativeInterceptor(receiver); | |
| }; | |
| J.getInterceptor$n = function(receiver) { | |
| if (typeof receiver == "number") | |
| return J.JSNumber.prototype; | |
| if (receiver == null) | |
| return receiver; | |
| if (!(receiver instanceof P.Object)) | |
| return J.UnknownJavaScriptObject.prototype; | |
| return receiver; | |
| }; | |
| J.getInterceptor$s = function(receiver) { | |
| if (typeof receiver == "string") | |
| return J.JSString.prototype; | |
| if (receiver == null) | |
| return receiver; | |
| if (!(receiver instanceof P.Object)) | |
| return J.UnknownJavaScriptObject.prototype; | |
| return receiver; | |
| }; | |
| J.getInterceptor$x = function(receiver) { | |
| if (receiver == null) | |
| return receiver; | |
| if (typeof receiver != "object") | |
| return receiver; | |
| if (receiver instanceof P.Object) | |
| return receiver; | |
| return J.getNativeInterceptor(receiver); | |
| }; | |
| C.C__DelayedDone = new P._DelayedDone(); | |
| C.C__RootZone = new P._RootZone(); | |
| C.Duration_0 = new P.Duration(0); | |
| C.EventStreamProvider_input = new W.EventStreamProvider("input"); | |
| C.EventStreamProvider_keyup = new W.EventStreamProvider("keyup"); | |
| C.JSArray_methods = J.JSArray.prototype; | |
| C.JSInt_methods = J.JSInt.prototype; | |
| C.JSNull_methods = J.JSNull.prototype; | |
| C.JSNumber_methods = J.JSNumber.prototype; | |
| C.JSString_methods = J.JSString.prototype; | |
| C.JS_CONST_0 = function(hooks) { | |
| if (typeof dartExperimentalFixupGetTag != "function") return hooks; | |
| hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); | |
| }; | |
| C.JS_CONST_6qb = function(hooks) { | |
| var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
| if (userAgent.indexOf("Firefox") == -1) return hooks; | |
| var getTag = hooks.getTag; | |
| var quickMap = { | |
| "BeforeUnloadEvent": "Event", | |
| "DataTransfer": "Clipboard", | |
| "GeoGeolocation": "Geolocation", | |
| "WorkerMessageEvent": "MessageEvent", | |
| "XMLDocument": "Document"}; | |
| function getTagFirefox(o) { | |
| var tag = getTag(o); | |
| return quickMap[tag] || tag; | |
| } | |
| hooks.getTag = getTagFirefox; | |
| }; | |
| C.JS_CONST_86y = function getTagFallback(o) { | |
| if (o == null) return "Null"; | |
| var constructor = o.constructor; | |
| if (typeof constructor == "function") { | |
| var name = constructor.builtin$cls; | |
| if (typeof name == "string") return name; | |
| name = constructor.name; | |
| if (typeof name == "string" | |
| && name !== "" | |
| && name !== "Object" | |
| && name !== "Function.prototype") { | |
| return name; | |
| } | |
| } | |
| var s = Object.prototype.toString.call(o); | |
| return s.substring(8, s.length - 1); | |
| }; | |
| C.JS_CONST_Cbr = function(getTagFallback) { | |
| return function(hooks) { | |
| if (typeof navigator != "object") return hooks; | |
| var userAgent = navigator.userAgent; | |
| if (userAgent.indexOf("Chrome") >= 0 || | |
| userAgent.indexOf("DumpRenderTree") >= 0) { | |
| return hooks; | |
| } | |
| hooks.getTag = getTagFallback; | |
| }; | |
| }; | |
| C.JS_CONST_Fs4 = function(hooks) { return hooks; } | |
| ; | |
| C.JS_CONST_TtD = function() { | |
| function typeNameInChrome(obj) { return obj.constructor.name; } | |
| function getUnknownTag(object, tag) { | |
| if (/^HTML[A-Z].*Element$/.test(tag)) { | |
| var name = Object.prototype.toString.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 navigator == "object"; | |
| return { | |
| getTag: typeNameInChrome, | |
| getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, | |
| prototypeForTag: prototypeForTag, | |
| discriminator: discriminator }; | |
| }; | |
| C.JS_CONST_ZYJ = ((typeof version == "function" && typeof os == "object" && "system" in os) | |
| || (typeof navigator == "object" | |
| && navigator.userAgent.indexOf('Chrome') != -1)) | |
| ? function(x) { return x.$dartCachedLength || x.length; } | |
| : function(x) { return x.length; }; | |
| ; | |
| C.JS_CONST_rD3 = function(hooks) { | |
| var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
| 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 == "Document") { | |
| if (!!o.xmlVersion) return "!Document"; | |
| return "!HTMLDocument"; | |
| } | |
| if (tag == "Object") { | |
| if (window.DataView && (o instanceof window.DataView)) return "DataView"; | |
| } | |
| return tag; | |
| } | |
| function prototypeForTagIE(tag) { | |
| if (tag == "Document") return null; | |
| var constructor = window[tag]; | |
| if (constructor == null) return null; | |
| return constructor.prototype; | |
| } | |
| hooks.getTag = getTagIE; | |
| hooks.prototypeForTag = prototypeForTagIE; | |
| }; | |
| Isolate.makeConstantList = function(list) { | |
| list.immutable$list = true; | |
| list.fixed$length = true; | |
| return list; | |
| }; | |
| C.List_empty = Isolate.makeConstantList([]); | |
| C.NodeList_methods = W.NodeList.prototype; | |
| C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; | |
| $.lazyPort = null; | |
| $.ReceivePortImpl__nextFreeId = 1; | |
| $.Primitives_mirrorFunctionCacheName = "$cachedFunction"; | |
| $.Primitives_mirrorInvokeCacheName = "$cachedInvocation"; | |
| $.getTagFunction = null; | |
| $.alternateTagFunction = null; | |
| $.prototypeForTagFunction = null; | |
| $.dispatchRecordsForInstanceTags = null; | |
| $.interceptorsForUncacheableTags = null; | |
| $.initNativeDispatchFlag = null; | |
| $.printToZone = null; | |
| $._callbacksAreEnqueued = false; | |
| $.Zone__current = C.C__RootZone; | |
| $.Expando__keyCount = 0; | |
| $.Device__isOpera = null; | |
| $.Device__isWebKit = null; | |
| J.$eq = function(receiver, a0) { | |
| if (receiver == null) | |
| return a0 == null; | |
| if (typeof receiver != "object") | |
| return a0 != null && receiver === a0; | |
| return J.getInterceptor(receiver).$eq(receiver, a0); | |
| }; | |
| J.$ge$n = function(receiver, a0) { | |
| if (typeof receiver == "number" && typeof a0 == "number") | |
| return receiver >= a0; | |
| return J.getInterceptor$n(receiver).$ge(receiver, a0); | |
| }; | |
| J.$index$asx = function(receiver, a0) { | |
| if (receiver.constructor == Array || typeof receiver == "string" || H.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) | |
| if (a0 >>> 0 === a0 && a0 < receiver.length) | |
| return receiver[a0]; | |
| return J.getInterceptor$asx(receiver).$index(receiver, a0); | |
| }; | |
| J.$indexSet$ax = function(receiver, a0, a1) { | |
| if ((receiver.constructor == Array || H.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) && !receiver.immutable$list && a0 >>> 0 === a0 && a0 < receiver.length) | |
| return receiver[a0] = a1; | |
| return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); | |
| }; | |
| J.add$1$ax = function(receiver, a0) { | |
| return J.getInterceptor$ax(receiver).add$1(receiver, a0); | |
| }; | |
| J.addEventListener$3$x = function(receiver, a0, a1, a2) { | |
| return J.getInterceptor$x(receiver).addEventListener$3(receiver, a0, a1, a2); | |
| }; | |
| J.elementAt$1$ax = function(receiver, a0) { | |
| return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); | |
| }; | |
| J.forEach$1$ax = function(receiver, a0) { | |
| return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); | |
| }; | |
| J.get$className$x = function(receiver) { | |
| return J.getInterceptor$x(receiver).get$className(receiver); | |
| }; | |
| J.get$classes$x = function(receiver) { | |
| return J.getInterceptor$x(receiver).get$classes(receiver); | |
| }; | |
| J.get$error$x = function(receiver) { | |
| return J.getInterceptor$x(receiver).get$error(receiver); | |
| }; | |
| J.get$hashCode$ = function(receiver) { | |
| return J.getInterceptor(receiver).get$hashCode(receiver); | |
| }; | |
| J.get$iterator$ax = function(receiver) { | |
| return J.getInterceptor$ax(receiver).get$iterator(receiver); | |
| }; | |
| J.get$length$asx = function(receiver) { | |
| return J.getInterceptor$asx(receiver).get$length(receiver); | |
| }; | |
| J.get$name$x = function(receiver) { | |
| return J.getInterceptor$x(receiver).get$name(receiver); | |
| }; | |
| J.get$value$x = function(receiver) { | |
| return J.getInterceptor$x(receiver).get$value(receiver); | |
| }; | |
| J.removeEventListener$3$x = function(receiver, a0, a1, a2) { | |
| return J.getInterceptor$x(receiver).removeEventListener$3(receiver, a0, a1, a2); | |
| }; | |
| J.set$className$x = function(receiver, value) { | |
| return J.getInterceptor$x(receiver).set$className(receiver, value); | |
| }; | |
| J.toList$0$ax = function(receiver) { | |
| return J.getInterceptor$ax(receiver).toList$0(receiver); | |
| }; | |
| J.toString$0 = function(receiver) { | |
| return J.getInterceptor(receiver).toString$0(receiver); | |
| }; | |
| J.trim$0$s = function(receiver) { | |
| return J.getInterceptor$s(receiver).trim$0(receiver); | |
| }; | |
| Isolate.$lazy($, "globalThis", "globalThis", "get$globalThis", function() { | |
| return function() { return this; }(); | |
| }); | |
| Isolate.$lazy($, "globalWindow", "globalWindow", "get$globalWindow", function() { | |
| return $.get$globalThis().window; | |
| }); | |
| Isolate.$lazy($, "globalWorker", "globalWorker", "get$globalWorker", function() { | |
| return $.get$globalThis().Worker; | |
| }); | |
| Isolate.$lazy($, "globalPostMessageDefined", "globalPostMessageDefined", "get$globalPostMessageDefined", function() { | |
| return $.get$globalThis().postMessage !== void 0; | |
| }); | |
| Isolate.$lazy($, "thisScript", "IsolateNatives_thisScript", "get$IsolateNatives_thisScript", function() { | |
| return H.IsolateNatives_computeThisScript(); | |
| }); | |
| Isolate.$lazy($, "workerIds", "IsolateNatives_workerIds", "get$IsolateNatives_workerIds", function() { | |
| return new P.Expando(null); | |
| }); | |
| Isolate.$lazy($, "noSuchMethodPattern", "TypeErrorDecoder_noSuchMethodPattern", "get$TypeErrorDecoder_noSuchMethodPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({ toString: function() { return "$receiver$"; } })); | |
| }); | |
| Isolate.$lazy($, "notClosurePattern", "TypeErrorDecoder_notClosurePattern", "get$TypeErrorDecoder_notClosurePattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({ $method$: null, toString: function() { return "$receiver$"; } })); | |
| }); | |
| Isolate.$lazy($, "nullCallPattern", "TypeErrorDecoder_nullCallPattern", "get$TypeErrorDecoder_nullCallPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null)); | |
| }); | |
| Isolate.$lazy($, "nullLiteralCallPattern", "TypeErrorDecoder_nullLiteralCallPattern", "get$TypeErrorDecoder_nullLiteralCallPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOnNull()); | |
| }); | |
| Isolate.$lazy($, "undefinedCallPattern", "TypeErrorDecoder_undefinedCallPattern", "get$TypeErrorDecoder_undefinedCallPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0)); | |
| }); | |
| Isolate.$lazy($, "undefinedLiteralCallPattern", "TypeErrorDecoder_undefinedLiteralCallPattern", "get$TypeErrorDecoder_undefinedLiteralCallPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOnUndefined()); | |
| }); | |
| Isolate.$lazy($, "nullPropertyPattern", "TypeErrorDecoder_nullPropertyPattern", "get$TypeErrorDecoder_nullPropertyPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null)); | |
| }); | |
| Isolate.$lazy($, "nullLiteralPropertyPattern", "TypeErrorDecoder_nullLiteralPropertyPattern", "get$TypeErrorDecoder_nullLiteralPropertyPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOnNull()); | |
| }); | |
| Isolate.$lazy($, "undefinedPropertyPattern", "TypeErrorDecoder_undefinedPropertyPattern", "get$TypeErrorDecoder_undefinedPropertyPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0)); | |
| }); | |
| Isolate.$lazy($, "undefinedLiteralPropertyPattern", "TypeErrorDecoder_undefinedLiteralPropertyPattern", "get$TypeErrorDecoder_undefinedLiteralPropertyPattern", function() { | |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOnUndefined()); | |
| }); | |
| Isolate.$lazy($, "_toStringList", "IterableMixinWorkaround__toStringList", "get$IterableMixinWorkaround__toStringList", function() { | |
| return P.List_List(null, null); | |
| }); | |
| Isolate.$lazy($, "_asyncCallbacks", "_asyncCallbacks", "get$_asyncCallbacks", function() { | |
| return P.ListQueue$(null, {func: "void_", void: true}); | |
| }); | |
| Isolate.$lazy($, "_toStringVisiting", "_toStringVisiting", "get$_toStringVisiting", function() { | |
| return P.HashSet_HashSet$identity(null); | |
| }); | |
| Isolate.$lazy($, "_toStringList", "Maps__toStringList", "get$Maps__toStringList", function() { | |
| return P.List_List(null, null); | |
| }); | |
| // Native classes | |
| init.functionAliases = {}; | |
| ; | |
| init.metadata = []; | |
| $ = null; | |
| Isolate = Isolate.$finishIsolateConstructor(Isolate); | |
| $ = new Isolate(); | |
| function convertToFastObject(properties) { | |
| function MyClass() {}; | |
| MyClass.prototype = properties; | |
| new MyClass(); | |
| return properties; | |
| } | |
| A = convertToFastObject(A); | |
| B = convertToFastObject(B); | |
| C = convertToFastObject(C); | |
| D = convertToFastObject(D); | |
| E = convertToFastObject(E); | |
| F = convertToFastObject(F); | |
| G = convertToFastObject(G); | |
| H = convertToFastObject(H); | |
| J = convertToFastObject(J); | |
| K = convertToFastObject(K); | |
| L = convertToFastObject(L); | |
| M = convertToFastObject(M); | |
| N = convertToFastObject(N); | |
| O = convertToFastObject(O); | |
| P = convertToFastObject(P); | |
| Q = convertToFastObject(Q); | |
| R = convertToFastObject(R); | |
| S = convertToFastObject(S); | |
| T = convertToFastObject(T); | |
| U = convertToFastObject(U); | |
| V = convertToFastObject(V); | |
| W = convertToFastObject(W); | |
| X = convertToFastObject(X); | |
| Y = convertToFastObject(Y); | |
| Z = convertToFastObject(Z); | |
| !function() { | |
| var objectProto = Object.prototype; | |
| for (var i = 0;; i++) { | |
| var property = "___dart_dispatch_record_ZxYxX_0_"; | |
| if (i > 0) | |
| property = rootProperty + "_" + i; | |
| if (!(property in objectProto)) | |
| return init.dispatchPropertyName = property; | |
| } | |
| }(); | |
| // BEGIN invoke [main]. | |
| ;(function (callback) { | |
| if (typeof document === "undefined") { | |
| callback(null); | |
| return; | |
| } | |
| if (document.currentScript) { | |
| 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; | |
| if (typeof dartMainRunner === "function") { | |
| dartMainRunner(function() { H.startRootIsolate(S.main$closure); }); | |
| } else { | |
| H.startRootIsolate(S.main$closure); | |
| } | |
| }); | |
| // END invoke [main]. | |
| function init() { | |
| Isolate.$isolateProperties = {}; | |
| function generateAccessor(field, accessors, cls) { | |
| var len = field.length; | |
| var code = field.charCodeAt(len - 1); | |
| var reflectable = false; | |
| if (code == 45) { | |
| len--; | |
| code = field.charCodeAt(len - 1); | |
| field = field.substring(0, len); | |
| reflectable = true; | |
| } | |
| code = code >= 60 && code <= 64 ? code - 59 : code >= 123 && code <= 126 ? code - 117 : code >= 37 && code <= 43 ? code - 27 : 0; | |
| if (code) { | |
| var getterCode = code & 3; | |
| var setterCode = code >> 2; | |
| var accessorName = field = field.substring(0, len - 1); | |
| var divider = field.indexOf(":"); | |
| if (divider > 0) { | |
| accessorName = field.substring(0, divider); | |
| field = field.substring(divider + 1); | |
| } | |
| if (getterCode) { | |
| var args = getterCode & 2 ? "receiver" : ""; | |
| var receiver = getterCode & 1 ? "this" : "receiver"; | |
| var body = "return " + receiver + "." + field; | |
| var property = cls + ".prototype.get$" + accessorName + "="; | |
| var fn = "function(" + args + "){" + body + "}"; | |
| if (reflectable) | |
| accessors.push(property + "$reflectable(" + fn + ");\n"); | |
| else | |
| accessors.push(property + fn + ";\n"); | |
| } | |
| if (setterCode) { | |
| var args = setterCode & 2 ? "receiver, value" : "value"; | |
| var receiver = setterCode & 1 ? "this" : "receiver"; | |
| var body = receiver + "." + field + " = value"; | |
| var property = cls + ".prototype.set$" + accessorName + "="; | |
| var fn = "function(" + args + "){" + body + "}"; | |
| if (reflectable) | |
| accessors.push(property + "$reflectable(" + fn + ");\n"); | |
| else | |
| accessors.push(property + fn + ";\n"); | |
| } | |
| } | |
| return field; | |
| } | |
| Isolate.$isolateProperties.$generateAccessor = generateAccessor; | |
| function defineClass(name, cls, fields) { | |
| var accessors = []; | |
| var str = "function " + cls + "("; | |
| var body = ""; | |
| for (var i = 0; i < fields.length; i++) { | |
| if (i != 0) | |
| str += ", "; | |
| var field = generateAccessor(fields[i], accessors, cls); | |
| var parameter = "parameter_" + field; | |
| str += parameter; | |
| body += "this." + field + " = " + parameter + ";\n"; | |
| } | |
| str += ") {\n" + body + "}\n"; | |
| str += cls + ".builtin$cls=\"" + name + "\";\n"; | |
| str += "$desc=$collectedClasses." + cls + ";\n"; | |
| str += "if($desc instanceof Array) $desc = $desc[1];\n"; | |
| str += cls + ".prototype = $desc;\n"; | |
| if (typeof defineClass.name != "string") { | |
| str += cls + ".name=\"" + cls + "\";\n"; | |
| } | |
| str += accessors.join(""); | |
| return str; | |
| } | |
| var inheritFrom = function() { | |
| function tmp() { | |
| } | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| return function(constructor, superConstructor) { | |
| tmp.prototype = superConstructor.prototype; | |
| var object = new tmp(); | |
| var properties = constructor.prototype; | |
| for (var member in properties) | |
| if (hasOwnProperty.call(properties, member)) | |
| object[member] = properties[member]; | |
| object.constructor = constructor; | |
| constructor.prototype = object; | |
| return object; | |
| }; | |
| }(); | |
| Isolate.$finishClasses = function(collectedClasses, isolateProperties, existingIsolateProperties) { | |
| var pendingClasses = {}; | |
| if (!init.allClasses) | |
| init.allClasses = {}; | |
| var allClasses = init.allClasses; | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| if (typeof dart_precompiled == "function") { | |
| var constructors = dart_precompiled(collectedClasses); | |
| } else { | |
| var combinedConstructorFunction = "function $reflectable(fn){fn.$reflectable=1;return fn};\n" + "var $desc;\n"; | |
| var constructorsList = []; | |
| } | |
| for (var cls in collectedClasses) { | |
| if (hasOwnProperty.call(collectedClasses, cls)) { | |
| var desc = collectedClasses[cls]; | |
| if (desc instanceof Array) | |
| desc = desc[1]; | |
| var classData = desc[""], supr, name = cls, fields = classData; | |
| if (typeof classData == "string") { | |
| var split = classData.split("/"); | |
| if (split.length == 2) { | |
| name = split[0]; | |
| fields = split[1]; | |
| } | |
| } | |
| var s = fields.split(";"); | |
| fields = s[1] == "" ? [] : s[1].split(","); | |
| supr = s[0]; | |
| if (supr && supr.indexOf("+") > 0) { | |
| s = supr.split("+"); | |
| supr = s[0]; | |
| var mixin = collectedClasses[s[1]]; | |
| if (mixin instanceof Array) | |
| mixin = mixin[1]; | |
| for (var d in mixin) { | |
| if (hasOwnProperty.call(mixin, d) && !hasOwnProperty.call(desc, d)) | |
| desc[d] = mixin[d]; | |
| } | |
| } | |
| if (typeof dart_precompiled != "function") { | |
| combinedConstructorFunction += defineClass(name, cls, fields); | |
| constructorsList.push(cls); | |
| } | |
| if (supr) | |
| pendingClasses[cls] = supr; | |
| } | |
| } | |
| if (typeof dart_precompiled != "function") { | |
| combinedConstructorFunction += "return [\n " + constructorsList.join(",\n ") + "\n]"; | |
| var constructors = new Function("$collectedClasses", combinedConstructorFunction)(collectedClasses); | |
| combinedConstructorFunction = null; | |
| } | |
| for (var i = 0; i < constructors.length; i++) { | |
| var constructor = constructors[i]; | |
| var cls = constructor.name; | |
| var desc = collectedClasses[cls]; | |
| var globalObject = isolateProperties; | |
| if (desc instanceof Array) { | |
| globalObject = desc[0] || isolateProperties; | |
| desc = desc[1]; | |
| } | |
| allClasses[cls] = constructor; | |
| globalObject[cls] = constructor; | |
| } | |
| constructors = null; | |
| var finishedClasses = {}; | |
| init.interceptorsByTag = Object.create(null); | |
| init.leafTags = {}; | |
| function finishClass(cls) { | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| if (hasOwnProperty.call(finishedClasses, cls)) | |
| return; | |
| finishedClasses[cls] = true; | |
| var superclass = pendingClasses[cls]; | |
| if (!superclass || typeof superclass != "string") | |
| return; | |
| finishClass(superclass); | |
| var constructor = allClasses[cls]; | |
| var superConstructor = allClasses[superclass]; | |
| if (!superConstructor) | |
| superConstructor = existingIsolateProperties[superclass]; | |
| var prototype = inheritFrom(constructor, superConstructor); | |
| if (hasOwnProperty.call(prototype, "%")) { | |
| var nativeSpec = prototype["%"].split(";"); | |
| if (nativeSpec[0]) { | |
| var tags = nativeSpec[0].split("|"); | |
| for (var i = 0; i < tags.length; i++) { | |
| init.interceptorsByTag[tags[i]] = constructor; | |
| init.leafTags[tags[i]] = true; | |
| } | |
| } | |
| if (nativeSpec[1]) { | |
| tags = nativeSpec[1].split("|"); | |
| if (nativeSpec[2]) { | |
| var subclasses = nativeSpec[2].split("|"); | |
| for (var i = 0; i < subclasses.length; i++) { | |
| var subclass = allClasses[subclasses[i]]; | |
| subclass.$nativeSuperclassTag = tags[0]; | |
| } | |
| } | |
| for (i = 0; i < tags.length; i++) { | |
| init.interceptorsByTag[tags[i]] = constructor; | |
| init.leafTags[tags[i]] = false; | |
| } | |
| } | |
| } | |
| } | |
| for (var cls in pendingClasses) | |
| finishClass(cls); | |
| }; | |
| Isolate.$lazy = function(prototype, staticName, fieldName, getterName, lazyValue) { | |
| var sentinelUndefined = {}; | |
| var sentinelInProgress = {}; | |
| prototype[fieldName] = sentinelUndefined; | |
| prototype[getterName] = function() { | |
| var result = $[fieldName]; | |
| try { | |
| if (result === sentinelUndefined) { | |
| $[fieldName] = sentinelInProgress; | |
| try { | |
| result = $[fieldName] = lazyValue(); | |
| } finally { | |
| if (result === sentinelUndefined) { | |
| if ($[fieldName] === sentinelInProgress) { | |
| $[fieldName] = null; | |
| } | |
| } | |
| } | |
| } else { | |
| if (result === sentinelInProgress) | |
| H.throwCyclicInit(staticName); | |
| } | |
| return result; | |
| } finally { | |
| $[getterName] = function() { | |
| return this[fieldName]; | |
| }; | |
| } | |
| }; | |
| }; | |
| Isolate.$finishIsolateConstructor = function(oldIsolate) { | |
| var isolateProperties = oldIsolate.$isolateProperties; | |
| function Isolate() { | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| for (var staticName in isolateProperties) | |
| if (hasOwnProperty.call(isolateProperties, staticName)) | |
| this[staticName] = isolateProperties[staticName]; | |
| function ForceEfficientMap() { | |
| } | |
| ForceEfficientMap.prototype = this; | |
| new ForceEfficientMap(); | |
| } | |
| Isolate.prototype = oldIsolate.prototype; | |
| Isolate.prototype.constructor = Isolate; | |
| Isolate.$isolateProperties = isolateProperties; | |
| Isolate.$finishClasses = oldIsolate.$finishClasses; | |
| Isolate.makeConstantList = oldIsolate.makeConstantList; | |
| return Isolate; | |
| }; | |
| } | |
| })() | |
| //# sourceMappingURL=paravictor.dart.js.map | |
| //@ sourceMappingURL=paravictor.dart.js.map |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment