| // Generated by dart2js, the Dart to JavaScript compiler version: 1.11.0-edge.131474. |
| // The code supports the following hooks: |
| // dartPrint(message): |
| // if this function is defined it is called instead of the Dart [print] |
| // method. |
| // |
| // dartMainRunner(main, args): |
| // if this function is defined, the Dart [main] method will not be invoked |
| // directly. Instead, a closure that will invoke [main], and its arguments |
| // [args] is passed to [dartMainRunner]. |
| // |
| // dartDeferredLibraryLoader(uri, successCallback, errorCallback): |
| // if this function is defined, it will be called when a deferered library |
| // is loaded. It should load and eval the javascript of `uri`, and call |
| // successCallback. If it fails to do so, it should call errorCallback with |
| // an error. |
| (function($) { |
| var supportsDirectProtoAccess = function() { |
| var cls = function() { |
| }; |
| cls.prototype = {p: {}}; |
| var object = new cls(); |
| return object.__proto__ && object.__proto__.p === cls.prototype.p; |
| }(); |
| ; |
| function map(x) { |
| x = Object.create(null); |
| x.x = 0; |
| delete x.x; |
| return x; |
| } |
| var A = map(); |
| var B = map(); |
| var C = map(); |
| var D = map(); |
| var E = map(); |
| var F = map(); |
| var G = map(); |
| var H = map(); |
| var J = map(); |
| var K = map(); |
| var L = map(); |
| var M = map(); |
| var N = map(); |
| var O = map(); |
| var P = map(); |
| var Q = map(); |
| var R = map(); |
| var S = map(); |
| var T = map(); |
| var U = map(); |
| var V = map(); |
| var W = map(); |
| var X = map(); |
| var Y = map(); |
| var Z = map(); |
| function Isolate() {} |
| init(); |
| |
| $ = Isolate.$isolateProperties; |
| $.functionThatReturnsNull = function() { |
| }; |
| ; |
| function setupProgram(programData, typesOffset) { |
| "use strict"; |
| function generateAccessor(fieldDescriptor, accessors, cls) { |
| var fieldInformation = fieldDescriptor.split("-"); |
| var field = fieldInformation[0]; |
| var len = field.length; |
| var code = field.charCodeAt(len - 1); |
| var reflectable; |
| if (fieldInformation.length > 1) |
| reflectable = true; |
| else |
| reflectable = false; |
| 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; |
| } |
| function defineClass(name, fields) { |
| var accessors = []; |
| var str = "function " + name + "("; |
| var body = ""; |
| var fieldNames = ""; |
| for (var i = 0; i < fields.length; i++) { |
| if (i != 0) |
| str += ", "; |
| var field = generateAccessor(fields[i], accessors, name); |
| fieldNames += "'" + field + "',"; |
| var parameter = "p_" + field; |
| str += parameter; |
| body += "this." + field + " = " + parameter + ";\n"; |
| } |
| if (supportsDirectProtoAccess) |
| body += "this." + "$deferredAction" + "();"; |
| str += ") {\n" + body + "}\n"; |
| str += name + ".builtin$cls=\"" + name + "\";\n"; |
| str += "$desc=$collectedClasses." + name + "[1];\n"; |
| str += name + ".prototype = $desc;\n"; |
| if (typeof defineClass.name != "string") |
| str += name + ".name=\"" + name + "\";\n"; |
| str += name + "." + "$__fields__" + "=[" + fieldNames + "];\n"; |
| str += accessors.join(""); |
| return str; |
| } |
| init.createNewIsolate = function() { |
| return new Isolate(); |
| }; |
| init.classIdExtractor = function(o) { |
| return o.constructor.name; |
| }; |
| init.classFieldsExtractor = function(o) { |
| var fieldNames = o.constructor.$__fields__; |
| if (!fieldNames) |
| return []; |
| var result = []; |
| result.length = fieldNames.length; |
| for (var i = 0; i < fieldNames.length; i++) |
| result[i] = o[fieldNames[i]]; |
| return result; |
| }; |
| init.instanceFromClassId = function(name) { |
| return new init.allClasses[name](); |
| }; |
| init.initializeEmptyInstance = function(name, o, fields) { |
| init.allClasses[name].apply(o, fields); |
| return o; |
| }; |
| var inheritFrom = supportsDirectProtoAccess ? function(constructor, superConstructor) { |
| var prototype = constructor.prototype; |
| prototype.__proto__ = superConstructor.prototype; |
| prototype.constructor = constructor; |
| prototype["$is" + constructor.name] = constructor; |
| return convertToFastObject(prototype); |
| } : function() { |
| function tmp() { |
| } |
| return function(constructor, superConstructor) { |
| tmp.prototype = superConstructor.prototype; |
| var object = new tmp(); |
| convertToSlowObject(object); |
| var properties = constructor.prototype; |
| var members = Object.keys(properties); |
| for (var i = 0; i < members.length; i++) { |
| var member = members[i]; |
| object[member] = properties[member]; |
| } |
| object["$is" + constructor.name] = constructor; |
| object.constructor = constructor; |
| constructor.prototype = object; |
| return object; |
| }; |
| }(); |
| function finishClasses(processedClasses) { |
| var allClasses = init.allClasses; |
| processedClasses.combinedConstructorFunction += "return [\n" + processedClasses.constructorsList.join(",\n ") + "\n]"; |
| var constructors = new Function("$collectedClasses", processedClasses.combinedConstructorFunction)(processedClasses.collected); |
| processedClasses.combinedConstructorFunction = null; |
| for (var i = 0; i < constructors.length; i++) { |
| var constructor = constructors[i]; |
| var cls = constructor.name; |
| var desc = processedClasses.collected[cls]; |
| var globalObject = desc[0]; |
| desc = desc[1]; |
| allClasses[cls] = constructor; |
| globalObject[cls] = constructor; |
| } |
| constructors = null; |
| var finishedClasses = init.finishedClasses; |
| function finishClass(cls) { |
| if (finishedClasses[cls]) |
| return; |
| finishedClasses[cls] = true; |
| var superclass = processedClasses.pending[cls]; |
| if (!superclass || typeof superclass != "string") { |
| var constructor = allClasses[cls]; |
| var prototype = constructor.prototype; |
| prototype.constructor = constructor; |
| prototype.$isObject = constructor; |
| prototype.$deferredAction = function() { |
| }; |
| return; |
| } |
| finishClass(superclass); |
| var superConstructor = allClasses[superclass]; |
| if (!superConstructor) |
| superConstructor = existingIsolateProperties[superclass]; |
| var constructor = allClasses[cls]; |
| var prototype = inheritFrom(constructor, superConstructor); |
| if (prototype.$isInterceptor) |
| prototype.$deferredAction(); |
| } |
| var properties = Object.keys(processedClasses.pending); |
| for (var i = 0; i < properties.length; i++) |
| finishClass(properties[i]); |
| } |
| function finishAddStubsHelper() { |
| var prototype = this; |
| while (!prototype.hasOwnProperty("$deferredAction")) |
| prototype = prototype.__proto__; |
| delete prototype.$deferredAction; |
| var properties = Object.keys(prototype); |
| for (var index = 0; index < properties.length; index++) { |
| var property = properties[index]; |
| var firstChar = property.charCodeAt(0); |
| var elem; |
| if (property !== "^" && property !== "$reflectable" && firstChar !== 43 && firstChar !== 42 && (elem = prototype[property]) != null && elem.constructor === Array && property !== "<>") |
| addStubs(prototype, elem, property, false, []); |
| } |
| convertToFastObject(prototype); |
| prototype = prototype.__proto__; |
| prototype.$deferredAction(); |
| } |
| function processClassData(cls, descriptor, processedClasses) { |
| descriptor = convertToSlowObject(descriptor); |
| var previousProperty; |
| var properties = Object.keys(descriptor); |
| var hasDeferredWork = false; |
| var shouldDeferWork = supportsDirectProtoAccess && cls != "Object"; |
| for (var i = 0; i < properties.length; i++) { |
| var property = properties[i]; |
| var firstChar = property.charCodeAt(0); |
| if (property === "static") { |
| processStatics(init.statics[cls] = descriptor.static, processedClasses); |
| delete descriptor.static; |
| } else if (firstChar === 43) { |
| mangledNames[previousProperty] = property.substring(1); |
| var flag = descriptor[property]; |
| if (flag > 0) |
| descriptor[previousProperty].$reflectable = flag; |
| } else if (firstChar === 42) { |
| descriptor[previousProperty].$defaultValues = descriptor[property]; |
| var optionalMethods = descriptor.$methodsWithOptionalArguments; |
| if (!optionalMethods) |
| descriptor.$methodsWithOptionalArguments = optionalMethods = {}; |
| optionalMethods[property] = previousProperty; |
| } else { |
| var elem = descriptor[property]; |
| if (property !== "^" && elem != null && elem.constructor === Array && property !== "<>") |
| if (shouldDeferWork) |
| hasDeferredWork = true; |
| else |
| addStubs(descriptor, elem, property, false, []); |
| else |
| previousProperty = property; |
| } |
| } |
| if (hasDeferredWork) |
| descriptor.$deferredAction = finishAddStubsHelper; |
| var classData = descriptor["^"], split, supr, fields = classData; |
| var s = fields.split(";"); |
| fields = s[1] == "" ? [] : s[1].split(","); |
| supr = s[0]; |
| split = supr.split(":"); |
| if (split.length == 2) { |
| supr = split[0]; |
| var functionSignature = split[1]; |
| if (functionSignature) |
| descriptor.$signature = function(s) { |
| return function() { |
| return init.types[s]; |
| }; |
| }(functionSignature); |
| } |
| if (supr) |
| processedClasses.pending[cls] = supr; |
| processedClasses.combinedConstructorFunction += defineClass(cls, fields); |
| processedClasses.constructorsList.push(cls); |
| processedClasses.collected[cls] = [globalObject, descriptor]; |
| classes.push(cls); |
| } |
| function processStatics(descriptor, processedClasses) { |
| var properties = Object.keys(descriptor); |
| for (var i = 0; i < properties.length; i++) { |
| var property = properties[i]; |
| if (property === "^") |
| continue; |
| var element = descriptor[property]; |
| var firstChar = property.charCodeAt(0); |
| var previousProperty; |
| if (firstChar === 43) { |
| mangledGlobalNames[previousProperty] = property.substring(1); |
| var flag = descriptor[property]; |
| if (flag > 0) |
| descriptor[previousProperty].$reflectable = flag; |
| if (element && element.length) |
| init.typeInformation[previousProperty] = element; |
| } else if (firstChar === 42) { |
| 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 if (element.constructor === Array) |
| addStubs(globalObject, element, property, true, functions); |
| else { |
| previousProperty = property; |
| processClassData(property, element, processedClasses); |
| } |
| } |
| } |
| function addStubs(prototype, array, name, isStatic, functions) { |
| var index = 0, alias = array[index], f; |
| if (typeof alias == "string") |
| f = array[++index]; |
| else { |
| f = alias; |
| alias = name; |
| } |
| var funcs = [prototype[name] = prototype[alias] = f]; |
| f.$stubName = name; |
| functions.push(name); |
| for (index++; index < array.length; index++) { |
| f = array[index]; |
| if (typeof f != "function") |
| break; |
| if (!isStatic) |
| f.$stubName = array[++index]; |
| funcs.push(f); |
| if (f.$stubName) { |
| prototype[f.$stubName] = f; |
| functions.push(f.$stubName); |
| } |
| } |
| for (var i = 0; i < funcs.length; index++, i++) |
| funcs[i].$callName = array[index]; |
| var getterStubName = array[index]; |
| array = array.slice(++index); |
| var requiredParameterInfo = array[0]; |
| var requiredParameterCount = requiredParameterInfo >> 1; |
| var isAccessor = (requiredParameterInfo & 1) === 1; |
| var isSetter = requiredParameterInfo === 3; |
| var isGetter = requiredParameterInfo === 1; |
| var optionalParameterInfo = array[1]; |
| var optionalParameterCount = optionalParameterInfo >> 1; |
| var optionalParametersAreNamed = (optionalParameterInfo & 1) === 1; |
| var isIntercepted = requiredParameterCount + optionalParameterCount != funcs[0].length; |
| var functionTypeIndex = array[2]; |
| if (typeof functionTypeIndex == "number") |
| array[2] = functionTypeIndex + typesOffset; |
| var unmangledNameIndex = 2 * optionalParameterCount + requiredParameterCount + 3; |
| if (getterStubName) { |
| f = tearOff(funcs, array, isStatic, name, isIntercepted); |
| prototype[name].$getter = f; |
| f.$getterStub = true; |
| if (isStatic) { |
| init.globalFunctions[name] = f; |
| functions.push(getterStubName); |
| } |
| prototype[getterStubName] = f; |
| funcs.push(f); |
| f.$stubName = getterStubName; |
| f.$callName = null; |
| } |
| } |
| function tearOffGetter(funcs, reflectionInfo, name, isIntercepted) { |
| return isIntercepted ? new Function("funcs", "reflectionInfo", "name", "H", "c", "return function tearOff_" + name + functionCounter++ + "(x) {" + "if (c === null) c = H.closureFromTearOff(" + "this, funcs, reflectionInfo, false, [x], name);" + "return new c(this, funcs[0], x, name);" + "}")(funcs, reflectionInfo, name, H, null) : new Function("funcs", "reflectionInfo", "name", "H", "c", "return function tearOff_" + name + functionCounter++ + "() {" + "if (c === null) c = H.closureFromTearOff(" + "this, funcs, reflectionInfo, false, [], name);" + "return new c(this, funcs[0], null, name);" + "}")(funcs, reflectionInfo, name, H, null); |
| } |
| function tearOff(funcs, reflectionInfo, isStatic, name, isIntercepted) { |
| var cache; |
| return isStatic ? function() { |
| if (cache === void 0) |
| cache = H.closureFromTearOff(this, funcs, reflectionInfo, true, [], name).prototype; |
| return cache; |
| } : tearOffGetter(funcs, reflectionInfo, name, isIntercepted); |
| } |
| var functionCounter = 0; |
| 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 = programData.length; |
| var processedClasses = map(); |
| processedClasses.collected = map(); |
| processedClasses.pending = map(); |
| processedClasses.constructorsList = []; |
| processedClasses.combinedConstructorFunction = "function $reflectable(fn){fn.$reflectable=1;return fn};\n" + "var $desc;\n"; |
| for (var i = 0; i < length; i++) { |
| var data = programData[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["^"]; |
| if (fields instanceof Array) |
| fields = fields[0]; |
| var classes = []; |
| var functions = []; |
| processStatics(descriptor, processedClasses); |
| libraries.push([name, uri, classes, functions, metadata, fields, isRoot, globalObject]); |
| } |
| finishClasses(processedClasses); |
| } |
| var dart =[["_foreign_helper", "dart:_foreign_helper",, H, { |
| "^": "", |
| JS_CONST: { |
| "^": "Object;code" |
| } |
| }], ["_interceptors", "dart:_interceptors",, J, { |
| "^": "", |
| getInterceptor: function(object) { |
| return void 0; |
| }, |
| 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); |
| } |
| }, |
| JSBool: { |
| "^": "Interceptor;", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| get$hashCode: function(receiver) { |
| return receiver ? 519018 : 218159; |
| }, |
| $isbool: 1 |
| }, |
| 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; |
| }, |
| $isJSObject: 1 |
| }, |
| PlainJavaScriptObject: { |
| "^": "JavaScriptObject;" |
| }, |
| UnknownJavaScriptObject: { |
| "^": "JavaScriptObject;", |
| toString$0: function(receiver) { |
| return String(receiver); |
| } |
| }, |
| JSArray: { |
| "^": "Interceptor;", |
| checkMutable$1: function(receiver, reason) { |
| if (!!receiver.immutable$list) |
| throw H.wrapException(new P.UnsupportedError(reason)); |
| }, |
| checkGrowable$1: function(receiver, reason) { |
| if (!!receiver.fixed$length) |
| throw H.wrapException(new P.UnsupportedError(reason)); |
| }, |
| forEach$1: function(receiver, f) { |
| var end, i; |
| end = receiver.length; |
| for (i = 0; i < end; ++i) { |
| f.call$1(receiver[i]); |
| if (receiver.length !== end) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| }, |
| map$1: function(receiver, f) { |
| return H.setRuntimeTypeInfo(new H.MappedListIterable(receiver, f), [null, null]); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index < 0 || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| get$first: function(receiver) { |
| if (receiver.length > 0) |
| return receiver[0]; |
| throw H.wrapException(H.IterableElementError_noElement()); |
| }, |
| setRange$4: function(receiver, start, end, iterable, skipCount) { |
| var $length, i, t1; |
| this.checkMutable$1(receiver, "set range"); |
| P.RangeError_checkValidRange(start, end, receiver.length, null, null, null); |
| $length = end - start; |
| if ($length === 0) |
| return; |
| if (skipCount + $length > iterable.length) |
| throw H.wrapException(new P.StateError("Too few elements")); |
| if (skipCount < start) |
| for (i = $length - 1; i >= 0; --i) { |
| t1 = skipCount + i; |
| if (t1 >= iterable.length) |
| return H.ioore(iterable, t1); |
| receiver[start + i] = iterable[t1]; |
| } |
| else |
| for (i = 0; i < $length; ++i) { |
| t1 = skipCount + i; |
| if (t1 >= iterable.length) |
| return H.ioore(iterable, t1); |
| receiver[start + i] = iterable[t1]; |
| } |
| }, |
| toString$0: function(receiver) { |
| return P.IterableBase_iterableToFullString(receiver, "[", "]"); |
| }, |
| get$iterator: function(receiver) { |
| return new J.ArrayIterator(receiver, receiver.length, 0, null); |
| }, |
| get$hashCode: function(receiver) { |
| return H.Primitives_objectHashCode(receiver); |
| }, |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| set$length: function(receiver, newLength) { |
| this.checkGrowable$1(receiver, "set length"); |
| if (newLength < 0) |
| throw H.wrapException(P.RangeError$value(newLength, null, null)); |
| receiver.length = newLength; |
| }, |
| $index: function(receiver, index) { |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| throw H.wrapException(P.ArgumentError$(index)); |
| if (index >= receiver.length || index < 0) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| return receiver[index]; |
| }, |
| $indexSet: function(receiver, index, value) { |
| this.checkMutable$1(receiver, "indexed set"); |
| if (index >= receiver.length || false) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| receiver[index] = value; |
| }, |
| $isJSIndexable: 1, |
| $isList: 1, |
| $isEfficientLengthIterable: 1 |
| }, |
| JSUnmodifiableArray: { |
| "^": "JSArray;" |
| }, |
| ArrayIterator: { |
| "^": "Object;_iterable,_length,_index,__interceptors$_current", |
| get$current: function() { |
| return this.__interceptors$_current; |
| }, |
| moveNext$0: function() { |
| var t1, $length, t2; |
| t1 = this._iterable; |
| $length = t1.length; |
| if (this._length !== $length) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| t2 = this._index; |
| if (t2 >= $length) { |
| this.__interceptors$_current = null; |
| return false; |
| } |
| this.__interceptors$_current = t1[t2]; |
| this._index = t2 + 1; |
| return true; |
| } |
| }, |
| JSNumber: { |
| "^": "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(new 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; |
| }, |
| $add: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(P.ArgumentError$(other)); |
| return receiver + other; |
| }, |
| _tdivFast$1: function(receiver, other) { |
| return (receiver | 0) === receiver ? receiver / other | 0 : this.toInt$0(receiver / other); |
| }, |
| _shrOtherPositive$1: function(receiver, other) { |
| var t1; |
| if (receiver > 0) |
| t1 = other > 31 ? 0 : receiver >>> other; |
| else { |
| t1 = other > 31 ? 31 : other; |
| t1 = receiver >> t1 >>> 0; |
| } |
| return t1; |
| }, |
| $lt: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(P.ArgumentError$(other)); |
| return receiver < other; |
| }, |
| $isnum: 1 |
| }, |
| JSInt: { |
| "^": "JSNumber;", |
| $isnum: 1, |
| $is$int: 1 |
| }, |
| JSDouble: { |
| "^": "JSNumber;", |
| $isnum: 1 |
| }, |
| JSString: { |
| "^": "Interceptor;", |
| codeUnitAt$1: function(receiver, index) { |
| if (index >= receiver.length) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| return receiver.charCodeAt(index); |
| }, |
| $add: function(receiver, other) { |
| if (typeof other !== "string") |
| throw H.wrapException(P.ArgumentError$(other)); |
| return receiver + other; |
| }, |
| substring$2: function(receiver, startIndex, endIndex) { |
| H.checkInt(startIndex); |
| if (endIndex == null) |
| endIndex = receiver.length; |
| H.checkInt(endIndex); |
| if (startIndex < 0) |
| throw H.wrapException(P.RangeError$value(startIndex, null, null)); |
| if (typeof endIndex !== "number") |
| return H.iae(endIndex); |
| if (startIndex > endIndex) |
| throw H.wrapException(P.RangeError$value(startIndex, null, null)); |
| if (endIndex > receiver.length) |
| throw H.wrapException(P.RangeError$value(endIndex, null, null)); |
| return receiver.substring(startIndex, endIndex); |
| }, |
| substring$1: function($receiver, startIndex) { |
| return this.substring$2($receiver, startIndex, null); |
| }, |
| 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(P.ArgumentError$(index)); |
| if (index >= receiver.length || index < 0) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| return receiver[index]; |
| }, |
| $isJSIndexable: 1, |
| $isString: 1 |
| } |
| }], ["_isolate_helper", "dart:_isolate_helper",, H, { |
| "^": "", |
| _callInIsolate: function(isolate, $function) { |
| var result = isolate.eval$1($function); |
| if (!init.globalState.currentContext._isExecutingEvent) |
| init.globalState.topEventLoop.run$0(); |
| return result; |
| }, |
| leaveJsAsync: function() { |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| }, |
| startRootIsolate: function(entry, args) { |
| var t1, t2, t3, t4, t5, rootContext; |
| t1 = {}; |
| t1._captured_args_0 = args; |
| args = args; |
| t1._captured_args_0 = args; |
| if (args == null) { |
| args = []; |
| t1._captured_args_0 = args; |
| t2 = args; |
| } else |
| t2 = args; |
| if (!J.getInterceptor(t2).$isList) |
| throw H.wrapException(P.ArgumentError$("Arguments to main must be a List: " + H.S(t2))); |
| t2 = new H._Manager(0, 0, 1, null, null, null, null, null, null, null, null, null, entry); |
| t2._nativeDetectEnvironment$0(); |
| t2.topEventLoop = new H._EventLoop(P.ListQueue$(null, H._IsolateEvent), 0); |
| t2.isolates = P.LinkedHashMap_LinkedHashMap(null, null, null, P.$int, H._IsolateContext); |
| t2.managers = P.LinkedHashMap_LinkedHashMap(null, null, null, P.$int, null); |
| if (t2.isWorker === true) { |
| t2.mainManager = new H._MainManagerStub(); |
| t2._nativeInitWorkerMessageHandler$0(); |
| } |
| init.globalState = t2; |
| if (init.globalState.isWorker === true) |
| return; |
| t2 = init.globalState.nextIsolateId++; |
| t3 = P.LinkedHashMap_LinkedHashMap(null, null, null, P.$int, H.RawReceivePortImpl); |
| t4 = P.LinkedHashSet_LinkedHashSet(null, null, null, P.$int); |
| t5 = new H.RawReceivePortImpl(0, null, false); |
| rootContext = new H._IsolateContext(t2, t3, t4, init.createNewIsolate(), t5, new H.CapabilityImpl(H.random64()), new H.CapabilityImpl(H.random64()), false, false, [], P.LinkedHashSet_LinkedHashSet(null, null, null, null), null, null, false, true, P.LinkedHashSet_LinkedHashSet(null, null, null, null)); |
| t4.add$1(0, 0); |
| rootContext._addRegistration$2(0, t5); |
| init.globalState.rootContext = rootContext; |
| init.globalState.currentContext = rootContext; |
| t2 = H.getDynamicRuntimeType(); |
| t3 = H.buildFunctionType(t2, [t2])._isTest$1(entry); |
| if (t3) |
| rootContext.eval$1(new H.startRootIsolate_closure(t1, entry)); |
| else { |
| t2 = H.buildFunctionType(t2, [t2, t2])._isTest$1(entry); |
| if (t2) |
| rootContext.eval$1(new H.startRootIsolate_closure0(t1, entry)); |
| else |
| rootContext.eval$1(entry); |
| } |
| init.globalState.topEventLoop.run$0(); |
| }, |
| IsolateNatives_computeThisScript: function() { |
| var currentScript = init.currentScript; |
| if (currentScript != null) |
| return String(currentScript.src); |
| if (init.globalState.isWorker === true) |
| return H.IsolateNatives_computeThisScriptFromTrace(); |
| return; |
| }, |
| IsolateNatives_computeThisScriptFromTrace: 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(new 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(new P.UnsupportedError("Cannot extract URI from \"" + H.S(stack) + "\"")); |
| }, |
| IsolateNatives__processWorkerMessage: function(sender, e) { |
| var msg, t1, functionName, entryPoint, args, message, isSpawnUri, startPaused, replyTo, t2, t3, t4, context; |
| msg = new H._Deserializer(true, []).deserialize$1(e.data); |
| t1 = J.getInterceptor$as(msg); |
| switch (t1.$index(msg, "command")) { |
| case "start": |
| init.globalState.currentManagerId = t1.$index(msg, "id"); |
| functionName = t1.$index(msg, "functionName"); |
| entryPoint = functionName == null ? init.globalState.entry : H.IsolateNatives__getJSFunctionFromName(functionName); |
| args = t1.$index(msg, "args"); |
| message = new H._Deserializer(true, []).deserialize$1(t1.$index(msg, "msg")); |
| isSpawnUri = t1.$index(msg, "isSpawnUri"); |
| startPaused = t1.$index(msg, "startPaused"); |
| replyTo = new H._Deserializer(true, []).deserialize$1(t1.$index(msg, "replyTo")); |
| t1 = init.globalState.nextIsolateId++; |
| t2 = P.LinkedHashMap_LinkedHashMap(null, null, null, P.$int, H.RawReceivePortImpl); |
| t3 = P.LinkedHashSet_LinkedHashSet(null, null, null, P.$int); |
| t4 = new H.RawReceivePortImpl(0, null, false); |
| context = new H._IsolateContext(t1, t2, t3, init.createNewIsolate(), t4, new H.CapabilityImpl(H.random64()), new H.CapabilityImpl(H.random64()), false, false, [], P.LinkedHashSet_LinkedHashSet(null, null, null, null), null, null, false, true, P.LinkedHashSet_LinkedHashSet(null, null, null, null)); |
| t3.add$1(0, 0); |
| context._addRegistration$2(0, t4); |
| init.globalState.topEventLoop.events._add$1(new H._IsolateEvent(context, new H.IsolateNatives__processWorkerMessage_closure(entryPoint, args, message, isSpawnUri, startPaused, replyTo), "worker-start")); |
| init.globalState.currentContext = context; |
| init.globalState.topEventLoop.run$0(); |
| break; |
| case "spawn-worker": |
| break; |
| case "message": |
| if (t1.$index(msg, "port") != null) |
| t1.$index(msg, "port").send$1(t1.$index(msg, "msg")); |
| init.globalState.topEventLoop.run$0(); |
| break; |
| case "close": |
| init.globalState.managers.remove$1(0, $.get$IsolateNatives_workerIds().$index(0, sender)); |
| sender.terminate(); |
| init.globalState.topEventLoop.run$0(); |
| break; |
| case "log": |
| H.IsolateNatives__log(t1.$index(msg, "msg")); |
| break; |
| case "print": |
| if (init.globalState.isWorker === true) { |
| t1 = init.globalState.mainManager; |
| t2 = P.LinkedHashMap__makeLiteral(["command", "print", "msg", msg]); |
| t2 = new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t2); |
| t1.toString; |
| self.postMessage(t2); |
| } else |
| P.print(t1.$index(msg, "msg")); |
| break; |
| case "error": |
| throw H.wrapException(t1.$index(msg, "msg")); |
| } |
| }, |
| IsolateNatives__log: function(msg) { |
| var trace, t1, t2, exception; |
| if (init.globalState.isWorker === true) { |
| t1 = init.globalState.mainManager; |
| t2 = P.LinkedHashMap__makeLiteral(["command", "log", "msg", msg]); |
| t2 = new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t2); |
| t1.toString; |
| self.postMessage(t2); |
| } else |
| try { |
| self.console.log(msg); |
| } catch (exception) { |
| H.unwrapException(exception); |
| trace = H.getTraceFromException(exception); |
| throw H.wrapException(P.Exception_Exception(trace)); |
| } |
| }, |
| IsolateNatives__getJSFunctionFromName: function(functionName) { |
| return init.globalFunctions[functionName](); |
| }, |
| IsolateNatives__startIsolate: function(topLevel, args, message, isSpawnUri, startPaused, replyTo) { |
| var context, t1, t2, t3; |
| context = init.globalState.currentContext; |
| t1 = context.id; |
| $.Primitives_mirrorFunctionCacheName = $.Primitives_mirrorFunctionCacheName + ("_" + t1); |
| $.Primitives_mirrorInvokeCacheName = $.Primitives_mirrorInvokeCacheName + ("_" + t1); |
| t1 = context.controlPort; |
| t2 = init.globalState.currentContext.id; |
| t3 = context.pauseCapability; |
| replyTo.send$1(["spawned", new H._NativeJsSendPort(t1, t2), t3, context.terminateCapability]); |
| t2 = new H.IsolateNatives__startIsolate_runStartFunction(topLevel, args, message, isSpawnUri, context); |
| if (startPaused === true) { |
| context.addPause$2(t3, t3); |
| init.globalState.topEventLoop.events._add$1(new H._IsolateEvent(context, t2, "start isolate")); |
| } else |
| t2.call$0(); |
| }, |
| _clone: function(message) { |
| return new H._Deserializer(true, []).deserialize$1(new H._Serializer(false, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(message)); |
| }, |
| startRootIsolate_closure: { |
| "^": "Closure:0;__isolate_helper$_box_0,_captured_entry_1", |
| call$0: function() { |
| this._captured_entry_1.call$1(this.__isolate_helper$_box_0._captured_args_0); |
| } |
| }, |
| startRootIsolate_closure0: { |
| "^": "Closure:0;__isolate_helper$_box_0,_captured_entry_2", |
| call$0: function() { |
| this._captured_entry_2.call$2(this.__isolate_helper$_box_0._captured_args_0, null); |
| } |
| }, |
| _Manager: { |
| "^": "Object;nextIsolateId,currentManagerId,nextManagerId,currentContext,rootContext,topEventLoop,fromCommandLine,isWorker,supportsWorkers,isolates,mainManager,managers,entry", |
| _nativeDetectEnvironment$0: function() { |
| var t1, t2, t3; |
| t1 = self.window == null; |
| t2 = self.Worker; |
| t3 = t1 && !!self.postMessage; |
| this.isWorker = t3; |
| if (!t3) |
| t2 = t2 != null && $.get$IsolateNatives_thisScript() != null; |
| else |
| t2 = true; |
| this.supportsWorkers = t2; |
| this.fromCommandLine = t1 && !t3; |
| }, |
| _nativeInitWorkerMessageHandler$0: function() { |
| self.onmessage = function(f, a) { |
| return function(e) { |
| f(a, e); |
| }; |
| }(H.IsolateNatives__processWorkerMessage, this.mainManager); |
| self.dartPrint = self.dartPrint || function(serialize) { |
| return function(object) { |
| if (self.console && self.console.log) |
| self.console.log(object); |
| else |
| self.postMessage(serialize(object)); |
| }; |
| }(H._Manager__serializePrintMessage); |
| }, |
| static: {_Manager__serializePrintMessage: function(object) { |
| var t1 = P.LinkedHashMap__makeLiteral(["command", "print", "msg", object]); |
| return new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t1); |
| }} |
| }, |
| _IsolateContext: { |
| "^": "Object;id,ports,weakPorts,isolateStatics<,controlPort<,pauseCapability,terminateCapability,initialized,isPaused,delayedEvents,pauseTokens,doneHandlers,_scheduledControlEvents,_isExecutingEvent,errorsAreFatal,errorPorts", |
| addPause$2: function(authentification, resume) { |
| if (!this.pauseCapability.$eq(0, authentification)) |
| return; |
| if (this.pauseTokens.add$1(0, resume) && !this.isPaused) |
| this.isPaused = true; |
| this._updateGlobalState$0(); |
| }, |
| removePause$1: function(resume) { |
| var t1, t2, $event, t3, t4, t5; |
| if (!this.isPaused) |
| return; |
| t1 = this.pauseTokens; |
| t1.remove$1(0, resume); |
| if (t1._collection$_length === 0) { |
| for (t1 = this.delayedEvents; t2 = t1.length, t2 !== 0;) { |
| if (0 >= t2) |
| return H.ioore(t1, 0); |
| $event = t1.pop(); |
| t2 = init.globalState.topEventLoop.events; |
| t3 = t2._head; |
| t4 = t2._table; |
| t5 = t4.length; |
| t3 = (t3 - 1 & t5 - 1) >>> 0; |
| t2._head = t3; |
| if (t3 < 0 || t3 >= t5) |
| return H.ioore(t4, t3); |
| t4[t3] = $event; |
| if (t3 === t2._tail) |
| t2._grow$0(); |
| ++t2._modificationCount; |
| } |
| this.isPaused = false; |
| } |
| this._updateGlobalState$0(); |
| }, |
| addDoneListener$2: function(responsePort, response) { |
| var t1, i, t2; |
| if (this.doneHandlers == null) |
| this.doneHandlers = []; |
| for (t1 = J.getInterceptor(responsePort), i = 0; t2 = this.doneHandlers, i < t2.length; i += 2) |
| if (t1.$eq(responsePort, t2[i])) { |
| t1 = this.doneHandlers; |
| t2 = i + 1; |
| if (t2 >= t1.length) |
| return H.ioore(t1, t2); |
| t1[t2] = response; |
| return; |
| } |
| t2.push(responsePort); |
| this.doneHandlers.push(response); |
| }, |
| removeDoneListener$1: function(responsePort) { |
| var t1, i, t2; |
| if (this.doneHandlers == null) |
| return; |
| for (t1 = J.getInterceptor(responsePort), i = 0; t2 = this.doneHandlers, i < t2.length; i += 2) |
| if (t1.$eq(responsePort, t2[i])) { |
| t1 = this.doneHandlers; |
| t2 = i + 2; |
| t1.toString; |
| if (typeof t1 !== "object" || t1 === null || !!t1.fixed$length) |
| H.throwExpression(new P.UnsupportedError("removeRange")); |
| P.RangeError_checkValidRange(i, t2, t1.length, null, null, null); |
| t1.splice(i, t2 - i); |
| return; |
| } |
| }, |
| setErrorsFatal$2: function(authentification, errorsAreFatal) { |
| if (!this.terminateCapability.$eq(0, authentification)) |
| return; |
| this.errorsAreFatal = errorsAreFatal; |
| }, |
| handlePing$3: function(responsePort, pingType, response) { |
| var t1 = J.getInterceptor(pingType); |
| if (!t1.$eq(pingType, 0)) |
| t1 = t1.$eq(pingType, 1) && !this._isExecutingEvent; |
| else |
| t1 = true; |
| if (t1) { |
| responsePort.send$1(response); |
| return; |
| } |
| t1 = this._scheduledControlEvents; |
| if (t1 == null) { |
| t1 = P.ListQueue$(null, null); |
| this._scheduledControlEvents = t1; |
| } |
| t1._add$1(new H._IsolateContext_handlePing_respond(responsePort, response)); |
| }, |
| handleKill$2: function(authentification, priority) { |
| var t1; |
| if (!this.terminateCapability.$eq(0, authentification)) |
| return; |
| t1 = J.getInterceptor(priority); |
| if (!t1.$eq(priority, 0)) |
| t1 = t1.$eq(priority, 1) && !this._isExecutingEvent; |
| else |
| t1 = true; |
| if (t1) { |
| this.kill$0(); |
| return; |
| } |
| t1 = this._scheduledControlEvents; |
| if (t1 == null) { |
| t1 = P.ListQueue$(null, null); |
| this._scheduledControlEvents = t1; |
| } |
| t1._add$1(this.get$kill()); |
| }, |
| handleUncaughtError$2: function(error, stackTrace) { |
| var t1, message, t2; |
| t1 = this.errorPorts; |
| if (t1._collection$_length === 0) { |
| if (this.errorsAreFatal === true && this === init.globalState.rootContext) |
| return; |
| if (self.console && self.console.error) |
| self.console.error(error, stackTrace); |
| else { |
| P.print(error); |
| if (stackTrace != null) |
| P.print(stackTrace); |
| } |
| return; |
| } |
| message = Array(2); |
| message.fixed$length = Array; |
| message[0] = J.toString$0(error); |
| message[1] = stackTrace == null ? null : J.toString$0(stackTrace); |
| for (t2 = new P.LinkedHashSetIterator(t1, t1._collection$_modifications, null, null), t2._cell = t1._collection$_first; t2.moveNext$0();) |
| t2._collection$_current.send$1(message); |
| }, |
| eval$1: function(code) { |
| var old, result, oldIsExecutingEvent, e, s, exception, t1; |
| old = init.globalState.currentContext; |
| init.globalState.currentContext = this; |
| $ = this.isolateStatics; |
| result = null; |
| oldIsExecutingEvent = this._isExecutingEvent; |
| this._isExecutingEvent = true; |
| try { |
| result = code.call$0(); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| this.handleUncaughtError$2(e, s); |
| if (this.errorsAreFatal === true) { |
| this.kill$0(); |
| if (this === init.globalState.rootContext) |
| throw exception; |
| } |
| } finally { |
| this._isExecutingEvent = oldIsExecutingEvent; |
| init.globalState.currentContext = old; |
| if (old != null) |
| $ = old.get$isolateStatics(); |
| if (this._scheduledControlEvents != null) |
| for (; t1 = this._scheduledControlEvents, !t1.get$isEmpty(t1);) |
| this._scheduledControlEvents.removeFirst$0().call$0(); |
| } |
| return result; |
| }, |
| lookup$1: function(portId) { |
| return this.ports.$index(0, portId); |
| }, |
| _addRegistration$2: function(portId, port) { |
| var t1 = this.ports; |
| if (t1.containsKey$1(portId)) |
| throw H.wrapException(P.Exception_Exception("Registry: ports must be registered only once.")); |
| t1.$indexSet(0, portId, port); |
| }, |
| _updateGlobalState$0: function() { |
| if (this.ports.__js_helper$_length - this.weakPorts._collection$_length > 0 || this.isPaused || !this.initialized) |
| init.globalState.isolates.$indexSet(0, this.id, this); |
| else |
| this.kill$0(); |
| }, |
| kill$0: [function() { |
| var t1, t2, i, responsePort, t3; |
| t1 = this._scheduledControlEvents; |
| if (t1 != null) |
| t1.clear$0(0); |
| for (t1 = this.ports, t2 = t1.get$values(), t2 = H.setRuntimeTypeInfo(new H.MappedIterator(null, J.get$iterator$a(t2.__internal$_iterable), t2._f), [H.getTypeArgumentByIndex(t2, 0), H.getTypeArgumentByIndex(t2, 1)]); t2.moveNext$0();) |
| t2.__internal$_current._close$0(); |
| if (t1.__js_helper$_length > 0) { |
| t1._last = null; |
| t1._first = null; |
| t1._rest = null; |
| t1._nums = null; |
| t1._strings = null; |
| t1.__js_helper$_length = 0; |
| t1._modifications = t1._modifications + 1 & 67108863; |
| } |
| this.weakPorts.clear$0(0); |
| init.globalState.isolates.remove$1(0, this.id); |
| this.errorPorts.clear$0(0); |
| if (this.doneHandlers != null) { |
| for (i = 0; t1 = this.doneHandlers, t2 = t1.length, i < t2; i += 2) { |
| responsePort = t1[i]; |
| t3 = i + 1; |
| if (t3 >= t2) |
| return H.ioore(t1, t3); |
| responsePort.send$1(t1[t3]); |
| } |
| this.doneHandlers = null; |
| } |
| }, "call$0", "get$kill", 0, 0, 1] |
| }, |
| _IsolateContext_handlePing_respond: { |
| "^": "Closure:1;_captured_responsePort_0,_captured_response_1", |
| call$0: function() { |
| this._captured_responsePort_0.send$1(this._captured_response_1); |
| } |
| }, |
| _EventLoop: { |
| "^": "Object;events,_activeJsAsyncCount", |
| dequeue$0: function() { |
| var t1 = this.events; |
| if (t1._head === t1._tail) |
| return; |
| return t1.removeFirst$0(); |
| }, |
| runIteration$0: function() { |
| var $event, t1, t2; |
| $event = this.dequeue$0(); |
| if ($event == null) { |
| if (init.globalState.rootContext != null && init.globalState.isolates.containsKey$1(init.globalState.rootContext.id) && init.globalState.fromCommandLine === true && init.globalState.rootContext.ports.__js_helper$_length === 0) |
| H.throwExpression(P.Exception_Exception("Program exited with open ReceivePorts.")); |
| t1 = init.globalState; |
| if (t1.isWorker === true && t1.isolates.__js_helper$_length === 0 && t1.topEventLoop._activeJsAsyncCount === 0) { |
| t1 = t1.mainManager; |
| t2 = P.LinkedHashMap__makeLiteral(["command", "close"]); |
| t2 = new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t2); |
| t1.toString; |
| self.postMessage(t2); |
| } |
| return false; |
| } |
| $event.process$0(); |
| return true; |
| }, |
| _runHelper$0: function() { |
| if (self.window != null) |
| new H._EventLoop__runHelper_next(this).call$0(); |
| else |
| for (; this.runIteration$0();) |
| ; |
| }, |
| run$0: function() { |
| var e, trace, exception, t1, t2; |
| if (init.globalState.isWorker !== true) |
| this._runHelper$0(); |
| else |
| try { |
| this._runHelper$0(); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| trace = H.getTraceFromException(exception); |
| t1 = init.globalState.mainManager; |
| t2 = P.LinkedHashMap__makeLiteral(["command", "error", "msg", H.S(e) + "\n" + H.S(trace)]); |
| t2 = new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t2); |
| t1.toString; |
| self.postMessage(t2); |
| } |
| } |
| }, |
| _EventLoop__runHelper_next: { |
| "^": "Closure:1;_captured_this_0", |
| call$0: function() { |
| if (!this._captured_this_0.runIteration$0()) |
| return; |
| P.Timer_Timer(C.Duration_0, this); |
| } |
| }, |
| _IsolateEvent: { |
| "^": "Object;isolate,fn,message", |
| process$0: function() { |
| var t1 = this.isolate; |
| if (t1.isPaused) { |
| t1.delayedEvents.push(this); |
| return; |
| } |
| t1.eval$1(this.fn); |
| } |
| }, |
| _MainManagerStub: { |
| "^": "Object;" |
| }, |
| IsolateNatives__processWorkerMessage_closure: { |
| "^": "Closure:0;_captured_entryPoint_0,_captured_args_1,_captured_message_2,_captured_isSpawnUri_3,_captured_startPaused_4,_captured_replyTo_5", |
| call$0: function() { |
| H.IsolateNatives__startIsolate(this._captured_entryPoint_0, this._captured_args_1, this._captured_message_2, this._captured_isSpawnUri_3, this._captured_startPaused_4, this._captured_replyTo_5); |
| } |
| }, |
| IsolateNatives__startIsolate_runStartFunction: { |
| "^": "Closure:1;_captured_topLevel_0,_captured_args_1,_captured_message_2,_captured_isSpawnUri_3,_captured_context_4", |
| call$0: function() { |
| var t1, t2, t3; |
| this._captured_context_4.initialized = true; |
| if (this._captured_isSpawnUri_3 !== true) |
| this._captured_topLevel_0.call$1(this._captured_message_2); |
| else { |
| t1 = this._captured_topLevel_0; |
| t2 = H.getDynamicRuntimeType(); |
| t3 = H.buildFunctionType(t2, [t2, t2])._isTest$1(t1); |
| if (t3) |
| t1.call$2(this._captured_args_1, this._captured_message_2); |
| else { |
| t2 = H.buildFunctionType(t2, [t2])._isTest$1(t1); |
| if (t2) |
| t1.call$1(this._captured_args_1); |
| else |
| t1.call$0(); |
| } |
| } |
| } |
| }, |
| _BaseSendPort: { |
| "^": "Object;" |
| }, |
| _NativeJsSendPort: { |
| "^": "_BaseSendPort;_receivePort,_isolateId", |
| send$1: function(message) { |
| var isolate, t1, msg, t2; |
| isolate = init.globalState.isolates.$index(0, this._isolateId); |
| if (isolate == null) |
| return; |
| t1 = this._receivePort; |
| if (t1.get$_isClosed()) |
| return; |
| msg = H._clone(message); |
| if (isolate.get$controlPort() === t1) { |
| t1 = J.getInterceptor$as(msg); |
| switch (t1.$index(msg, 0)) { |
| case "pause": |
| isolate.addPause$2(t1.$index(msg, 1), t1.$index(msg, 2)); |
| break; |
| case "resume": |
| isolate.removePause$1(t1.$index(msg, 1)); |
| break; |
| case "add-ondone": |
| isolate.addDoneListener$2(t1.$index(msg, 1), t1.$index(msg, 2)); |
| break; |
| case "remove-ondone": |
| isolate.removeDoneListener$1(t1.$index(msg, 1)); |
| break; |
| case "set-errors-fatal": |
| isolate.setErrorsFatal$2(t1.$index(msg, 1), t1.$index(msg, 2)); |
| break; |
| case "ping": |
| isolate.handlePing$3(t1.$index(msg, 1), t1.$index(msg, 2), t1.$index(msg, 3)); |
| break; |
| case "kill": |
| isolate.handleKill$2(t1.$index(msg, 1), t1.$index(msg, 2)); |
| break; |
| case "getErrors": |
| t1 = t1.$index(msg, 1); |
| isolate.errorPorts.add$1(0, t1); |
| break; |
| case "stopErrors": |
| t1 = t1.$index(msg, 1); |
| isolate.errorPorts.remove$1(0, t1); |
| break; |
| } |
| return; |
| } |
| t1 = init.globalState.topEventLoop; |
| t2 = "receive " + H.S(message); |
| t1.events._add$1(new H._IsolateEvent(isolate, new H._NativeJsSendPort_send_closure(this, msg), t2)); |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| return other instanceof H._NativeJsSendPort && J.$eq(this._receivePort, other._receivePort); |
| }, |
| get$hashCode: function(_) { |
| return this._receivePort.get$_id(); |
| } |
| }, |
| _NativeJsSendPort_send_closure: { |
| "^": "Closure:0;_captured_this_0,_captured_msg_1", |
| call$0: function() { |
| var t1 = this._captured_this_0._receivePort; |
| if (!t1.get$_isClosed()) |
| t1.__isolate_helper$_add$1(this._captured_msg_1); |
| } |
| }, |
| _WorkerSendPort: { |
| "^": "_BaseSendPort;_workerId,_receivePortId,_isolateId", |
| send$1: function(message) { |
| var t1, workerMessage, manager; |
| t1 = P.LinkedHashMap__makeLiteral(["command", "message", "port", this, "msg", message]); |
| workerMessage = new H._Serializer(true, P.LinkedHashMap_LinkedHashMap$identity(null, P.$int)).serialize$1(t1); |
| if (init.globalState.isWorker === true) { |
| init.globalState.mainManager.toString; |
| self.postMessage(workerMessage); |
| } else { |
| manager = init.globalState.managers.$index(0, this._workerId); |
| if (manager != null) |
| manager.postMessage(workerMessage); |
| } |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| return other instanceof H._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") |
| return t1.$shl(); |
| t2 = this._isolateId; |
| if (typeof t2 !== "number") |
| return t2.$shl(); |
| t3 = this._receivePortId; |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| return (t1 << 16 ^ t2 << 8 ^ t3) >>> 0; |
| } |
| }, |
| RawReceivePortImpl: { |
| "^": "Object;_id<,_handler,_isClosed<", |
| _close$0: function() { |
| this._isClosed = true; |
| this._handler = null; |
| }, |
| __isolate_helper$_add$1: function(dataEvent) { |
| if (this._isClosed) |
| return; |
| this._handler$1(dataEvent); |
| }, |
| _handler$1: function(arg0) { |
| return this._handler.call$1(arg0); |
| }, |
| $isRawReceivePort: 1 |
| }, |
| TimerImpl: { |
| "^": "Object;_once,_inEventLoop,_handle", |
| TimerImpl$2: function(milliseconds, callback) { |
| var t1, t2; |
| if (milliseconds === 0) |
| t1 = self.setTimeout == null || init.globalState.isWorker === true; |
| else |
| t1 = false; |
| if (t1) { |
| this._handle = 1; |
| t1 = init.globalState.topEventLoop; |
| t2 = init.globalState.currentContext; |
| t1.events._add$1(new H._IsolateEvent(t2, new H.TimerImpl_internalCallback(this, callback), "timer")); |
| this._inEventLoop = true; |
| } else if (self.setTimeout != null) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| this._handle = self.setTimeout(H.convertDartClosureToJS(new H.TimerImpl_internalCallback0(this, callback), 0), milliseconds); |
| } else |
| throw H.wrapException(new 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:1;_captured_this_0,_captured_callback_1", |
| call$0: function() { |
| this._captured_this_0._handle = null; |
| this._captured_callback_1.call$0(); |
| } |
| }, |
| TimerImpl_internalCallback0: { |
| "^": "Closure:1;_captured_this_2,_captured_callback_3", |
| call$0: function() { |
| this._captured_this_2._handle = null; |
| H.leaveJsAsync(); |
| this._captured_callback_3.call$0(); |
| } |
| }, |
| CapabilityImpl: { |
| "^": "Object;_id<", |
| get$hashCode: function(_) { |
| var hash = this._id; |
| hash = C.JSInt_methods._shrOtherPositive$1(hash, 0) ^ C.JSInt_methods._tdivFast$1(hash, 4294967296); |
| hash = (~hash >>> 0) + (hash << 15 >>> 0) & 4294967295; |
| hash = ((hash ^ hash >>> 12) >>> 0) * 5 & 4294967295; |
| hash = ((hash ^ hash >>> 4) >>> 0) * 2057 & 4294967295; |
| return (hash ^ hash >>> 16) >>> 0; |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (other === this) |
| return true; |
| if (other instanceof H.CapabilityImpl) |
| return this._id === other._id; |
| return false; |
| } |
| }, |
| _Serializer: { |
| "^": "Object;_serializeSendPorts,serializedObjectIds", |
| serialize$1: [function(x) { |
| var t1, serializationId, serializeTearOff, t2, $name; |
| if (x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean") |
| return x; |
| t1 = this.serializedObjectIds; |
| serializationId = t1.$index(0, x); |
| if (serializationId != null) |
| return ["ref", serializationId]; |
| t1.$indexSet(0, x, t1.__js_helper$_length); |
| t1 = J.getInterceptor(x); |
| if (!!t1.$isJSIndexable) |
| return this.serializeJSIndexable$1(x); |
| if (!!t1.$isInternalMap) { |
| serializeTearOff = this.get$serialize(); |
| t1 = x.get$keys(); |
| t1 = H.MappedIterable_MappedIterable(t1, serializeTearOff, H.getRuntimeTypeArgument(t1, "Iterable", 0), null); |
| t1 = P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "Iterable", 0)); |
| t2 = x.get$values(); |
| t2 = H.MappedIterable_MappedIterable(t2, serializeTearOff, H.getRuntimeTypeArgument(t2, "Iterable", 0), null); |
| return ["map", t1, P.List_List$from(t2, true, H.getRuntimeTypeArgument(t2, "Iterable", 0))]; |
| } |
| if (!!t1.$isJSObject) |
| return this.serializeJSObject$1(x); |
| if (!!t1.$isInterceptor) |
| this.unsupported$1(x); |
| if (!!t1.$isRawReceivePort) |
| this.unsupported$2(x, "RawReceivePorts can't be transmitted:"); |
| if (!!t1.$is_NativeJsSendPort) |
| return this.serializeJsSendPort$1(x); |
| if (!!t1.$is_WorkerSendPort) |
| return this.serializeWorkerSendPort$1(x); |
| if (!!t1.$isClosure) { |
| $name = x.$name; |
| if ($name == null) |
| this.unsupported$2(x, "Closures can't be transmitted:"); |
| return ["function", $name]; |
| } |
| return ["dart", init.classIdExtractor(x), this.serializeArrayInPlace$1(init.classFieldsExtractor(x))]; |
| }, "call$1", "get$serialize", 2, 0, 2], |
| unsupported$2: function(x, message) { |
| throw H.wrapException(new P.UnsupportedError(H.S(message == null ? "Can't transmit:" : message) + " " + H.S(x))); |
| }, |
| unsupported$1: function(x) { |
| return this.unsupported$2(x, null); |
| }, |
| serializeJSIndexable$1: function(indexable) { |
| var serialized = this.serializeArray$1(indexable); |
| if (!!indexable.fixed$length) |
| return ["fixed", serialized]; |
| if (!indexable.fixed$length) |
| return ["extendable", serialized]; |
| if (!indexable.immutable$list) |
| return ["mutable", serialized]; |
| if (indexable.constructor === Array) |
| return ["const", serialized]; |
| this.unsupported$2(indexable, "Can't serialize indexable: "); |
| }, |
| serializeArray$1: function(x) { |
| var serialized, i, t1; |
| serialized = []; |
| C.JSArray_methods.set$length(serialized, x.length); |
| for (i = 0; i < x.length; ++i) { |
| t1 = this.serialize$1(x[i]); |
| if (i >= serialized.length) |
| return H.ioore(serialized, i); |
| serialized[i] = t1; |
| } |
| return serialized; |
| }, |
| serializeArrayInPlace$1: function(x) { |
| var i; |
| for (i = 0; i < x.length; ++i) |
| C.JSArray_methods.$indexSet(x, i, this.serialize$1(x[i])); |
| return x; |
| }, |
| serializeJSObject$1: function(x) { |
| var keys, values, i, t1; |
| if (!!x.constructor && x.constructor !== Object) |
| this.unsupported$2(x, "Only plain JS Objects are supported:"); |
| keys = Object.keys(x); |
| values = []; |
| C.JSArray_methods.set$length(values, keys.length); |
| for (i = 0; i < keys.length; ++i) { |
| t1 = this.serialize$1(x[keys[i]]); |
| if (i >= values.length) |
| return H.ioore(values, i); |
| values[i] = t1; |
| } |
| return ["js-object", keys, values]; |
| }, |
| serializeWorkerSendPort$1: function(x) { |
| if (this._serializeSendPorts) |
| return ["sendport", x._workerId, x._isolateId, x._receivePortId]; |
| return ["raw sendport", x]; |
| }, |
| serializeJsSendPort$1: function(x) { |
| if (this._serializeSendPorts) |
| return ["sendport", init.globalState.currentManagerId, x._isolateId, x._receivePort.get$_id()]; |
| return ["raw sendport", x]; |
| } |
| }, |
| _Deserializer: { |
| "^": "Object;_adjustSendPorts,deserializedObjects", |
| deserialize$1: [function(x) { |
| var serializationId, t1, result, classId, fields, emptyInstance; |
| if (x == null || typeof x === "string" || typeof x === "number" || typeof x === "boolean") |
| return x; |
| if (typeof x !== "object" || x === null || x.constructor !== Array) |
| throw H.wrapException(P.ArgumentError$("Bad serialized message: " + H.S(x))); |
| switch (C.JSArray_methods.get$first(x)) { |
| case "ref": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| serializationId = x[1]; |
| t1 = this.deserializedObjects; |
| if (serializationId >>> 0 !== serializationId || serializationId >= t1.length) |
| return H.ioore(t1, serializationId); |
| return t1[serializationId]; |
| case "buffer": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| return result; |
| case "typed": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| return result; |
| case "fixed": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| t1 = this.deserializeArrayInPlace$1(result); |
| t1.$builtinTypeInfo = [null]; |
| t1.fixed$length = Array; |
| return t1; |
| case "extendable": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| t1 = this.deserializeArrayInPlace$1(result); |
| t1.$builtinTypeInfo = [null]; |
| return t1; |
| case "mutable": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| return this.deserializeArrayInPlace$1(result); |
| case "const": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| t1 = this.deserializeArrayInPlace$1(result); |
| t1.$builtinTypeInfo = [null]; |
| t1.fixed$length = Array; |
| return t1; |
| case "map": |
| return this.deserializeMap$1(x); |
| case "sendport": |
| return this.deserializeSendPort$1(x); |
| case "raw sendport": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = x[1]; |
| this.deserializedObjects.push(result); |
| return result; |
| case "js-object": |
| return this.deserializeJSObject$1(x); |
| case "function": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| result = init.globalFunctions[x[1]](); |
| this.deserializedObjects.push(result); |
| return result; |
| case "dart": |
| t1 = x.length; |
| if (1 >= t1) |
| return H.ioore(x, 1); |
| classId = x[1]; |
| if (2 >= t1) |
| return H.ioore(x, 2); |
| fields = x[2]; |
| emptyInstance = init.instanceFromClassId(classId); |
| this.deserializedObjects.push(emptyInstance); |
| this.deserializeArrayInPlace$1(fields); |
| return init.initializeEmptyInstance(classId, emptyInstance, fields); |
| default: |
| throw H.wrapException("couldn't deserialize: " + H.S(x)); |
| } |
| }, "call$1", "get$deserialize", 2, 0, 2], |
| deserializeArrayInPlace$1: function(x) { |
| var t1, i, t2; |
| t1 = J.getInterceptor$as(x); |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(x); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| t1.$indexSet(x, i, this.deserialize$1(t1.$index(x, i))); |
| ++i; |
| } |
| return x; |
| }, |
| deserializeMap$1: function(x) { |
| var t1, keys, values, result, t2, i; |
| t1 = x.length; |
| if (1 >= t1) |
| return H.ioore(x, 1); |
| keys = x[1]; |
| if (2 >= t1) |
| return H.ioore(x, 2); |
| values = x[2]; |
| result = P.LinkedHashMap__makeEmpty(); |
| this.deserializedObjects.push(result); |
| keys = J.map$1$a(keys, this.get$deserialize()).toList$0(0); |
| for (t1 = J.getInterceptor$as(keys), t2 = J.getInterceptor$as(values), i = 0; i < t1.get$length(keys); ++i) { |
| if (i >= keys.length) |
| return H.ioore(keys, i); |
| result.$indexSet(0, keys[i], this.deserialize$1(t2.$index(values, i))); |
| } |
| return result; |
| }, |
| deserializeSendPort$1: function(x) { |
| var t1, managerId, isolateId, receivePortId, isolate, receivePort, result; |
| t1 = x.length; |
| if (1 >= t1) |
| return H.ioore(x, 1); |
| managerId = x[1]; |
| if (2 >= t1) |
| return H.ioore(x, 2); |
| isolateId = x[2]; |
| if (3 >= t1) |
| return H.ioore(x, 3); |
| receivePortId = x[3]; |
| if (J.$eq(managerId, init.globalState.currentManagerId)) { |
| isolate = init.globalState.isolates.$index(0, isolateId); |
| if (isolate == null) |
| return; |
| receivePort = isolate.lookup$1(receivePortId); |
| if (receivePort == null) |
| return; |
| result = new H._NativeJsSendPort(receivePort, isolateId); |
| } else |
| result = new H._WorkerSendPort(managerId, receivePortId, isolateId); |
| this.deserializedObjects.push(result); |
| return result; |
| }, |
| deserializeJSObject$1: function(x) { |
| var t1, keys, values, o, t2, i, t3; |
| t1 = x.length; |
| if (1 >= t1) |
| return H.ioore(x, 1); |
| keys = x[1]; |
| if (2 >= t1) |
| return H.ioore(x, 2); |
| values = x[2]; |
| o = {}; |
| this.deserializedObjects.push(o); |
| t1 = J.getInterceptor$as(keys); |
| t2 = J.getInterceptor$as(values); |
| i = 0; |
| while (true) { |
| t3 = t1.get$length(keys); |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| if (!(i < t3)) |
| break; |
| o[t1.$index(keys, i)] = this.deserialize$1(t2.$index(values, i)); |
| ++i; |
| } |
| return o; |
| } |
| } |
| }], ["_js_helper", "dart:_js_helper",, H, { |
| "^": "", |
| getType: function(index) { |
| return init.types[index]; |
| }, |
| 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(H._argumentError(value)); |
| return res; |
| }, |
| 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_8ZY(J.getInterceptor(object)); |
| if ($name === "Object") { |
| decompiled = String(object.constructor).match(/^\s*function\s*([\w$]*)\s*\(/)[1]; |
| if (typeof decompiled === "string") |
| $name = /^\w+$/.test(decompiled) ? decompiled : $name; |
| } |
| if ($name.length > 1 && C.JSString_methods.codeUnitAt$1($name, 0) === 36) |
| $name = C.JSString_methods.substring$1($name, 1); |
| return ($name + H.joinArguments(H.getRuntimeTypeInfo(object), 0, null)).replace(/[^<,> ]+/g, function(m) { |
| return init.mangledGlobalNames[m] || m; |
| }); |
| }, |
| Primitives_objectToString: function(object) { |
| return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; |
| }, |
| Primitives_getProperty: function(object, key) { |
| if (object == null || typeof object === "boolean" || typeof object === "number" || typeof object === "string") |
| throw H.wrapException(H._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(H._argumentError(object)); |
| object[key] = value; |
| }, |
| iae: function(argument) { |
| throw H.wrapException(H._argumentError(argument)); |
| }, |
| ioore: function(receiver, index) { |
| if (receiver == null) |
| J.get$length$as(receiver); |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| H.iae(index); |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| }, |
| _argumentError: function(object) { |
| return new P.ArgumentError(true, object, null, null); |
| }, |
| checkInt: function(value) { |
| if (typeof value !== "number" || Math.floor(value) !== value) |
| throw H.wrapException(H._argumentError(value)); |
| return value; |
| }, |
| 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}); |
| wrapper.name = ""; |
| } else |
| wrapper.toString = H.toStringWrapper; |
| 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 (ex instanceof H.ExceptionAndStackTrace) |
| return t1.call$1(ex.dartException); |
| 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._shrOtherPositive$1(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)); |
| } |
| } |
| 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) |
| return t1.call$1(new H.NullError(message, match == null ? null : match.method)); |
| } |
| } |
| return t1.call$1(new H.UnknownJsTypeError(typeof message === "string" ? message : "")); |
| } |
| if (ex instanceof RangeError) { |
| if (typeof message === "string" && message.indexOf("call stack") !== -1) |
| return new P.StackOverflowError(); |
| return t1.call$1(new P.ArgumentError(false, null, null, null)); |
| } |
| if (typeof InternalError == "function" && ex instanceof InternalError) |
| if (typeof message === "string" && message === "too much recursion") |
| return new P.StackOverflowError(); |
| return ex; |
| }, |
| getTraceFromException: function(exception) { |
| if (exception instanceof H.ExceptionAndStackTrace) |
| return exception.stackTrace; |
| return new H._StackTrace(exception, null); |
| }, |
| 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(0, 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 = 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, init.globalState.currentContext, H.invokeClosure); |
| closure.$identity = $function; |
| return $function; |
| }, |
| Closure_fromTearOff: function(receiver, functions, reflectionInfo, isStatic, jsArguments, propertyName) { |
| var $function, callName, functionType, $prototype, $constructor, t1, isIntercepted, trampoline, signatureFunction, getReceiver, i, stub, stubCallName, t2; |
| $function = functions[0]; |
| callName = $function.$callName; |
| if (!!J.getInterceptor(reflectionInfo).$isList) { |
| $function.$reflectionInfo = reflectionInfo; |
| functionType = H.ReflectionInfo_ReflectionInfo($function).functionType; |
| } else |
| functionType = reflectionInfo; |
| $prototype = isStatic ? Object.create(new H.StaticClosure().constructor.prototype) : Object.create(new H.BoundClosure(null, null, null, null).constructor.prototype); |
| $prototype.$initialize = $prototype.constructor; |
| if (isStatic) |
| $constructor = function() { |
| this.$initialize(); |
| }; |
| else { |
| t1 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t1, 1); |
| t1 = new Function("a,b,c,d", "this.$initialize(a,b,c,d);" + t1); |
| $constructor = t1; |
| } |
| $prototype.constructor = $constructor; |
| $constructor.prototype = $prototype; |
| t1 = !isStatic; |
| if (t1) { |
| isIntercepted = jsArguments.length == 1 && true; |
| trampoline = H.Closure_forwardCallTo(receiver, $function, isIntercepted); |
| trampoline.$reflectionInfo = reflectionInfo; |
| } else { |
| $prototype.$name = propertyName; |
| trampoline = $function; |
| isIntercepted = false; |
| } |
| if (typeof functionType == "number") |
| signatureFunction = function(t) { |
| return function() { |
| return H.getType(t); |
| }; |
| }(functionType); |
| else if (t1 && typeof functionType == "function") { |
| getReceiver = isIntercepted ? H.BoundClosure_receiverOf : H.BoundClosure_selfOf; |
| signatureFunction = function(f, r) { |
| return function() { |
| return f.apply({$receiver: r(this)}, arguments); |
| }; |
| }(functionType, getReceiver); |
| } else |
| throw H.wrapException("Error in reflectionInfo."); |
| $prototype.$signature = signatureFunction; |
| $prototype[callName] = trampoline; |
| for (t1 = functions.length, i = 1; i < t1; ++i) { |
| stub = functions[i]; |
| stubCallName = stub.$callName; |
| if (stubCallName != null) { |
| t2 = isStatic ? stub : H.Closure_forwardCallTo(receiver, stub, isIntercepted); |
| $prototype[stubCallName] = t2; |
| } |
| } |
| $prototype["call*"] = trampoline; |
| $prototype.$requiredArgCount = $function.$requiredArgCount; |
| $prototype.$defaultValues = $function.$defaultValues; |
| return $constructor; |
| }, |
| Closure_cspForwardCall: function(arity, isSuperCall, stubName, $function) { |
| var getSelf = H.BoundClosure_selfOf; |
| switch (isSuperCall ? -1 : arity) { |
| case 0: |
| return function(n, S) { |
| return function() { |
| return S(this)[n](); |
| }; |
| }(stubName, getSelf); |
| case 1: |
| return function(n, S) { |
| return function(a) { |
| return S(this)[n](a); |
| }; |
| }(stubName, getSelf); |
| case 2: |
| return function(n, S) { |
| return function(a, b) { |
| return S(this)[n](a, b); |
| }; |
| }(stubName, getSelf); |
| case 3: |
| return function(n, S) { |
| return function(a, b, c) { |
| return S(this)[n](a, b, c); |
| }; |
| }(stubName, getSelf); |
| case 4: |
| return function(n, S) { |
| return function(a, b, c, d) { |
| return S(this)[n](a, b, c, d); |
| }; |
| }(stubName, getSelf); |
| case 5: |
| return function(n, S) { |
| return function(a, b, c, d, e) { |
| return S(this)[n](a, b, c, d, e); |
| }; |
| }(stubName, getSelf); |
| default: |
| return function(f, s) { |
| return function() { |
| return f.apply(s(this), arguments); |
| }; |
| }($function, getSelf); |
| } |
| }, |
| Closure_forwardCallTo: function(receiver, $function, isIntercepted) { |
| var stubName, arity, lookedUpFunction, t1, t2, $arguments; |
| if (isIntercepted) |
| return H.Closure_forwardInterceptedCallTo(receiver, $function); |
| stubName = $function.$stubName; |
| arity = $function.length; |
| lookedUpFunction = receiver[stubName]; |
| t1 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction; |
| t2 = !t1 || arity >= 27; |
| if (t2) |
| return H.Closure_cspForwardCall(arity, !t1, stubName, $function); |
| if (arity === 0) { |
| t1 = $.BoundClosure_selfFieldNameCache; |
| if (t1 == null) { |
| t1 = H.BoundClosure_computeFieldNamed("self"); |
| $.BoundClosure_selfFieldNameCache = t1; |
| } |
| t1 = "return function(){return this." + H.S(t1) + "." + H.S(stubName) + "();"; |
| t2 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t2, 1); |
| return new Function(t1 + H.S(t2) + "}")(); |
| } |
| $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(","); |
| t1 = "return function(" + $arguments + "){return this."; |
| t2 = $.BoundClosure_selfFieldNameCache; |
| if (t2 == null) { |
| t2 = H.BoundClosure_computeFieldNamed("self"); |
| $.BoundClosure_selfFieldNameCache = t2; |
| } |
| t2 = t1 + H.S(t2) + "." + H.S(stubName) + "(" + $arguments + ");"; |
| t1 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t1, 1); |
| return new Function(t2 + H.S(t1) + "}")(); |
| }, |
| Closure_cspForwardInterceptedCall: function(arity, isSuperCall, $name, $function) { |
| var getSelf, getReceiver; |
| getSelf = H.BoundClosure_selfOf; |
| getReceiver = H.BoundClosure_receiverOf; |
| switch (isSuperCall ? -1 : arity) { |
| case 0: |
| throw H.wrapException(new H.RuntimeError("Intercepted function with no arguments.")); |
| case 1: |
| return function(n, s, r) { |
| return function() { |
| return s(this)[n](r(this)); |
| }; |
| }($name, getSelf, getReceiver); |
| case 2: |
| return function(n, s, r) { |
| return function(a) { |
| return s(this)[n](r(this), a); |
| }; |
| }($name, getSelf, getReceiver); |
| case 3: |
| return function(n, s, r) { |
| return function(a, b) { |
| return s(this)[n](r(this), a, b); |
| }; |
| }($name, getSelf, getReceiver); |
| case 4: |
| return function(n, s, r) { |
| return function(a, b, c) { |
| return s(this)[n](r(this), a, b, c); |
| }; |
| }($name, getSelf, getReceiver); |
| case 5: |
| return function(n, s, r) { |
| return function(a, b, c, d) { |
| return s(this)[n](r(this), a, b, c, d); |
| }; |
| }($name, getSelf, getReceiver); |
| case 6: |
| return function(n, s, r) { |
| return function(a, b, c, d, e) { |
| return s(this)[n](r(this), a, b, c, d, e); |
| }; |
| }($name, getSelf, getReceiver); |
| default: |
| return function(f, s, r, a) { |
| return function() { |
| a = [r(this)]; |
| Array.prototype.push.apply(a, arguments); |
| return f.apply(s(this), a); |
| }; |
| }($function, getSelf, getReceiver); |
| } |
| }, |
| Closure_forwardInterceptedCallTo: function(receiver, $function) { |
| var selfField, t1, stubName, arity, lookedUpFunction, t2, t3, $arguments; |
| selfField = H.BoundClosure_selfFieldName(); |
| t1 = $.BoundClosure_receiverFieldNameCache; |
| if (t1 == null) { |
| t1 = H.BoundClosure_computeFieldNamed("receiver"); |
| $.BoundClosure_receiverFieldNameCache = t1; |
| } |
| stubName = $function.$stubName; |
| arity = $function.length; |
| lookedUpFunction = receiver[stubName]; |
| t2 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction; |
| t3 = !t2 || arity >= 28; |
| if (t3) |
| return H.Closure_cspForwardInterceptedCall(arity, !t2, stubName, $function); |
| if (arity === 1) { |
| t1 = "return function(){return this." + H.S(selfField) + "." + H.S(stubName) + "(this." + H.S(t1) + ");"; |
| t2 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t2, 1); |
| return new Function(t1 + H.S(t2) + "}")(); |
| } |
| $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity - 1).join(","); |
| t1 = "return function(" + $arguments + "){return this." + H.S(selfField) + "." + H.S(stubName) + "(this." + H.S(t1) + ", " + $arguments + ");"; |
| t2 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t2, 1); |
| return new Function(t1 + H.S(t2) + "}")(); |
| }, |
| closureFromTearOff: function(receiver, functions, reflectionInfo, isStatic, jsArguments, $name) { |
| var t1; |
| functions.fixed$length = Array; |
| if (!!J.getInterceptor(reflectionInfo).$isList) { |
| reflectionInfo.fixed$length = Array; |
| t1 = reflectionInfo; |
| } else |
| t1 = reflectionInfo; |
| return H.Closure_fromTearOff(receiver, functions, t1, !!isStatic, jsArguments, $name); |
| }, |
| throwCyclicInit: function(staticName) { |
| throw H.wrapException(new P.CyclicInitializationError("Cyclic initialization for static " + H.S(staticName))); |
| }, |
| buildFunctionType: function(returnType, parameterTypes, optionalParameterTypes) { |
| return new H.RuntimeFunctionType(returnType, parameterTypes, optionalParameterTypes, null); |
| }, |
| getDynamicRuntimeType: function() { |
| return C.C_DynamicRuntimeType; |
| }, |
| random64: function() { |
| return (Math.random() * 0x100000000 >>> 0) + (Math.random() * 0x100000000 >>> 0) * 4294967296; |
| }, |
| asyncHelper: function(object, bodyFunctionOrErrorCode, completer) { |
| var future; |
| if (bodyFunctionOrErrorCode === 0) { |
| completer.complete$1(object); |
| return; |
| } else if (bodyFunctionOrErrorCode === 1) { |
| completer.completeError$2(H.unwrapException(object), H.getTraceFromException(object)); |
| return; |
| } |
| if (!!J.getInterceptor(object).$isFuture) |
| future = object; |
| else { |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| future._asyncComplete$1(object); |
| } |
| future.then$2$onError(H._wrapJsFunctionForAsync(bodyFunctionOrErrorCode, 0), new H.asyncHelper_closure(bodyFunctionOrErrorCode)); |
| return completer.get$future(); |
| }, |
| _wrapJsFunctionForAsync: function($function, errorCode) { |
| return new H._wrapJsFunctionForAsync_closure(errorCode, function(errorCode, result) { |
| while (true) |
| try { |
| $function(errorCode, result); |
| break; |
| } catch (error) { |
| result = error; |
| errorCode = 1; |
| } |
| }); |
| }, |
| 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]; |
| }, |
| getTypeArgumentByIndex: function(target, index) { |
| var rti = H.getRuntimeTypeInfo(target); |
| return rti == null ? null : rti[index]; |
| }, |
| runtimeTypeToString: function(type, onTypeVariable) { |
| if (type == null) |
| return "dynamic"; |
| else if (typeof type === "object" && type !== null && type.constructor === Array) |
| return type[0].builtin$cls + H.joinArguments(type, 1, 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, t1, argument; |
| if (types == null) |
| return ""; |
| buffer = new P.StringBuffer(""); |
| for (index = startIndex, firstArgument = true, allDynamic = true, t1 = ""; index < types.length; ++index) { |
| if (firstArgument) |
| firstArgument = false; |
| else |
| buffer._contents = t1 + ", "; |
| argument = types[index]; |
| if (argument != null) |
| allDynamic = false; |
| t1 = buffer._contents += H.S(H.runtimeTypeToString(argument, onTypeVariable)); |
| } |
| return allDynamic ? "" : "<" + H.S(buffer) + ">"; |
| }, |
| substitute: function(substitution, $arguments) { |
| if (typeof substitution == "function") { |
| substitution = H.invokeOn(substitution, null, $arguments); |
| if (substitution == null || typeof substitution === "object" && substitution !== null && substitution.constructor === Array) |
| $arguments = substitution; |
| else if (typeof substitution == "function") |
| $arguments = H.invokeOn(substitution, null, $arguments); |
| } |
| return $arguments; |
| }, |
| areSubtypes: function(s, t) { |
| var len, i; |
| if (s == null || t == null) |
| return true; |
| len = s.length; |
| for (i = 0; i < len; ++i) |
| if (!H.isSubtype(s[i], t[i])) |
| return false; |
| return true; |
| }, |
| computeSignature: function(signature, context, contextName) { |
| return H.invokeOn(signature, context, H.getRuntimeTypeArguments(context, contextName)); |
| }, |
| isSubtype: function(s, t) { |
| var t1, typeOfS, t2, typeOfT, substitution; |
| if (s === t) |
| return true; |
| if (s == null || t == null) |
| return true; |
| if ('func' in t) |
| return H.isFunctionSubtype(s, t); |
| if ('func' in s) |
| return t.builtin$cls === "Function"; |
| t1 = typeof s === "object" && s !== null && s.constructor === Array; |
| typeOfS = t1 ? s[0] : s; |
| t2 = typeof t === "object" && t !== null && t.constructor === Array; |
| typeOfT = t2 ? t[0] : t; |
| if (typeOfT !== typeOfS) { |
| if (!('$is' + H.runtimeTypeToString(typeOfT, null) in typeOfS.prototype)) |
| return false; |
| substitution = typeOfS.prototype["$as" + H.S(H.runtimeTypeToString(typeOfT, null))]; |
| } else |
| substitution = null; |
| if (!t1 && substitution == null || !t2) |
| return true; |
| t1 = t1 ? s.slice(1) : null; |
| t2 = t2 ? t.slice(1) : null; |
| return H.areSubtypes(H.substitute(substitution, t1), t2); |
| }, |
| areAssignable: function(s, t, allowShorter) { |
| var t1, sLength, tLength, i, t2; |
| t1 = t == null; |
| if (t1 && s == null) |
| return true; |
| if (t1) |
| return allowShorter; |
| if (s == null) |
| return false; |
| sLength = s.length; |
| tLength = t.length; |
| if (allowShorter) { |
| if (sLength < tLength) |
| return false; |
| } else if (sLength !== tLength) |
| return false; |
| for (i = 0; i < tLength; ++i) { |
| t1 = s[i]; |
| t2 = t[i]; |
| if (!(H.isSubtype(t1, t2) || H.isSubtype(t2, t1))) |
| return false; |
| } |
| return true; |
| }, |
| areAssignableMaps: function(s, t) { |
| var t1, names, i, $name, tType, sType; |
| if (t == null) |
| return true; |
| if (s == null) |
| return false; |
| t1 = Object.getOwnPropertyNames(t); |
| t1.fixed$length = Array; |
| names = t1; |
| for (t1 = names.length, i = 0; i < t1; ++i) { |
| $name = names[i]; |
| if (!Object.hasOwnProperty.call(s, $name)) |
| return false; |
| tType = t[$name]; |
| sType = s[$name]; |
| if (!(H.isSubtype(tType, sType) || H.isSubtype(sType, tType))) |
| return false; |
| } |
| return true; |
| }, |
| isFunctionSubtype: function(s, t) { |
| var sReturnType, tReturnType, sParameterTypes, tParameterTypes, sOptionalParameterTypes, tOptionalParameterTypes, sParametersLen, tParametersLen, sOptionalParametersLen, tOptionalParametersLen, pos, t1, t2, tPos, sPos; |
| if (!('func' in s)) |
| return false; |
| if ("void" in s) { |
| if (!("void" in t) && "ret" in t) |
| return false; |
| } else if (!("void" in t)) { |
| sReturnType = s.ret; |
| tReturnType = t.ret; |
| if (!(H.isSubtype(sReturnType, tReturnType) || H.isSubtype(tReturnType, sReturnType))) |
| return false; |
| } |
| sParameterTypes = s.args; |
| tParameterTypes = t.args; |
| sOptionalParameterTypes = s.opt; |
| tOptionalParameterTypes = t.opt; |
| sParametersLen = sParameterTypes != null ? sParameterTypes.length : 0; |
| tParametersLen = tParameterTypes != null ? tParameterTypes.length : 0; |
| sOptionalParametersLen = sOptionalParameterTypes != null ? sOptionalParameterTypes.length : 0; |
| tOptionalParametersLen = tOptionalParameterTypes != null ? tOptionalParameterTypes.length : 0; |
| if (sParametersLen > tParametersLen) |
| return false; |
| if (sParametersLen + sOptionalParametersLen < tParametersLen + tOptionalParametersLen) |
| return false; |
| if (sParametersLen === tParametersLen) { |
| if (!H.areAssignable(sParameterTypes, tParameterTypes, false)) |
| return false; |
| if (!H.areAssignable(sOptionalParameterTypes, tOptionalParameterTypes, true)) |
| return false; |
| } else { |
| for (pos = 0; pos < sParametersLen; ++pos) { |
| t1 = sParameterTypes[pos]; |
| t2 = tParameterTypes[pos]; |
| if (!(H.isSubtype(t1, t2) || H.isSubtype(t2, t1))) |
| return false; |
| } |
| for (tPos = pos, sPos = 0; tPos < tParametersLen; ++sPos, ++tPos) { |
| t1 = sOptionalParameterTypes[sPos]; |
| t2 = tParameterTypes[tPos]; |
| if (!(H.isSubtype(t1, t2) || H.isSubtype(t2, t1))) |
| return false; |
| } |
| for (tPos = 0; tPos < tOptionalParametersLen; ++sPos, ++tPos) { |
| t1 = sOptionalParameterTypes[sPos]; |
| t2 = tOptionalParameterTypes[tPos]; |
| if (!(H.isSubtype(t1, t2) || H.isSubtype(t2, t1))) |
| return false; |
| } |
| } |
| return H.areAssignableMaps(s.named, t.named); |
| }, |
| invokeOn: function($function, receiver, $arguments) { |
| return $function.apply(receiver, $arguments); |
| }, |
| ReflectionInfo: { |
| "^": "Object;jsFunction,data,isAccessor,requiredParameterCount,optionalParameterCount,areOptionalParametersNamed,functionType,cachedSortedIndices", |
| static: {ReflectionInfo_ReflectionInfo: function(jsFunction) { |
| var data, requiredParametersInfo, optionalParametersInfo; |
| data = jsFunction.$reflectionInfo; |
| if (data == null) |
| return; |
| data.fixed$length = Array; |
| data = data; |
| requiredParametersInfo = data[0]; |
| optionalParametersInfo = data[1]; |
| return new H.ReflectionInfo(jsFunction, data, (requiredParametersInfo & 1) === 1, requiredParametersInfo >> 1, optionalParametersInfo >> 1, (optionalParametersInfo & 1) === 1, data[2], null); |
| }} |
| }, |
| 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 = Object.create(null); |
| t1 = this._arguments; |
| if (t1 !== -1) |
| result.arguments = match[t1 + 1]; |
| t1 = this._argumentsExpr; |
| if (t1 !== -1) |
| result.argumentsExpr = match[t1 + 1]; |
| t1 = this._expr; |
| if (t1 !== -1) |
| result.expr = match[t1 + 1]; |
| t1 = this._method; |
| if (t1 !== -1) |
| result.method = match[t1 + 1]; |
| t1 = this._receiver; |
| if (t1 !== -1) |
| result.receiver = match[t1 + 1]; |
| return result; |
| }, |
| static: {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_provokePropertyErrorOn: function(expression) { |
| return function($expr$) { |
| try { |
| $expr$.$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }(expression); |
| }} |
| }, |
| NullError: { |
| "^": "Error;_message,_method", |
| toString$0: function(_) { |
| var t1 = this._method; |
| if (t1 == null) |
| return "NullError: " + H.S(this._message); |
| return "NullError: method not found: '" + H.S(t1) + "' on null"; |
| } |
| }, |
| 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: method not found: '" + H.S(t1) + "' (" + H.S(this._message) + ")"; |
| return "NoSuchMethodError: method not found: '" + H.S(t1) + "' on '" + H.S(t2) + "' (" + H.S(this._message) + ")"; |
| }, |
| static: {JsNoSuchMethodError$: function(_message, match) { |
| var t1, t2; |
| t1 = match == null; |
| t2 = t1 ? null : match.method; |
| return new H.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver); |
| }} |
| }, |
| UnknownJsTypeError: { |
| "^": "Error;_message", |
| toString$0: function(_) { |
| var t1 = this._message; |
| return C.JSString_methods.get$isEmpty(t1) ? "Error" : "Error: " + t1; |
| } |
| }, |
| unwrapException_saveStackTrace: { |
| "^": "Closure:2;_captured_ex_0", |
| call$1: function(error) { |
| if (!!J.getInterceptor(error).$isError) |
| if (error.$thrownJsError == null) |
| error.$thrownJsError = this._captured_ex_0; |
| return error; |
| } |
| }, |
| _StackTrace: { |
| "^": "Object;_exception,_trace", |
| toString$0: function(_) { |
| var t1, trace; |
| t1 = this._trace; |
| if (t1 != null) |
| return t1; |
| t1 = this._exception; |
| trace = t1 !== null && typeof t1 === "object" ? t1.stack : null; |
| t1 = trace == null ? "" : trace; |
| this._trace = t1; |
| return t1; |
| } |
| }, |
| invokeClosure_closure: { |
| "^": "Closure:0;_captured_closure_0", |
| call$0: function() { |
| return this._captured_closure_0.call$0(); |
| } |
| }, |
| invokeClosure_closure0: { |
| "^": "Closure:0;_captured_closure_1,_captured_arg1_2", |
| call$0: function() { |
| return this._captured_closure_1.call$1(this._captured_arg1_2); |
| } |
| }, |
| invokeClosure_closure1: { |
| "^": "Closure:0;_captured_closure_3,_captured_arg1_4,_captured_arg2_5", |
| call$0: function() { |
| return this._captured_closure_3.call$2(this._captured_arg1_4, this._captured_arg2_5); |
| } |
| }, |
| invokeClosure_closure2: { |
| "^": "Closure:0;_captured_closure_6,_captured_arg1_7,_captured_arg2_8,_captured_arg3_9", |
| call$0: function() { |
| return this._captured_closure_6.call$3(this._captured_arg1_7, this._captured_arg2_8, this._captured_arg3_9); |
| } |
| }, |
| invokeClosure_closure3: { |
| "^": "Closure:0;_captured_closure_10,_captured_arg1_11,_captured_arg2_12,_captured_arg3_13,_captured_arg4_14", |
| call$0: function() { |
| return this._captured_closure_10.call$4(this._captured_arg1_11, this._captured_arg2_12, this._captured_arg3_13, this._captured_arg4_14); |
| } |
| }, |
| Closure: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "Closure '" + H.Primitives_objectTypeName(this) + "'"; |
| }, |
| get$$call: function() { |
| return this; |
| }, |
| get$$call: function() { |
| return this; |
| } |
| }, |
| TearOffClosure: { |
| "^": "Closure;" |
| }, |
| StaticClosure: { |
| "^": "TearOffClosure;", |
| toString$0: function(_) { |
| var $name = this.$name; |
| if ($name == null) |
| return "Closure of unknown static method"; |
| return "Closure '" + $name + "'"; |
| } |
| }, |
| BoundClosure: { |
| "^": "TearOffClosure;_self,_target,_receiver,_name", |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (this === other) |
| return true; |
| if (!(other instanceof H.BoundClosure)) |
| 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; |
| }, |
| toString$0: function(_) { |
| var receiver = this._receiver; |
| if (receiver == null) |
| receiver = this._self; |
| return "Closure '" + H.S(this._name) + "' of " + H.Primitives_objectToString(receiver); |
| }, |
| static: {BoundClosure_selfOf: function(closure) { |
| return closure._self; |
| }, BoundClosure_receiverOf: function(closure) { |
| return closure._receiver; |
| }, BoundClosure_selfFieldName: function() { |
| var t1 = $.BoundClosure_selfFieldNameCache; |
| if (t1 == null) { |
| t1 = H.BoundClosure_computeFieldNamed("self"); |
| $.BoundClosure_selfFieldNameCache = t1; |
| } |
| return t1; |
| }, BoundClosure_computeFieldNamed: function(fieldName) { |
| var template, t1, names, i, $name; |
| template = new H.BoundClosure("self", "target", "receiver", "name"); |
| t1 = Object.getOwnPropertyNames(template); |
| t1.fixed$length = Array; |
| names = t1; |
| for (t1 = names.length, i = 0; i < t1; ++i) { |
| $name = names[i]; |
| if (template[$name] === fieldName) |
| return $name; |
| } |
| }} |
| }, |
| RuntimeError: { |
| "^": "Error;message", |
| toString$0: function(_) { |
| return "RuntimeError: " + this.message; |
| } |
| }, |
| RuntimeType: { |
| "^": "Object;" |
| }, |
| RuntimeFunctionType: { |
| "^": "RuntimeType;returnType,parameterTypes,optionalParameterTypes,namedParameters", |
| _isTest$1: function(expression) { |
| var functionTypeObject = this._extractFunctionTypeObjectFrom$1(expression); |
| return functionTypeObject == null ? false : H.isFunctionSubtype(functionTypeObject, this.toRti$0()); |
| }, |
| _extractFunctionTypeObjectFrom$1: function(o) { |
| var interceptor = J.getInterceptor(o); |
| return "$signature" in interceptor ? interceptor.$signature() : null; |
| }, |
| toRti$0: function() { |
| var result, t1, t2, namedRti, keys, i, $name; |
| result = {func: "dynafunc"}; |
| t1 = this.returnType; |
| t2 = J.getInterceptor(t1); |
| if (!!t2.$isVoidRuntimeType) |
| result.void = true; |
| else if (!t2.$isDynamicRuntimeType) |
| result.ret = t1.toRti$0(); |
| t1 = this.parameterTypes; |
| if (t1 != null && t1.length !== 0) |
| result.args = H.RuntimeFunctionType_listToRti(t1); |
| t1 = this.optionalParameterTypes; |
| if (t1 != null && t1.length !== 0) |
| result.opt = H.RuntimeFunctionType_listToRti(t1); |
| t1 = this.namedParameters; |
| if (t1 != null) { |
| namedRti = Object.create(null); |
| keys = H.extractKeys(t1); |
| for (t2 = keys.length, i = 0; i < t2; ++i) { |
| $name = keys[i]; |
| namedRti[$name] = t1[$name].toRti$0(); |
| } |
| result.named = namedRti; |
| } |
| return result; |
| }, |
| toString$0: function(_) { |
| var t1, t2, result, needsComma, i, type, keys, $name; |
| t1 = this.parameterTypes; |
| if (t1 != null) |
| for (t2 = t1.length, result = "(", needsComma = false, i = 0; i < t2; ++i, needsComma = true) { |
| type = t1[i]; |
| if (needsComma) |
| result += ", "; |
| result += H.S(type); |
| } |
| else { |
| result = "("; |
| needsComma = false; |
| } |
| t1 = this.optionalParameterTypes; |
| if (t1 != null && t1.length !== 0) { |
| result = (needsComma ? result + ", " : result) + "["; |
| for (t2 = t1.length, needsComma = false, i = 0; i < t2; ++i, needsComma = true) { |
| type = t1[i]; |
| if (needsComma) |
| result += ", "; |
| result += H.S(type); |
| } |
| result += "]"; |
| } else { |
| t1 = this.namedParameters; |
| if (t1 != null) { |
| result = (needsComma ? result + ", " : result) + "{"; |
| keys = H.extractKeys(t1); |
| for (t2 = keys.length, needsComma = false, i = 0; i < t2; ++i, needsComma = true) { |
| $name = keys[i]; |
| if (needsComma) |
| result += ", "; |
| result += H.S(t1[$name].toRti$0()) + " " + $name; |
| } |
| result += "}"; |
| } |
| } |
| return result + (") -> " + H.S(this.returnType)); |
| }, |
| static: {RuntimeFunctionType_listToRti: function(list) { |
| var result, t1, i; |
| list = list; |
| result = []; |
| for (t1 = list.length, i = 0; i < t1; ++i) |
| result.push(list[i].toRti$0()); |
| return result; |
| }} |
| }, |
| DynamicRuntimeType: { |
| "^": "RuntimeType;", |
| toString$0: function(_) { |
| return "dynamic"; |
| }, |
| toRti$0: function() { |
| return; |
| } |
| }, |
| ExceptionAndStackTrace: { |
| "^": "Object;dartException,stackTrace<" |
| }, |
| asyncHelper_closure: { |
| "^": "Closure:3;_captured_bodyFunctionOrErrorCode_0", |
| call$2: function(error, stackTrace) { |
| H._wrapJsFunctionForAsync(this._captured_bodyFunctionOrErrorCode_0, 1).call$1(new H.ExceptionAndStackTrace(error, stackTrace)); |
| } |
| }, |
| _wrapJsFunctionForAsync_closure: { |
| "^": "Closure:2;_captured_errorCode_0,_captured_protected_1", |
| call$1: function(result) { |
| this._captured_protected_1(this._captured_errorCode_0, result); |
| } |
| }, |
| JsLinkedHashMap: { |
| "^": "Object;__js_helper$_length,_strings,_nums,_rest,_first,_last,_modifications", |
| get$length: function(_) { |
| return this.__js_helper$_length; |
| }, |
| get$keys: function() { |
| return H.setRuntimeTypeInfo(new H.LinkedHashMapKeyIterable(this), [H.getTypeArgumentByIndex(this, 0)]); |
| }, |
| get$values: function() { |
| return H.MappedIterable_MappedIterable(H.setRuntimeTypeInfo(new H.LinkedHashMapKeyIterable(this), [H.getTypeArgumentByIndex(this, 0)]), new H.JsLinkedHashMap_values_closure(this), H.getTypeArgumentByIndex(this, 0), H.getTypeArgumentByIndex(this, 1)); |
| }, |
| containsKey$1: function(key) { |
| var nums; |
| if ((key & 0x3ffffff) === key) { |
| nums = this._nums; |
| if (nums == null) |
| return false; |
| return this._containsTableEntry$2(nums, key); |
| } else |
| return this.internalContainsKey$1(key); |
| }, |
| internalContainsKey$1: function(key) { |
| var rest = this._rest; |
| if (rest == null) |
| return false; |
| return this.internalFindBucketIndex$2(this._getTableEntry$2(rest, this.internalComputeHashCode$1(key)), key) >= 0; |
| }, |
| $index: function(_, key) { |
| var strings, cell, nums; |
| if (typeof key === "string") { |
| strings = this._strings; |
| if (strings == null) |
| return; |
| cell = this._getTableEntry$2(strings, key); |
| return cell == null ? null : cell.get$hashMapCellValue(); |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { |
| nums = this._nums; |
| if (nums == null) |
| return; |
| cell = this._getTableEntry$2(nums, key); |
| return cell == null ? null : cell.get$hashMapCellValue(); |
| } else |
| return this.internalGet$1(key); |
| }, |
| internalGet$1: function(key) { |
| var rest, bucket, index; |
| rest = this._rest; |
| if (rest == null) |
| return; |
| bucket = this._getTableEntry$2(rest, this.internalComputeHashCode$1(key)); |
| index = this.internalFindBucketIndex$2(bucket, key); |
| if (index < 0) |
| return; |
| return bucket[index].get$hashMapCellValue(); |
| }, |
| $indexSet: function(_, key, value) { |
| var strings, nums; |
| if (typeof key === "string") { |
| strings = this._strings; |
| if (strings == null) { |
| strings = this._newHashTable$0(); |
| this._strings = strings; |
| } |
| this.__js_helper$_addHashTableEntry$3(strings, key, value); |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { |
| nums = this._nums; |
| if (nums == null) { |
| nums = this._newHashTable$0(); |
| this._nums = nums; |
| } |
| this.__js_helper$_addHashTableEntry$3(nums, key, value); |
| } else |
| this.internalSet$2(key, value); |
| }, |
| internalSet$2: function(key, value) { |
| var rest, hash, bucket, index; |
| rest = this._rest; |
| if (rest == null) { |
| rest = this._newHashTable$0(); |
| this._rest = rest; |
| } |
| hash = this.internalComputeHashCode$1(key); |
| bucket = this._getTableEntry$2(rest, hash); |
| if (bucket == null) |
| this._setTableEntry$3(rest, hash, [this.__js_helper$_newLinkedCell$2(key, value)]); |
| else { |
| index = this.internalFindBucketIndex$2(bucket, key); |
| if (index >= 0) |
| bucket[index].set$hashMapCellValue(value); |
| else |
| bucket.push(this.__js_helper$_newLinkedCell$2(key, value)); |
| } |
| }, |
| remove$1: function(_, key) { |
| if (typeof key === "string") |
| return this._removeHashTableEntry$2(this._strings, key); |
| else if (typeof key === "number" && (key & 0x3ffffff) === key) |
| return this._removeHashTableEntry$2(this._nums, key); |
| else |
| return this.internalRemove$1(key); |
| }, |
| internalRemove$1: function(key) { |
| var rest, bucket, index, cell; |
| rest = this._rest; |
| if (rest == null) |
| return; |
| bucket = this._getTableEntry$2(rest, this.internalComputeHashCode$1(key)); |
| index = this.internalFindBucketIndex$2(bucket, key); |
| if (index < 0) |
| return; |
| cell = bucket.splice(index, 1)[0]; |
| this._unlinkCell$1(cell); |
| return cell.get$hashMapCellValue(); |
| }, |
| forEach$1: function(_, action) { |
| var cell, modifications; |
| cell = this._first; |
| modifications = this._modifications; |
| for (; cell != null;) { |
| action.call$2(cell.hashMapCellKey, cell.hashMapCellValue); |
| if (modifications !== this._modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| cell = cell.__js_helper$_next; |
| } |
| }, |
| __js_helper$_addHashTableEntry$3: function(table, key, value) { |
| var cell = this._getTableEntry$2(table, key); |
| if (cell == null) |
| this._setTableEntry$3(table, key, this.__js_helper$_newLinkedCell$2(key, value)); |
| else |
| cell.set$hashMapCellValue(value); |
| }, |
| _removeHashTableEntry$2: function(table, key) { |
| var cell; |
| if (table == null) |
| return; |
| cell = this._getTableEntry$2(table, key); |
| if (cell == null) |
| return; |
| this._unlinkCell$1(cell); |
| this._deleteTableEntry$2(table, key); |
| return cell.get$hashMapCellValue(); |
| }, |
| __js_helper$_newLinkedCell$2: function(key, value) { |
| var cell, last; |
| cell = new H.LinkedHashMapCell(key, value, null, null); |
| if (this._first == null) { |
| this._last = cell; |
| this._first = cell; |
| } else { |
| last = this._last; |
| cell.__js_helper$_previous = last; |
| last.__js_helper$_next = cell; |
| this._last = cell; |
| } |
| ++this.__js_helper$_length; |
| this._modifications = this._modifications + 1 & 67108863; |
| return cell; |
| }, |
| _unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$__js_helper$_previous(); |
| next = cell.__js_helper$_next; |
| if (previous == null) |
| this._first = next; |
| else |
| previous.__js_helper$_next = next; |
| if (next == null) |
| this._last = previous; |
| else |
| next.__js_helper$_previous = previous; |
| --this.__js_helper$_length; |
| this._modifications = this._modifications + 1 & 67108863; |
| }, |
| internalComputeHashCode$1: function(key) { |
| return J.get$hashCode$(key) & 0x3ffffff; |
| }, |
| internalFindBucketIndex$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$hashMapCellKey(), key)) |
| return i; |
| return -1; |
| }, |
| toString$0: function(_) { |
| return P.Maps_mapToString(this); |
| }, |
| _getTableEntry$2: function(table, key) { |
| return table[key]; |
| }, |
| _setTableEntry$3: function(table, key, value) { |
| table[key] = value; |
| }, |
| _deleteTableEntry$2: function(table, key) { |
| delete table[key]; |
| }, |
| _containsTableEntry$2: function(table, key) { |
| return this._getTableEntry$2(table, key) != null; |
| }, |
| _newHashTable$0: function() { |
| var table = Object.create(null); |
| this._setTableEntry$3(table, "<non-identifier-key>", table); |
| this._deleteTableEntry$2(table, "<non-identifier-key>"); |
| return table; |
| }, |
| $isInternalMap: 1 |
| }, |
| JsLinkedHashMap_values_closure: { |
| "^": "Closure:2;__js_helper$_captured_this_0", |
| call$1: function(each) { |
| return this.__js_helper$_captured_this_0.$index(0, each); |
| } |
| }, |
| LinkedHashMapCell: { |
| "^": "Object;hashMapCellKey<,hashMapCellValue@,__js_helper$_next,__js_helper$_previous<" |
| }, |
| LinkedHashMapKeyIterable: { |
| "^": "Iterable;_map", |
| get$length: function(_) { |
| return this._map.__js_helper$_length; |
| }, |
| get$iterator: function(_) { |
| var t1, t2; |
| t1 = this._map; |
| t2 = new H.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); |
| t2.__js_helper$_cell = t1._first; |
| return t2; |
| }, |
| forEach$1: function(_, f) { |
| var t1, cell, modifications; |
| t1 = this._map; |
| cell = t1._first; |
| modifications = t1._modifications; |
| for (; cell != null;) { |
| f.call$1(cell.hashMapCellKey); |
| if (modifications !== t1._modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| cell = cell.__js_helper$_next; |
| } |
| }, |
| $isEfficientLengthIterable: 1 |
| }, |
| LinkedHashMapKeyIterator: { |
| "^": "Object;_map,_modifications,__js_helper$_cell,__js_helper$_current", |
| get$current: function() { |
| return this.__js_helper$_current; |
| }, |
| moveNext$0: function() { |
| var t1 = this._map; |
| if (this._modifications !== t1._modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| else { |
| t1 = this.__js_helper$_cell; |
| if (t1 == null) { |
| this.__js_helper$_current = null; |
| return false; |
| } else { |
| this.__js_helper$_current = t1.hashMapCellKey; |
| this.__js_helper$_cell = t1.__js_helper$_next; |
| return true; |
| } |
| } |
| } |
| } |
| }], ["dart._internal", "dart:_internal",, H, { |
| "^": "", |
| IterableElementError_noElement: function() { |
| return new P.StateError("No element"); |
| }, |
| Symbol_getName: function(symbol) { |
| return symbol.get$__internal$_name(); |
| }, |
| ListIterable: { |
| "^": "Iterable;", |
| 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(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| map$1: function(_, f) { |
| return H.setRuntimeTypeInfo(new H.MappedListIterable(this, f), [null, null]); |
| }, |
| toList$1$growable: function(_, growable) { |
| var result, i, t1; |
| if (growable) { |
| result = H.setRuntimeTypeInfo([], [H.getRuntimeTypeArgument(this, "ListIterable", 0)]); |
| C.JSArray_methods.set$length(result, this.get$length(this)); |
| } else |
| result = H.setRuntimeTypeInfo(Array(this.get$length(this)), [H.getRuntimeTypeArgument(this, "ListIterable", 0)]); |
| for (i = 0; i < this.get$length(this); ++i) { |
| t1 = this.elementAt$1(0, i); |
| if (i >= result.length) |
| return H.ioore(result, i); |
| result[i] = t1; |
| } |
| return result; |
| }, |
| toList$0: function($receiver) { |
| return this.toList$1$growable($receiver, true); |
| }, |
| $isEfficientLengthIterable: 1 |
| }, |
| ListIterator: { |
| "^": "Object;__internal$_iterable,__internal$_length,__internal$_index,__internal$_current", |
| get$current: function() { |
| return this.__internal$_current; |
| }, |
| moveNext$0: function() { |
| var t1, $length, t2; |
| t1 = this.__internal$_iterable; |
| $length = t1.get$length(t1); |
| if (this.__internal$_length !== $length) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| t2 = this.__internal$_index; |
| if (t2 >= $length) { |
| this.__internal$_current = null; |
| return false; |
| } |
| this.__internal$_current = t1.elementAt$1(0, t2); |
| ++this.__internal$_index; |
| return true; |
| } |
| }, |
| MappedIterable: { |
| "^": "Iterable;__internal$_iterable,_f", |
| get$iterator: function(_) { |
| var t1 = new H.MappedIterator(null, J.get$iterator$a(this.__internal$_iterable), this._f); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| return t1; |
| }, |
| get$length: function(_) { |
| return J.get$length$as(this.__internal$_iterable); |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| }, |
| static: {MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { |
| if (!!J.getInterceptor(iterable).$isEfficientLengthIterable) |
| return H.setRuntimeTypeInfo(new H.EfficientLengthMappedIterable(iterable, $function), [$S, $T]); |
| return H.setRuntimeTypeInfo(new H.MappedIterable(iterable, $function), [$S, $T]); |
| }} |
| }, |
| EfficientLengthMappedIterable: { |
| "^": "MappedIterable;__internal$_iterable,_f", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| MappedIterator: { |
| "^": "Iterator;__internal$_current,_iterator,_f", |
| moveNext$0: function() { |
| var t1 = this._iterator; |
| if (t1.moveNext$0()) { |
| this.__internal$_current = this._f$1(t1.get$current()); |
| return true; |
| } |
| this.__internal$_current = null; |
| return false; |
| }, |
| get$current: function() { |
| return this.__internal$_current; |
| }, |
| _f$1: function(arg0) { |
| return this._f.call$1(arg0); |
| } |
| }, |
| MappedListIterable: { |
| "^": "ListIterable;_source,_f", |
| get$length: function(_) { |
| return J.get$length$as(this._source); |
| }, |
| elementAt$1: function(_, index) { |
| return this._f$1(J.elementAt$1$a(this._source, index)); |
| }, |
| _f$1: function(arg0) { |
| return this._f.call$1(arg0); |
| }, |
| $asListIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $asEfficientLengthIterable: function($S, $T) { |
| return [$T]; |
| } |
| } |
| }], ["dart._js_names", "dart:_js_names",, H, { |
| "^": "", |
| extractKeys: function(victim) { |
| var t1 = H.setRuntimeTypeInfo(victim ? Object.keys(victim) : [], [null]); |
| t1.fixed$length = Array; |
| return t1; |
| } |
| }], ["dart.async", "dart:async",, P, { |
| "^": "", |
| _AsyncRun__initializeScheduleImmediate: function() { |
| var t1, div, span; |
| t1 = {}; |
| if (self.scheduleImmediate != null) |
| return P._AsyncRun__scheduleImmediateJsOverride$closure(); |
| if (self.MutationObserver != null && self.document != null) { |
| div = self.document.createElement("div"); |
| span = self.document.createElement("span"); |
| t1._captured_storedCallback_0 = null; |
| new self.MutationObserver(H.convertDartClosureToJS(new P._AsyncRun__initializeScheduleImmediate_internalCallback(t1), 1)).observe(div, {childList: true}); |
| return new P._AsyncRun__initializeScheduleImmediate_closure(t1, div, span); |
| } else if (self.setImmediate != null) |
| return P._AsyncRun__scheduleImmediateWithSetImmediate$closure(); |
| return P._AsyncRun__scheduleImmediateWithTimer$closure(); |
| }, |
| _AsyncRun__scheduleImmediateJsOverride: [function(callback) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| self.scheduleImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateJsOverride_internalCallback(callback), 0)); |
| }, "call$1", "_AsyncRun__scheduleImmediateJsOverride$closure", 2, 0, 11], |
| _AsyncRun__scheduleImmediateWithSetImmediate: [function(callback) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| self.setImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(callback), 0)); |
| }, "call$1", "_AsyncRun__scheduleImmediateWithSetImmediate$closure", 2, 0, 11], |
| _AsyncRun__scheduleImmediateWithTimer: [function(callback) { |
| P.Timer__createTimer(C.Duration_0, callback); |
| }, "call$1", "_AsyncRun__scheduleImmediateWithTimer$closure", 2, 0, 11], |
| _registerErrorHandler: function(errorHandler, zone) { |
| var t1 = H.getDynamicRuntimeType(); |
| t1 = H.buildFunctionType(t1, [t1, t1])._isTest$1(errorHandler); |
| if (t1) { |
| zone.toString; |
| return errorHandler; |
| } else { |
| zone.toString; |
| return errorHandler; |
| } |
| }, |
| Completer_Completer: function($T) { |
| return H.setRuntimeTypeInfo(new P._AsyncCompleter(H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [$T])), [$T]); |
| }, |
| _microtaskLoop: function() { |
| var t1, t2; |
| for (; t1 = $._nextCallback, t1 != null;) { |
| $._lastPriorityCallback = null; |
| t2 = t1.next; |
| $._nextCallback = t2; |
| if (t2 == null) |
| $._lastCallback = null; |
| $.Zone__current = t1.zone; |
| t1.callback$0(); |
| } |
| }, |
| _microtaskLoopEntry: [function() { |
| $._isInCallbackLoop = true; |
| try { |
| P._microtaskLoop(); |
| } finally { |
| $.Zone__current = C.C__RootZone; |
| $._lastPriorityCallback = null; |
| $._isInCallbackLoop = false; |
| if ($._nextCallback != null) |
| $.get$_AsyncRun_scheduleImmediateClosure().call$1(P._microtaskLoopEntry$closure()); |
| } |
| }, "call$0", "_microtaskLoopEntry$closure", 0, 0, 1], |
| _scheduleAsyncCallback: function(newEntry) { |
| if ($._nextCallback == null) { |
| $._lastCallback = newEntry; |
| $._nextCallback = newEntry; |
| if (!$._isInCallbackLoop) |
| $.get$_AsyncRun_scheduleImmediateClosure().call$1(P._microtaskLoopEntry$closure()); |
| } else { |
| $._lastCallback.next = newEntry; |
| $._lastCallback = newEntry; |
| } |
| }, |
| scheduleMicrotask: function(callback) { |
| var currentZone, t1; |
| currentZone = $.Zone__current; |
| if (C.C__RootZone === currentZone) { |
| P._rootScheduleMicrotask(null, null, C.C__RootZone, callback); |
| return; |
| } |
| currentZone.toString; |
| if (C.C__RootZone.get$errorZone() === currentZone) { |
| P._rootScheduleMicrotask(null, null, currentZone, callback); |
| return; |
| } |
| t1 = $.Zone__current; |
| P._rootScheduleMicrotask(null, null, t1, t1.bindCallback$2$runGuarded(callback, true)); |
| }, |
| StreamIterator_StreamIterator: function(stream, $T) { |
| var t1, t2, t3; |
| t1 = H.setRuntimeTypeInfo(new P._StreamIteratorImpl(null, null, null, 0), [$T]); |
| t2 = t1.get$_onData(); |
| t3 = t1.get$_onError(); |
| t1._subscription = stream.listen$4$cancelOnError$onDone$onError(t2, true, t1.get$_onDone(), t3); |
| return t1; |
| }, |
| Timer_Timer: function(duration, callback) { |
| var t1 = $.Zone__current; |
| if (t1 === C.C__RootZone) { |
| t1.toString; |
| return P.Timer__createTimer(duration, callback); |
| } |
| return P.Timer__createTimer(duration, t1.bindCallback$2$runGuarded(callback, true)); |
| }, |
| Timer__createTimer: function(duration, callback) { |
| var milliseconds = C.JSInt_methods._tdivFast$1(duration._duration, 1000); |
| return H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback); |
| }, |
| Zone__enter: function(zone) { |
| var previous = $.Zone__current; |
| $.Zone__current = zone; |
| return previous; |
| }, |
| _rootHandleUncaughtError: function($self, $parent, zone, error, stackTrace) { |
| var entry, t1, t2; |
| entry = new P._AsyncCallbackEntry(new P._rootHandleUncaughtError_closure(error, stackTrace), C.C__RootZone, null); |
| t1 = $._nextCallback; |
| if (t1 == null) { |
| P._scheduleAsyncCallback(entry); |
| $._lastPriorityCallback = $._lastCallback; |
| } else { |
| t2 = $._lastPriorityCallback; |
| if (t2 == null) { |
| entry.next = t1; |
| $._lastPriorityCallback = entry; |
| $._nextCallback = entry; |
| } else { |
| entry.next = t2.next; |
| t2.next = entry; |
| $._lastPriorityCallback = entry; |
| if (entry.next == null) |
| $._lastCallback = entry; |
| } |
| } |
| }, |
| _rootRun: function($self, $parent, zone, f) { |
| var old, t1; |
| if ($.Zone__current === zone) |
| return f.call$0(); |
| old = P.Zone__enter(zone); |
| try { |
| t1 = f.call$0(); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, |
| _rootRunUnary: function($self, $parent, zone, f, arg) { |
| var old, t1; |
| if ($.Zone__current === zone) |
| return f.call$1(arg); |
| old = P.Zone__enter(zone); |
| try { |
| t1 = f.call$1(arg); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, |
| _rootRunBinary: function($self, $parent, zone, f, arg1, arg2) { |
| var old, t1; |
| if ($.Zone__current === zone) |
| return f.call$2(arg1, arg2); |
| old = P.Zone__enter(zone); |
| try { |
| t1 = f.call$2(arg1, arg2); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, |
| _rootScheduleMicrotask: function($self, $parent, zone, f) { |
| var t1 = C.C__RootZone !== zone; |
| if (t1) { |
| f = zone.bindCallback$2$runGuarded(f, !(!t1 || C.C__RootZone.get$errorZone() === zone)); |
| zone = C.C__RootZone; |
| } |
| P._scheduleAsyncCallback(new P._AsyncCallbackEntry(f, zone, null)); |
| }, |
| _AsyncRun__initializeScheduleImmediate_internalCallback: { |
| "^": "Closure:2;_box_0", |
| call$1: function(_) { |
| var t1, f; |
| H.leaveJsAsync(); |
| t1 = this._box_0; |
| f = t1._captured_storedCallback_0; |
| t1._captured_storedCallback_0 = null; |
| f.call$0(); |
| } |
| }, |
| _AsyncRun__initializeScheduleImmediate_closure: { |
| "^": "Closure:4;_box_0,_captured_div_1,_captured_span_2", |
| call$1: function(callback) { |
| var t1, t2; |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| this._box_0._captured_storedCallback_0 = callback; |
| t1 = this._captured_div_1; |
| t2 = this._captured_span_2; |
| t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2); |
| } |
| }, |
| _AsyncRun__scheduleImmediateJsOverride_internalCallback: { |
| "^": "Closure:0;_captured_callback_0", |
| call$0: function() { |
| H.leaveJsAsync(); |
| this._captured_callback_0.call$0(); |
| } |
| }, |
| _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: { |
| "^": "Closure:0;_captured_callback_0", |
| call$0: function() { |
| H.leaveJsAsync(); |
| this._captured_callback_0.call$0(); |
| } |
| }, |
| _UncaughtAsyncError: { |
| "^": "AsyncError;error,stackTrace", |
| toString$0: function(_) { |
| var result, t1; |
| result = "Uncaught Error: " + H.S(this.error); |
| t1 = this.stackTrace; |
| return t1 != null ? result + ("\nStack Trace:\n" + H.S(t1)) : result; |
| }, |
| static: {_UncaughtAsyncError__getBestStackTrace: function(error, stackTrace) { |
| if (stackTrace != null) |
| return stackTrace; |
| if (!!J.getInterceptor(error).$isError) |
| return error.get$stackTrace(); |
| return; |
| }} |
| }, |
| Future: { |
| "^": "Object;" |
| }, |
| _Completer: { |
| "^": "Object;future<", |
| completeError$2: function(error, stackTrace) { |
| error = error != null ? error : new P.NullThrownError(); |
| if (this.future._state !== 0) |
| throw H.wrapException(new P.StateError("Future already completed")); |
| $.Zone__current.toString; |
| this._completeError$2(error, stackTrace); |
| } |
| }, |
| _AsyncCompleter: { |
| "^": "_Completer;future", |
| complete$1: function(value) { |
| var t1 = this.future; |
| if (t1._state !== 0) |
| throw H.wrapException(new P.StateError("Future already completed")); |
| t1._asyncComplete$1(value); |
| }, |
| _completeError$2: function(error, stackTrace) { |
| this.future._asyncCompleteError$2(error, stackTrace); |
| } |
| }, |
| _FutureListener: { |
| "^": "Object;_nextListener<,result<,state,callback,errorCallback", |
| get$_zone: function() { |
| return this.result._zone; |
| }, |
| get$handlesValue: function() { |
| return (this.state & 1) !== 0; |
| }, |
| get$hasErrorTest: function() { |
| return this.state === 6; |
| }, |
| get$handlesComplete: function() { |
| return this.state === 8; |
| }, |
| get$_onValue: function() { |
| return this.callback; |
| }, |
| get$_whenCompleteAction: function() { |
| return this.callback; |
| } |
| }, |
| _Future: { |
| "^": "Object;_state?,_zone<,_resultOrListeners", |
| get$_hasError: function() { |
| return this._state === 8; |
| }, |
| set$_isChained: function(value) { |
| if (value) |
| this._state = 2; |
| else |
| this._state = 0; |
| }, |
| then$2$onError: function(f, onError) { |
| var result, t1; |
| result = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| t1 = result._zone; |
| if (t1 !== C.C__RootZone) { |
| t1.toString; |
| if (onError != null) |
| onError = P._registerErrorHandler(onError, t1); |
| } |
| this._addListener$1(new P._FutureListener(null, result, onError == null ? 1 : 3, f, onError)); |
| return result; |
| }, |
| _markPendingCompletion$0: function() { |
| if (this._state !== 0) |
| throw H.wrapException(new P.StateError("Future already completed")); |
| this._state = 1; |
| }, |
| get$_value: function() { |
| return this._resultOrListeners; |
| }, |
| get$_error: function() { |
| return this._resultOrListeners; |
| }, |
| _setValue$1: function(value) { |
| this._state = 4; |
| this._resultOrListeners = value; |
| }, |
| _setErrorObject$1: function(error) { |
| this._state = 8; |
| this._resultOrListeners = error; |
| }, |
| _setError$2: function(error, stackTrace) { |
| this._setErrorObject$1(new P.AsyncError(error, stackTrace)); |
| }, |
| _addListener$1: function(listener) { |
| var t1; |
| if (this._state >= 4) { |
| t1 = this._zone; |
| t1.toString; |
| P._rootScheduleMicrotask(null, null, t1, 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 (!!t1.$isFuture) |
| if (!!t1.$is_Future) |
| P._Future__chainCoreFuture(value, this); |
| else |
| P._Future__chainForeignFuture(value, this); |
| else { |
| listeners = this._removeListeners$0(); |
| this._setValue$1(value); |
| P._Future__propagateToListeners(this, listeners); |
| } |
| }, |
| _completeWithValue$1: function(value) { |
| var listeners = this._removeListeners$0(); |
| this._setValue$1(value); |
| P._Future__propagateToListeners(this, listeners); |
| }, |
| _completeError$2: function(error, stackTrace) { |
| var listeners = this._removeListeners$0(); |
| this._setErrorObject$1(new P.AsyncError(error, stackTrace)); |
| P._Future__propagateToListeners(this, listeners); |
| }, |
| _asyncComplete$1: function(value) { |
| var t1; |
| if (value == null) |
| ; |
| else { |
| t1 = J.getInterceptor(value); |
| if (!!t1.$isFuture) { |
| if (!!t1.$is_Future) { |
| t1 = value._state; |
| if (t1 >= 4 && t1 === 8) { |
| this._markPendingCompletion$0(); |
| t1 = this._zone; |
| t1.toString; |
| P._rootScheduleMicrotask(null, null, t1, new P._Future__asyncComplete_closure(this, value)); |
| } else |
| P._Future__chainCoreFuture(value, this); |
| } else |
| P._Future__chainForeignFuture(value, this); |
| return; |
| } |
| } |
| this._markPendingCompletion$0(); |
| t1 = this._zone; |
| t1.toString; |
| P._rootScheduleMicrotask(null, null, t1, new P._Future__asyncComplete_closure0(this, value)); |
| }, |
| _asyncCompleteError$2: function(error, stackTrace) { |
| var t1; |
| this._markPendingCompletion$0(); |
| t1 = this._zone; |
| t1.toString; |
| P._rootScheduleMicrotask(null, null, t1, new P._Future__asyncCompleteError_closure(this, error, stackTrace)); |
| }, |
| $isFuture: 1, |
| static: {_Future__chainForeignFuture: function(source, target) { |
| var e, s, exception, t1; |
| target.set$_state(2); |
| try { |
| source.then$2$onError(new P._Future__chainForeignFuture_closure(target), new P._Future__chainForeignFuture_closure0(target)); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| P.scheduleMicrotask(new P._Future__chainForeignFuture_closure1(target, e, s)); |
| } |
| }, _Future__chainCoreFuture: function(source, target) { |
| var listener; |
| target._state = 2; |
| listener = new P._FutureListener(null, target, 0, null, null); |
| if (source._state >= 4) |
| P._Future__propagateToListeners(source, listener); |
| else |
| source._addListener$1(listener); |
| }, _Future__propagateToListeners: function(source, listeners) { |
| var t1, t2, t3, hasError, asyncError, t4, listeners0, sourceValue, zone, oldZone, chainSource, result; |
| t1 = {}; |
| t1._captured_source_4 = source; |
| for (t2 = source; true;) { |
| t3 = {}; |
| hasError = t2.get$_hasError(); |
| if (listeners == null) { |
| if (hasError) { |
| asyncError = t1._captured_source_4.get$_error(); |
| t2 = t1._captured_source_4.get$_zone(); |
| t3 = asyncError.get$error(); |
| t4 = asyncError.get$stackTrace(); |
| t2.toString; |
| P._rootHandleUncaughtError(null, null, t2, t3, t4); |
| } |
| return; |
| } |
| for (; listeners.get$_nextListener() != null; listeners = listeners0) { |
| listeners0 = listeners._nextListener; |
| listeners._nextListener = null; |
| P._Future__propagateToListeners(t1._captured_source_4, listeners); |
| } |
| t3._captured_listenerHasValue_1 = true; |
| sourceValue = hasError ? null : t1._captured_source_4.get$_value(); |
| t3._captured_listenerValueOrError_2 = sourceValue; |
| t3._captured_isPropagationAborted_3 = false; |
| t2 = !hasError; |
| if (!t2 || listeners.get$handlesValue() || listeners.state === 8) { |
| zone = listeners.get$_zone(); |
| if (hasError) { |
| t4 = t1._captured_source_4.get$_zone(); |
| t4.toString; |
| if (t4 == null ? zone != null : t4 !== zone) { |
| t4 = t4.get$errorZone(); |
| zone.toString; |
| t4 = t4 === zone; |
| } else |
| t4 = true; |
| t4 = !t4; |
| } else |
| t4 = false; |
| if (t4) { |
| asyncError = t1._captured_source_4.get$_error(); |
| t2 = t1._captured_source_4.get$_zone(); |
| t3 = asyncError.get$error(); |
| t4 = asyncError.get$stackTrace(); |
| t2.toString; |
| P._rootHandleUncaughtError(null, null, t2, t3, t4); |
| return; |
| } |
| oldZone = $.Zone__current; |
| if (oldZone == null ? zone != null : oldZone !== zone) |
| $.Zone__current = zone; |
| else |
| oldZone = null; |
| if (t2) { |
| if (listeners.get$handlesValue()) |
| t3._captured_listenerHasValue_1 = new P._Future__propagateToListeners_handleValueCallback(t3, listeners, sourceValue, zone).call$0(); |
| } else |
| new P._Future__propagateToListeners_handleError(t1, t3, listeners, zone).call$0(); |
| if (listeners.get$handlesComplete()) |
| new P._Future__propagateToListeners_handleWhenCompleteCallback(t1, t3, hasError, listeners, zone).call$0(); |
| if (oldZone != null) |
| $.Zone__current = oldZone; |
| if (t3._captured_isPropagationAborted_3) |
| return; |
| if (t3._captured_listenerHasValue_1 === true) { |
| t2 = t3._captured_listenerValueOrError_2; |
| t2 = (sourceValue == null ? t2 != null : sourceValue !== t2) && !!J.getInterceptor(t2).$isFuture; |
| } else |
| t2 = false; |
| if (t2) { |
| chainSource = t3._captured_listenerValueOrError_2; |
| result = listeners.result; |
| if (chainSource instanceof P._Future) |
| if (chainSource._state >= 4) { |
| result._state = 2; |
| t1._captured_source_4 = chainSource; |
| listeners = new P._FutureListener(null, result, 0, null, null); |
| t2 = chainSource; |
| continue; |
| } else |
| P._Future__chainCoreFuture(chainSource, result); |
| else |
| P._Future__chainForeignFuture(chainSource, result); |
| return; |
| } |
| } |
| result = listeners.result; |
| listeners = result._removeListeners$0(); |
| t2 = t3._captured_listenerHasValue_1; |
| t3 = t3._captured_listenerValueOrError_2; |
| if (t2 === true) { |
| result._state = 4; |
| result._resultOrListeners = t3; |
| } else { |
| result._state = 8; |
| result._resultOrListeners = t3; |
| } |
| t1._captured_source_4 = result; |
| t2 = result; |
| } |
| }} |
| }, |
| _Future__addListener_closure: { |
| "^": "Closure:0;_async$_captured_this_0,_captured_listener_1", |
| call$0: function() { |
| P._Future__propagateToListeners(this._async$_captured_this_0, this._captured_listener_1); |
| } |
| }, |
| _Future__chainForeignFuture_closure: { |
| "^": "Closure:2;_captured_target_0", |
| call$1: function(value) { |
| this._captured_target_0._completeWithValue$1(value); |
| } |
| }, |
| _Future__chainForeignFuture_closure0: { |
| "^": "Closure:5;_captured_target_1", |
| call$2: function(error, stackTrace) { |
| this._captured_target_1._completeError$2(error, stackTrace); |
| }, |
| call$1: function(error) { |
| return this.call$2(error, null); |
| } |
| }, |
| _Future__chainForeignFuture_closure1: { |
| "^": "Closure:0;_captured_target_2,_captured_e_3,_captured_s_4", |
| call$0: function() { |
| this._captured_target_2._completeError$2(this._captured_e_3, this._captured_s_4); |
| } |
| }, |
| _Future__asyncComplete_closure: { |
| "^": "Closure:0;_async$_captured_this_0,_captured_coreFuture_1", |
| call$0: function() { |
| P._Future__chainCoreFuture(this._captured_coreFuture_1, this._async$_captured_this_0); |
| } |
| }, |
| _Future__asyncComplete_closure0: { |
| "^": "Closure:0;_async$_captured_this_2,_captured_value_3", |
| call$0: function() { |
| this._async$_captured_this_2._completeWithValue$1(this._captured_value_3); |
| } |
| }, |
| _Future__asyncCompleteError_closure: { |
| "^": "Closure:0;_async$_captured_this_0,_captured_error_1,_captured_stackTrace_2", |
| call$0: function() { |
| this._async$_captured_this_0._completeError$2(this._captured_error_1, this._captured_stackTrace_2); |
| } |
| }, |
| _Future__propagateToListeners_handleValueCallback: { |
| "^": "Closure:6;_box_1,_captured_listener_3,_captured_sourceValue_4,_captured_zone_5", |
| call$0: function() { |
| var e, s, exception, t1; |
| try { |
| this._box_1._captured_listenerValueOrError_2 = this._captured_zone_5.runUnary$2(this._captured_listener_3.get$_onValue(), this._captured_sourceValue_4); |
| return true; |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| this._box_1._captured_listenerValueOrError_2 = new P.AsyncError(e, s); |
| return false; |
| } |
| } |
| }, |
| _Future__propagateToListeners_handleError: { |
| "^": "Closure:1;_box_2,_box_1,_captured_listener_6,_captured_zone_7", |
| call$0: function() { |
| var asyncError, matchesTest, test, e, s, errorCallback, e0, s0, t1, exception, t2, listenerValueOrError, t3, t4; |
| asyncError = this._box_2._captured_source_4.get$_error(); |
| matchesTest = true; |
| t1 = this._captured_listener_6; |
| if (t1.get$hasErrorTest()) { |
| test = t1.callback; |
| try { |
| matchesTest = this._captured_zone_7.runUnary$2(test, asyncError.get$error()); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| t1 = asyncError.get$error(); |
| t2 = e; |
| listenerValueOrError = (t1 == null ? t2 == null : t1 === t2) ? asyncError : new P.AsyncError(e, s); |
| t1 = this._box_1; |
| t1._captured_listenerValueOrError_2 = listenerValueOrError; |
| t1._captured_listenerHasValue_1 = false; |
| return; |
| } |
| } |
| errorCallback = t1.errorCallback; |
| if (matchesTest === true && errorCallback != null) { |
| try { |
| t1 = errorCallback; |
| t2 = H.getDynamicRuntimeType(); |
| t2 = H.buildFunctionType(t2, [t2, t2])._isTest$1(t1); |
| t3 = this._captured_zone_7; |
| t4 = this._box_1; |
| if (t2) |
| t4._captured_listenerValueOrError_2 = t3.runBinary$3(errorCallback, asyncError.get$error(), asyncError.get$stackTrace()); |
| else |
| t4._captured_listenerValueOrError_2 = t3.runUnary$2(errorCallback, asyncError.get$error()); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e0 = t1; |
| s0 = H.getTraceFromException(exception); |
| t1 = asyncError.get$error(); |
| t2 = e0; |
| listenerValueOrError = (t1 == null ? t2 == null : t1 === t2) ? asyncError : new P.AsyncError(e0, s0); |
| t1 = this._box_1; |
| t1._captured_listenerValueOrError_2 = listenerValueOrError; |
| t1._captured_listenerHasValue_1 = false; |
| return; |
| } |
| this._box_1._captured_listenerHasValue_1 = true; |
| } else { |
| t1 = this._box_1; |
| t1._captured_listenerValueOrError_2 = asyncError; |
| t1._captured_listenerHasValue_1 = false; |
| } |
| } |
| }, |
| _Future__propagateToListeners_handleWhenCompleteCallback: { |
| "^": "Closure:1;_box_2,_box_1,_captured_hasError_8,_captured_listener_9,_captured_zone_10", |
| call$0: function() { |
| var t1, e, s, completeResult, t2, exception, result; |
| t1 = {}; |
| t1._captured_completeResult_0 = null; |
| try { |
| completeResult = this._captured_zone_10.run$1(this._captured_listener_9.get$_whenCompleteAction()); |
| t1._captured_completeResult_0 = completeResult; |
| t2 = completeResult; |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| if (this._captured_hasError_8) { |
| t1 = this._box_2._captured_source_4.get$_error().get$error(); |
| t2 = e; |
| t2 = t1 == null ? t2 == null : t1 === t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| t2 = this._box_1; |
| if (t1) |
| t2._captured_listenerValueOrError_2 = this._box_2._captured_source_4.get$_error(); |
| else |
| t2._captured_listenerValueOrError_2 = new P.AsyncError(e, s); |
| t2._captured_listenerHasValue_1 = false; |
| return; |
| } |
| if (!!J.getInterceptor(t2).$isFuture) { |
| result = this._captured_listener_9.get$result(); |
| result.set$_isChained(true); |
| this._box_1._captured_isPropagationAborted_3 = true; |
| t2.then$2$onError(new P._Future__propagateToListeners_handleWhenCompleteCallback_closure(this._box_2, result), new P._Future__propagateToListeners_handleWhenCompleteCallback_closure0(t1, result)); |
| } |
| } |
| }, |
| _Future__propagateToListeners_handleWhenCompleteCallback_closure: { |
| "^": "Closure:2;_box_2,_captured_result_11", |
| call$1: function(ignored) { |
| P._Future__propagateToListeners(this._box_2._captured_source_4, new P._FutureListener(null, this._captured_result_11, 0, null, null)); |
| } |
| }, |
| _Future__propagateToListeners_handleWhenCompleteCallback_closure0: { |
| "^": "Closure:5;_box_0,_captured_result_12", |
| call$2: function(error, stackTrace) { |
| var t1, completeResult; |
| t1 = this._box_0; |
| if (!(t1._captured_completeResult_0 instanceof P._Future)) { |
| completeResult = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| t1._captured_completeResult_0 = completeResult; |
| completeResult._setError$2(error, stackTrace); |
| } |
| P._Future__propagateToListeners(t1._captured_completeResult_0, new P._FutureListener(null, this._captured_result_12, 0, null, null)); |
| }, |
| call$1: function(error) { |
| return this.call$2(error, null); |
| } |
| }, |
| _AsyncCallbackEntry: { |
| "^": "Object;callback,zone,next", |
| callback$0: function() { |
| return this.callback.call$0(); |
| } |
| }, |
| StreamSubscription: { |
| "^": "Object;" |
| }, |
| _EventSink: { |
| "^": "Object;" |
| }, |
| _DelayedEvent: { |
| "^": "Object;" |
| }, |
| _StreamIteratorImpl: { |
| "^": "Object;_subscription,_current,_futureOrPrefetch,_state?", |
| _clear$0: function() { |
| this._subscription = null; |
| this._futureOrPrefetch = null; |
| this._current = null; |
| this._state = 1; |
| }, |
| _onData$1: [function(data) { |
| var hasNext; |
| if (this._state === 2) { |
| this._current = data; |
| hasNext = this._futureOrPrefetch; |
| this._futureOrPrefetch = null; |
| this._state = 0; |
| hasNext._complete$1(true); |
| return; |
| } |
| this._subscription.pause$0(); |
| this._futureOrPrefetch = data; |
| this._state = 3; |
| }, "call$1", "get$_onData", 2, 0, function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, void: true, args: [T]}; |
| }, this.$receiver, "_StreamIteratorImpl"); |
| }], |
| _onError$2: [function(error, stackTrace) { |
| var hasNext; |
| if (this._state === 2) { |
| hasNext = this._futureOrPrefetch; |
| this._clear$0(); |
| hasNext._completeError$2(error, stackTrace); |
| return; |
| } |
| this._subscription.pause$0(); |
| this._futureOrPrefetch = new P.AsyncError(error, stackTrace); |
| this._state = 4; |
| }, function(error) { |
| return this._onError$2(error, null); |
| }, "_onError$1", "call$2", "call$1", "get$_onError", 2, 2, 7, 0], |
| _onDone$0: [function() { |
| if (this._state === 2) { |
| var hasNext = this._futureOrPrefetch; |
| this._clear$0(); |
| hasNext._complete$1(false); |
| return; |
| } |
| this._subscription.pause$0(); |
| this._futureOrPrefetch = null; |
| this._state = 5; |
| }, "call$0", "get$_onDone", 0, 0, 1] |
| }, |
| AsyncError: { |
| "^": "Object;error<,stackTrace<", |
| toString$0: function(_) { |
| return H.S(this.error); |
| }, |
| $isError: 1 |
| }, |
| _Zone: { |
| "^": "Object;" |
| }, |
| _rootHandleUncaughtError_closure: { |
| "^": "Closure:0;_captured_error_0,_captured_stackTrace_1", |
| call$0: function() { |
| var t1 = this._captured_error_0; |
| throw H.wrapException(new P._UncaughtAsyncError(t1, P._UncaughtAsyncError__getBestStackTrace(t1, this._captured_stackTrace_1))); |
| } |
| }, |
| _RootZone: { |
| "^": "_Zone;", |
| get$errorZone: function() { |
| return this; |
| }, |
| runGuarded$1: function(f) { |
| var e, s, t1, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| t1 = f.call$0(); |
| return t1; |
| } |
| t1 = P._rootRun(null, null, this, f); |
| return t1; |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| return P._rootHandleUncaughtError(null, null, this, e, s); |
| } |
| }, |
| bindCallback$2$runGuarded: function(f, runGuarded) { |
| if (runGuarded) |
| return new P._RootZone_bindCallback_closure(this, f); |
| else |
| return new P._RootZone_bindCallback_closure0(this, f); |
| }, |
| $index: function(_, key) { |
| return; |
| }, |
| run$1: function(f) { |
| if ($.Zone__current === C.C__RootZone) |
| return f.call$0(); |
| return P._rootRun(null, null, this, f); |
| }, |
| runUnary$2: function(f, arg) { |
| if ($.Zone__current === C.C__RootZone) |
| return f.call$1(arg); |
| return P._rootRunUnary(null, null, this, f, arg); |
| }, |
| runBinary$3: function(f, arg1, arg2) { |
| if ($.Zone__current === C.C__RootZone) |
| return f.call$2(arg1, arg2); |
| return P._rootRunBinary(null, null, this, f, arg1, arg2); |
| } |
| }, |
| _RootZone_bindCallback_closure: { |
| "^": "Closure:0;_async$_captured_this_0,_captured_f_1", |
| call$0: function() { |
| return this._async$_captured_this_0.runGuarded$1(this._captured_f_1); |
| } |
| }, |
| _RootZone_bindCallback_closure0: { |
| "^": "Closure:0;_async$_captured_this_2,_captured_f_3", |
| call$0: function() { |
| return this._async$_captured_this_2.run$1(this._captured_f_3); |
| } |
| } |
| }], ["dart.collection", "dart:collection",, P, { |
| "^": "", |
| LinkedHashMap__makeEmpty: function() { |
| return H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [null, null]); |
| }, |
| LinkedHashMap__makeLiteral: function(keyValuePairs) { |
| return H.fillLiteralMap(keyValuePairs, H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [null, null])); |
| }, |
| _defaultEquals: [function(a, b) { |
| return J.$eq(a, b); |
| }, "call$2", "_defaultEquals$closure", 4, 0, 12], |
| _defaultHashCode: [function(a) { |
| return J.get$hashCode$(a); |
| }, "call$1", "_defaultHashCode$closure", 2, 0, 13], |
| IterableBase_iterableToShortString: function(iterable, leftDelimiter, rightDelimiter) { |
| var parts, t1; |
| if (P._isToStringVisiting(iterable)) { |
| if (leftDelimiter === "(" && rightDelimiter === ")") |
| return "(...)"; |
| return leftDelimiter + "..." + rightDelimiter; |
| } |
| parts = []; |
| t1 = $.get$_toStringVisiting(); |
| t1.push(iterable); |
| try { |
| P._iterablePartsToStrings(iterable, parts); |
| } finally { |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t1.pop(); |
| } |
| t1 = P.StringBuffer__writeAll(leftDelimiter, parts, ", ") + rightDelimiter; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| IterableBase_iterableToFullString: function(iterable, leftDelimiter, rightDelimiter) { |
| var buffer, t1, t2; |
| if (P._isToStringVisiting(iterable)) |
| return leftDelimiter + "..." + rightDelimiter; |
| buffer = new P.StringBuffer(leftDelimiter); |
| t1 = $.get$_toStringVisiting(); |
| t1.push(iterable); |
| try { |
| t2 = buffer; |
| t2._contents = P.StringBuffer__writeAll(t2.get$_contents(), iterable, ", "); |
| } finally { |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t1.pop(); |
| } |
| t1 = buffer; |
| t1._contents = t1.get$_contents() + rightDelimiter; |
| t1 = buffer.get$_contents(); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _isToStringVisiting: function(o) { |
| var i, t1; |
| for (i = 0; t1 = $.get$_toStringVisiting(), i < t1.length; ++i) |
| if (o === t1[i]) |
| return true; |
| return false; |
| }, |
| _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) |
| return H.ioore(parts, 0); |
| ultimateString = parts.pop(); |
| if (0 >= parts.length) |
| return 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) |
| return 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) |
| return 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) |
| return 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) { |
| return H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [$K, $V]); |
| }, |
| LinkedHashMap_LinkedHashMap$identity: function($K, $V) { |
| return H.setRuntimeTypeInfo(new P._LinkedIdentityHashMap(0, null, null, null, null, null, 0), [$K, $V]); |
| }, |
| LinkedHashSet_LinkedHashSet: function(equals, hashCode, isValidKey, $E) { |
| return H.setRuntimeTypeInfo(new P._LinkedHashSet(0, null, null, null, null, null, 0), [$E]); |
| }, |
| Maps_mapToString: function(m) { |
| var t1, result, t2; |
| t1 = {}; |
| if (P._isToStringVisiting(m)) |
| return "{...}"; |
| result = new P.StringBuffer(""); |
| try { |
| $.get$_toStringVisiting().push(m); |
| t2 = result; |
| t2._contents = t2.get$_contents() + "{"; |
| t1._captured_first_0 = true; |
| J.forEach$1$a(m, new P.Maps_mapToString_closure(t1, result)); |
| t1 = result; |
| t1._contents = t1.get$_contents() + "}"; |
| } finally { |
| t1 = $.get$_toStringVisiting(); |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t1.pop(); |
| } |
| t1 = result.get$_contents(); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _LinkedIdentityHashMap: { |
| "^": "JsLinkedHashMap;__js_helper$_length,_strings,_nums,_rest,_first,_last,_modifications", |
| internalComputeHashCode$1: function(key) { |
| return H.objectHashCode(key) & 0x3ffffff; |
| }, |
| internalFindBucketIndex$2: function(bucket, key) { |
| var $length, i, t1; |
| if (bucket == null) |
| return -1; |
| $length = bucket.length; |
| for (i = 0; i < $length; ++i) { |
| t1 = bucket[i].get$hashMapCellKey(); |
| if (t1 == null ? key == null : t1 === key) |
| return i; |
| } |
| return -1; |
| } |
| }, |
| _LinkedHashSet: { |
| "^": "_HashSetBase;_collection$_length,_collection$_strings,_collection$_nums,_collection$_rest,_collection$_first,_collection$_last,_collection$_modifications", |
| get$iterator: function(_) { |
| var t1 = new P.LinkedHashSetIterator(this, this._collection$_modifications, null, null); |
| t1._cell = this._collection$_first; |
| return t1; |
| }, |
| get$length: function(_) { |
| return this._collection$_length; |
| }, |
| contains$1: function(_, object) { |
| var strings, nums; |
| if (typeof object === "string" && object !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) |
| return false; |
| return strings[object] != null; |
| } else if (typeof object === "number" && (object & 0x3ffffff) === object) { |
| nums = this._collection$_nums; |
| if (nums == null) |
| return false; |
| return nums[object] != null; |
| } else |
| return this._contains$1(object); |
| }, |
| _contains$1: function(object) { |
| var rest = this._collection$_rest; |
| if (rest == null) |
| return false; |
| return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object) >= 0; |
| }, |
| lookup$1: function(object) { |
| var t1; |
| if (!(typeof object === "string" && object !== "__proto__")) |
| t1 = typeof object === "number" && (object & 0x3ffffff) === object; |
| else |
| t1 = true; |
| if (t1) |
| return this.contains$1(0, object) ? object : null; |
| else |
| return this._lookup$1(object); |
| }, |
| _lookup$1: function(object) { |
| var rest, bucket, index; |
| rest = this._collection$_rest; |
| if (rest == null) |
| return; |
| bucket = rest[this._computeHashCode$1(object)]; |
| index = this._findBucketIndex$2(bucket, object); |
| if (index < 0) |
| return; |
| return J.$index$as(bucket, index).get$_element(); |
| }, |
| forEach$1: function(_, action) { |
| var cell, modifications; |
| cell = this._collection$_first; |
| modifications = this._collection$_modifications; |
| for (; cell != null;) { |
| action.call$1(cell._element); |
| if (modifications !== this._collection$_modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| cell = cell._next; |
| } |
| }, |
| add$1: function(_, element) { |
| var strings, nums; |
| if (typeof element === "string" && element !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) { |
| strings = P._LinkedHashSet__newHashTable(); |
| this._collection$_strings = strings; |
| } |
| return this._addHashTableEntry$2(strings, element); |
| } else if (typeof element === "number" && (element & 0x3ffffff) === element) { |
| nums = this._collection$_nums; |
| if (nums == null) { |
| nums = P._LinkedHashSet__newHashTable(); |
| this._collection$_nums = nums; |
| } |
| return this._addHashTableEntry$2(nums, element); |
| } else |
| return this._add$1(element); |
| }, |
| _add$1: function(element) { |
| var rest, hash, bucket; |
| rest = this._collection$_rest; |
| if (rest == null) { |
| rest = P._LinkedHashSet__newHashTable(); |
| this._collection$_rest = rest; |
| } |
| 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; |
| }, |
| remove$1: function(_, object) { |
| if (typeof object === "string" && object !== "__proto__") |
| return this._collection$_removeHashTableEntry$2(this._collection$_strings, object); |
| else if (typeof object === "number" && (object & 0x3ffffff) === object) |
| return this._collection$_removeHashTableEntry$2(this._collection$_nums, object); |
| else |
| return this._remove$1(object); |
| }, |
| _remove$1: function(object) { |
| var rest, bucket, index; |
| rest = this._collection$_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$_unlinkCell$1(bucket.splice(index, 1)[0]); |
| return true; |
| }, |
| clear$0: function(_) { |
| if (this._collection$_length > 0) { |
| this._collection$_last = null; |
| this._collection$_first = null; |
| this._collection$_rest = null; |
| this._collection$_nums = null; |
| this._collection$_strings = null; |
| this._collection$_length = 0; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| } |
| }, |
| _addHashTableEntry$2: function(table, element) { |
| if (table[element] != null) |
| return false; |
| table[element] = this._newLinkedCell$1(element); |
| return true; |
| }, |
| _collection$_removeHashTableEntry$2: function(table, element) { |
| var cell; |
| if (table == null) |
| return false; |
| cell = table[element]; |
| if (cell == null) |
| return false; |
| this._collection$_unlinkCell$1(cell); |
| delete table[element]; |
| return true; |
| }, |
| _newLinkedCell$1: function(element) { |
| var cell, last; |
| cell = new P.LinkedHashSetCell(element, null, null); |
| if (this._collection$_first == null) { |
| this._collection$_last = cell; |
| this._collection$_first = cell; |
| } else { |
| last = this._collection$_last; |
| cell._previous = last; |
| last._next = cell; |
| this._collection$_last = cell; |
| } |
| ++this._collection$_length; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| return cell; |
| }, |
| _collection$_unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$_previous(); |
| next = cell._next; |
| if (previous == null) |
| this._collection$_first = next; |
| else |
| previous._next = next; |
| if (next == null) |
| this._collection$_last = previous; |
| else |
| next._previous = previous; |
| --this._collection$_length; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| }, |
| _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].get$_element(), element)) |
| return i; |
| return -1; |
| }, |
| $isEfficientLengthIterable: 1, |
| static: {_LinkedHashSet__newHashTable: function() { |
| var table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| return table; |
| }} |
| }, |
| LinkedHashSetCell: { |
| "^": "Object;_element<,_next,_previous<" |
| }, |
| LinkedHashSetIterator: { |
| "^": "Object;_set,_collection$_modifications,_cell,_collection$_current", |
| get$current: function() { |
| return this._collection$_current; |
| }, |
| moveNext$0: function() { |
| var t1 = this._set; |
| if (this._collection$_modifications !== t1._collection$_modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| else { |
| t1 = this._cell; |
| if (t1 == null) { |
| this._collection$_current = null; |
| return false; |
| } else { |
| this._collection$_current = t1._element; |
| this._cell = t1._next; |
| return true; |
| } |
| } |
| } |
| }, |
| _HashSetBase: { |
| "^": "SetBase;" |
| }, |
| Maps_mapToString_closure: { |
| "^": "Closure:8;_collection$_box_0,_captured_result_1", |
| call$2: function(k, v) { |
| var t1, t2; |
| t1 = this._collection$_box_0; |
| if (!t1._captured_first_0) |
| this._captured_result_1._contents += ", "; |
| t1._captured_first_0 = false; |
| t1 = this._captured_result_1; |
| t2 = t1._contents += H.S(k); |
| t1._contents = t2 + ": "; |
| t1._contents += H.S(v); |
| } |
| }, |
| ListQueue: { |
| "^": "Iterable;_table,_head,_tail,_modificationCount", |
| get$iterator: function(_) { |
| return new P._ListQueueIterator(this, this._tail, this._modificationCount, this._head, null); |
| }, |
| 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) |
| return H.ioore(t1, i); |
| action.call$1(t1[i]); |
| if (modificationCount !== this._modificationCount) |
| H.throwExpression(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| get$isEmpty: function(_) { |
| return this._head === this._tail; |
| }, |
| get$length: function(_) { |
| return (this._tail - this._head & this._table.length - 1) >>> 0; |
| }, |
| clear$0: function(_) { |
| var i, t1, t2, t3, t4; |
| i = this._head; |
| t1 = this._tail; |
| if (i !== t1) { |
| for (t2 = this._table, t3 = t2.length, t4 = t3 - 1; i !== t1; i = (i + 1 & t4) >>> 0) { |
| if (i < 0 || i >= t3) |
| return H.ioore(t2, i); |
| t2[i] = null; |
| } |
| this._tail = 0; |
| this._head = 0; |
| ++this._modificationCount; |
| } |
| }, |
| toString$0: function(_) { |
| return P.IterableBase_iterableToFullString(this, "{", "}"); |
| }, |
| removeFirst$0: function() { |
| var t1, t2, t3, result; |
| t1 = this._head; |
| if (t1 === this._tail) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| ++this._modificationCount; |
| t2 = this._table; |
| t3 = t2.length; |
| if (t1 >= t3) |
| return H.ioore(t2, t1); |
| result = t2[t1]; |
| t2[t1] = null; |
| this._head = (t1 + 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 >= t3) |
| return H.ioore(t1, t2); |
| t1[t2] = element; |
| t3 = (t2 + 1 & t3 - 1) >>> 0; |
| this._tail = t3; |
| if (this._head === t3) |
| this._grow$0(); |
| ++this._modificationCount; |
| }, |
| _grow$0: function() { |
| var t1, newTable, t2, split; |
| t1 = Array(this._table.length * 2); |
| t1.fixed$length = Array; |
| newTable = H.setRuntimeTypeInfo(t1, [H.getTypeArgumentByIndex(this, 0)]); |
| t1 = this._table; |
| t2 = this._head; |
| split = t1.length - t2; |
| C.JSArray_methods.setRange$4(newTable, 0, split, t1, t2); |
| C.JSArray_methods.setRange$4(newTable, split, split + this._head, this._table, 0); |
| this._head = 0; |
| this._tail = this._table.length; |
| this._table = newTable; |
| }, |
| ListQueue$1: function(initialCapacity, $E) { |
| var t1 = Array(8); |
| t1.fixed$length = Array; |
| this._table = H.setRuntimeTypeInfo(t1, [$E]); |
| }, |
| $isEfficientLengthIterable: 1, |
| static: {ListQueue$: function(initialCapacity, $E) { |
| var t1 = H.setRuntimeTypeInfo(new P.ListQueue(null, 0, 0, 0), [$E]); |
| t1.ListQueue$1(initialCapacity, $E); |
| return t1; |
| }} |
| }, |
| _ListQueueIterator: { |
| "^": "Object;_queue,_end,_modificationCount,_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(new P.ConcurrentModificationError(t1)); |
| t2 = this._position; |
| if (t2 === this._end) { |
| this._collection$_current = null; |
| return false; |
| } |
| t1 = t1._table; |
| t3 = t1.length; |
| if (t2 >= t3) |
| return H.ioore(t1, t2); |
| this._collection$_current = t1[t2]; |
| this._position = (t2 + 1 & t3 - 1) >>> 0; |
| return true; |
| } |
| }, |
| SetMixin: { |
| "^": "Object;", |
| map$1: function(_, f) { |
| return H.setRuntimeTypeInfo(new H.EfficientLengthMappedIterable(this, f), [H.getTypeArgumentByIndex(this, 0), null]); |
| }, |
| toString$0: function(_) { |
| return P.IterableBase_iterableToFullString(this, "{", "}"); |
| }, |
| forEach$1: function(_, f) { |
| var t1; |
| for (t1 = this.get$iterator(this); t1.moveNext$0();) |
| f.call$1(t1._collection$_current); |
| }, |
| $isEfficientLengthIterable: 1 |
| }, |
| SetBase: { |
| "^": "SetMixin;" |
| } |
| }], ["dart.core", "dart:core",, P, { |
| "^": "", |
| _symbolToString: function(symbol) { |
| return H.Symbol_getName(symbol); |
| }, |
| Error_safeToString: function(object) { |
| if (typeof object === "number" || typeof object === "boolean" || null == object) |
| return J.toString$0(object); |
| if (typeof object === "string") |
| return JSON.stringify(object); |
| return P.Error__objectToString(object); |
| }, |
| Error__objectToString: function(object) { |
| var t1 = J.getInterceptor(object); |
| if (!!t1.$isClosure) |
| return t1.toString$0(object); |
| return H.Primitives_objectToString(object); |
| }, |
| Exception_Exception: function(message) { |
| return new P._ExceptionImplementation(message); |
| }, |
| identical: [function(a, b) { |
| return a == null ? b == null : a === b; |
| }, "call$2", "identical$closure", 4, 0, 14], |
| identityHashCode: [function(object) { |
| return H.objectHashCode(object); |
| }, "call$1", "identityHashCode$closure", 2, 0, 15], |
| List_List$from: function(elements, growable, $E) { |
| var list, t1; |
| list = H.setRuntimeTypeInfo([], [$E]); |
| for (t1 = J.get$iterator$a(elements); t1.moveNext$0();) |
| list.push(t1.get$current()); |
| if (growable) |
| return list; |
| list.fixed$length = Array; |
| return list; |
| }, |
| print: function(object) { |
| var line = H.S(object); |
| H.printString(line); |
| }, |
| NoSuchMethodError_toString_closure: { |
| "^": "Closure:9;_core$_box_0,_captured_sb_1", |
| call$2: function(key, value) { |
| this._captured_sb_1._contents += this._core$_box_0._captured_comma_0; |
| P._symbolToString(key); |
| } |
| }, |
| bool: { |
| "^": "Object;" |
| }, |
| "+bool": 0, |
| $double: { |
| "^": "num;" |
| }, |
| "+double": 0, |
| Duration: { |
| "^": "Object;_duration", |
| $add: function(_, other) { |
| return new P.Duration(C.JSInt_methods.$add(this._duration, other.get$_duration())); |
| }, |
| $lt: function(_, other) { |
| return C.JSInt_methods.$lt(this._duration, other.get$_duration()); |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (!(other instanceof P.Duration)) |
| 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 "-" + new P.Duration(-t2).toString$0(0); |
| twoDigitMinutes = t1.call$1(C.JSInt_methods.remainder$1(C.JSInt_methods._tdivFast$1(t2, 60000000), 60)); |
| twoDigitSeconds = t1.call$1(C.JSInt_methods.remainder$1(C.JSInt_methods._tdivFast$1(t2, 1000000), 60)); |
| sixDigitUs = new P.Duration_toString_sixDigits().call$1(C.JSInt_methods.remainder$1(t2, 1000000)); |
| return "" + C.JSInt_methods._tdivFast$1(t2, 3600000000) + ":" + H.S(twoDigitMinutes) + ":" + H.S(twoDigitSeconds) + "." + H.S(sixDigitUs); |
| } |
| }, |
| Duration_toString_sixDigits: { |
| "^": "Closure:10;", |
| call$1: function(n) { |
| if (n >= 100000) |
| return "" + n; |
| if (n >= 10000) |
| return "0" + n; |
| if (n >= 1000) |
| return "00" + n; |
| if (n >= 100) |
| return "000" + n; |
| if (n >= 10) |
| return "0000" + n; |
| return "00000" + n; |
| } |
| }, |
| Duration_toString_twoDigits: { |
| "^": "Closure:10;", |
| call$1: function(n) { |
| if (n >= 10) |
| return "" + n; |
| return "0" + n; |
| } |
| }, |
| Error: { |
| "^": "Object;", |
| get$stackTrace: function() { |
| return H.getTraceFromException(this.$thrownJsError); |
| } |
| }, |
| NullThrownError: { |
| "^": "Error;", |
| toString$0: function(_) { |
| return "Throw of null."; |
| } |
| }, |
| ArgumentError: { |
| "^": "Error;_hasValue,invalidValue,name,message", |
| get$_errorName: function() { |
| return "Invalid argument" + (!this._hasValue ? "(s)" : ""); |
| }, |
| get$_errorExplanation: function() { |
| return ""; |
| }, |
| toString$0: function(_) { |
| var t1, nameString, message, prefix, explanation, errorValue; |
| t1 = this.name; |
| nameString = t1 != null ? " (" + H.S(t1) + ")" : ""; |
| t1 = this.message; |
| message = t1 == null ? "" : ": " + H.S(t1); |
| prefix = this.get$_errorName() + nameString + message; |
| if (!this._hasValue) |
| return prefix; |
| explanation = this.get$_errorExplanation(); |
| errorValue = P.Error_safeToString(this.invalidValue); |
| return prefix + explanation + ": " + H.S(errorValue); |
| }, |
| static: {ArgumentError$: function(message) { |
| return new P.ArgumentError(false, null, null, message); |
| }} |
| }, |
| RangeError: { |
| "^": "ArgumentError;start,end,_hasValue,invalidValue,name,message", |
| get$_errorName: function() { |
| return "RangeError"; |
| }, |
| get$_errorExplanation: function() { |
| var t1, explanation, t2; |
| t1 = this.start; |
| if (t1 == null) { |
| t1 = this.end; |
| explanation = t1 != null ? ": Not less than or equal to " + H.S(t1) : ""; |
| } else { |
| t2 = this.end; |
| if (t2 == null) |
| explanation = ": Not greater than or equal to " + H.S(t1); |
| else { |
| if (typeof t2 !== "number") |
| return t2.$gt(); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| if (t2 > t1) |
| explanation = ": Not in range " + t1 + ".." + t2 + ", inclusive"; |
| else |
| explanation = t2 < t1 ? ": Valid value range is empty" : ": Only valid value is " + t1; |
| } |
| } |
| return explanation; |
| }, |
| static: {RangeError$value: function(value, $name, message) { |
| return new P.RangeError(null, null, true, value, $name, "Value not in range"); |
| }, RangeError$range: function(invalidValue, minValue, maxValue, $name, message) { |
| return new P.RangeError(minValue, maxValue, true, invalidValue, $name, "Invalid value"); |
| }, RangeError_checkValidRange: function(start, end, $length, startName, endName, message) { |
| if (0 > start || start > $length) |
| throw H.wrapException(P.RangeError$range(start, 0, $length, "start", message)); |
| if (start > end || end > $length) |
| throw H.wrapException(P.RangeError$range(end, start, $length, "end", message)); |
| return end; |
| }} |
| }, |
| IndexError: { |
| "^": "ArgumentError;indexable,length>,_hasValue,invalidValue,name,message", |
| get$_errorName: function() { |
| return "RangeError"; |
| }, |
| get$_errorExplanation: function() { |
| P.Error_safeToString(this.indexable); |
| var explanation = ": index should be less than " + H.S(this.length); |
| return J.$lt$n(this.invalidValue, 0) ? ": index must not be negative" : explanation; |
| }, |
| static: {IndexError$: function(invalidValue, indexable, $name, message, $length) { |
| var t1 = $length != null ? $length : J.get$length$as(indexable); |
| return new P.IndexError(indexable, t1, true, invalidValue, $name, "Index out of range"); |
| }} |
| }, |
| UnsupportedError: { |
| "^": "Error;message", |
| toString$0: function(_) { |
| return "Unsupported operation: " + this.message; |
| } |
| }, |
| StateError: { |
| "^": "Error;message", |
| toString$0: function(_) { |
| return "Bad state: " + this.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)) + "."; |
| } |
| }, |
| StackOverflowError: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "Stack Overflow"; |
| }, |
| get$stackTrace: function() { |
| return; |
| }, |
| $isError: 1 |
| }, |
| CyclicInitializationError: { |
| "^": "Error;variableName", |
| toString$0: function(_) { |
| return "Reading static variable '" + this.variableName + "' during its initialization"; |
| } |
| }, |
| _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; |
| } |
| }, |
| $int: { |
| "^": "num;" |
| }, |
| "+int": 0, |
| Iterable: { |
| "^": "Object;", |
| map$1: function(_, f) { |
| return H.MappedIterable_MappedIterable(this, f, H.getRuntimeTypeArgument(this, "Iterable", 0), null); |
| }, |
| forEach$1: function(_, f) { |
| var t1; |
| for (t1 = this.get$iterator(this); t1.moveNext$0();) |
| f.call$1(t1.get$current()); |
| }, |
| toList$1$growable: function(_, growable) { |
| return P.List_List$from(this, growable, H.getRuntimeTypeArgument(this, "Iterable", 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, elementIndex, element; |
| if (index < 0) |
| H.throwExpression(P.RangeError$range(index, 0, null, "index", null)); |
| for (t1 = this.get$iterator(this), elementIndex = 0; t1.moveNext$0();) { |
| element = t1.get$current(); |
| if (index === elementIndex) |
| return element; |
| ++elementIndex; |
| } |
| throw H.wrapException(P.IndexError$(index, this, "index", null, elementIndex)); |
| }, |
| toString$0: function(_) { |
| return P.IterableBase_iterableToShortString(this, "(", ")"); |
| } |
| }, |
| Iterator: { |
| "^": "Object;" |
| }, |
| List: { |
| "^": "Object;", |
| $isEfficientLengthIterable: 1 |
| }, |
| "+List": 0, |
| Null: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "null"; |
| } |
| }, |
| "+Null": 0, |
| num: { |
| "^": "Object;" |
| }, |
| "+num": 0, |
| 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;" |
| }, |
| String: { |
| "^": "Object;" |
| }, |
| "+String": 0, |
| StringBuffer: { |
| "^": "Object;_contents<", |
| get$length: function(_) { |
| return this._contents.length; |
| }, |
| toString$0: function(_) { |
| var t1 = this._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| static: {StringBuffer__writeAll: function(string, objects, separator) { |
| var iterator = J.get$iterator$a(objects); |
| if (!iterator.moveNext$0()) |
| return string; |
| if (separator.length === 0) { |
| do |
| string += H.S(iterator.get$current()); |
| while (iterator.moveNext$0()); |
| } else { |
| string += H.S(iterator.get$current()); |
| for (; iterator.moveNext$0();) |
| string = string + separator + H.S(iterator.get$current()); |
| } |
| return string; |
| }} |
| }, |
| Symbol: { |
| "^": "Object;" |
| } |
| }], ["dart.isolate", "dart:isolate",, P, { |
| "^": "", |
| Capability: { |
| "^": "Object;" |
| } |
| }], ["dart2js._js_primitives", "dart:_js_primitives",, H, { |
| "^": "", |
| printString: function(string) { |
| if (typeof dartPrint == "function") { |
| dartPrint(string); |
| return; |
| } |
| if (typeof console == "object" && typeof console.log != "undefined") { |
| console.log(string); |
| return; |
| } |
| if (typeof window == "object") |
| return; |
| if (typeof print == "function") { |
| print(string); |
| return; |
| } |
| throw "Unable to print message: " + String(string); |
| } |
| }], ["", "test.dart",, V, { |
| "^": "", |
| main: [function() { |
| var $goto = 0, completer = new P.Completer_Completer(), $returnValue, handler = 2, currentError; |
| function main(errorCode, result) { |
| if (errorCode === 1) { |
| currentError = result; |
| $goto = handler; |
| } |
| while (true) |
| switch ($goto) { |
| case 0: |
| // Function start |
| // goto return |
| $goto = 1; |
| break; |
| case 1: |
| // return |
| return H.asyncHelper($returnValue, 0, completer, null); |
| case 2: |
| // rethrow |
| return H.asyncHelper(currentError, 1, completer); |
| } |
| } |
| return H.asyncHelper(null, main, completer, null); |
| }, "call$0", "main$closure", 0, 0, 16] |
| }, 1]]; |
| setupProgram(dart, 0); |
| // 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 (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return receiver; |
| }; |
| J.getInterceptor$a = function(receiver) { |
| if (receiver == null) |
| return receiver; |
| if (receiver.constructor == Array) |
| return J.JSArray.prototype; |
| if (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return receiver; |
| }; |
| J.getInterceptor$as = function(receiver) { |
| if (typeof receiver == "string") |
| return J.JSString.prototype; |
| if (receiver == null) |
| return receiver; |
| if (receiver.constructor == Array) |
| return J.JSArray.prototype; |
| if (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return 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$ns = function(receiver) { |
| if (typeof receiver == "number") |
| return J.JSNumber.prototype; |
| if (typeof receiver == "string") |
| return J.JSString.prototype; |
| if (receiver == null) |
| return receiver; |
| if (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return receiver; |
| }; |
| J.$add$ns = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver + a0; |
| return J.getInterceptor$ns(receiver).$add(receiver, a0); |
| }; |
| 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.$index$as = function(receiver, a0) { |
| if (receiver.constructor == Array || typeof receiver == "string") |
| if (a0 >>> 0 === a0 && a0 < receiver.length) |
| return receiver[a0]; |
| return J.getInterceptor$as(receiver).$index(receiver, a0); |
| }; |
| J.$lt$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver < a0; |
| return J.getInterceptor$n(receiver).$lt(receiver, a0); |
| }; |
| J.elementAt$1$a = function(receiver, a0) { |
| return J.getInterceptor$a(receiver).elementAt$1(receiver, a0); |
| }; |
| J.forEach$1$a = function(receiver, a0) { |
| return J.getInterceptor$a(receiver).forEach$1(receiver, a0); |
| }; |
| J.get$hashCode$ = function(receiver) { |
| return J.getInterceptor(receiver).get$hashCode(receiver); |
| }; |
| J.get$iterator$a = function(receiver) { |
| return J.getInterceptor$a(receiver).get$iterator(receiver); |
| }; |
| J.get$length$as = function(receiver) { |
| return J.getInterceptor$as(receiver).get$length(receiver); |
| }; |
| J.map$1$a = function(receiver, a0) { |
| return J.getInterceptor$a(receiver).map$1(receiver, a0); |
| }; |
| J.toString$0 = function(receiver) { |
| return J.getInterceptor(receiver).toString$0(receiver); |
| }; |
| C.JSArray_methods = J.JSArray.prototype; |
| C.JSInt_methods = J.JSInt.prototype; |
| C.JSString_methods = J.JSString.prototype; |
| C.C_DynamicRuntimeType = new H.DynamicRuntimeType(); |
| C.C__RootZone = new P._RootZone(); |
| C.Duration_0 = new P.Duration(0); |
| C.JS_CONST_8ZY = function getTagFallback(o) { |
| var constructor = o.constructor; |
| if (typeof constructor == "function") { |
| var name = constructor.name; |
| if (typeof name == "string" && |
| name.length > 2 && |
| name !== "Object" && |
| name !== "Function.prototype") { |
| return name; |
| } |
| } |
| var s = Object.prototype.toString.call(o); |
| return s.substring(8, s.length - 1); |
| }; |
| { |
| init.isHunkLoaded = function(hunkHash) { |
| return !!$dart_deferred_initializers[hunkHash]; |
| }; |
| init.deferredInitialized = new Object(null); |
| init.isHunkInitialized = function(hunkHash) { |
| return init.deferredInitialized[hunkHash]; |
| }; |
| init.initializeLoadedHunk = function(hunkHash) { |
| $dart_deferred_initializers[hunkHash](globalsHolder, $); |
| init.deferredInitialized[hunkHash] = true; |
| }; |
| } |
| init.deferredLibraryUris = {}; |
| init.deferredLibraryHashes = {}; |
| $.Primitives_mirrorFunctionCacheName = "$cachedFunction"; |
| $.Primitives_mirrorInvokeCacheName = "$cachedInvocation"; |
| $.Closure_functionCounter = 0; |
| $.BoundClosure_selfFieldNameCache = null; |
| $.BoundClosure_receiverFieldNameCache = null; |
| $._nextCallback = null; |
| $._lastCallback = null; |
| $._lastPriorityCallback = null; |
| $._isInCallbackLoop = false; |
| $.Zone__current = C.C__RootZone; |
| $.Expando__keyCount = 0; |
| (function(lazies) { |
| var descriptorLength = 4; |
| for (var i = 0; i < lazies.length; i += descriptorLength) { |
| var fieldName = lazies[i]; |
| var getterName = lazies[i + 1]; |
| var lazyValue = lazies[i + 2]; |
| var staticName = lazies[i + 3]; |
| Isolate.$lazy(fieldName, getterName, lazyValue, staticName); |
| } |
| })(["IsolateNatives_thisScript", "get$IsolateNatives_thisScript", function() { |
| return H.IsolateNatives_computeThisScript(); |
| }, "thisScript", "IsolateNatives_workerIds", "get$IsolateNatives_workerIds", function() { |
| return new P.Expando(null); |
| }, "workerIds", "TypeErrorDecoder_noSuchMethodPattern", "get$TypeErrorDecoder_noSuchMethodPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({toString: function() { |
| return "$receiver$"; |
| }})); |
| }, "noSuchMethodPattern", "TypeErrorDecoder_notClosurePattern", "get$TypeErrorDecoder_notClosurePattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({$method$: null, toString: function() { |
| return "$receiver$"; |
| }})); |
| }, "notClosurePattern", "TypeErrorDecoder_nullCallPattern", "get$TypeErrorDecoder_nullCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null)); |
| }, "nullCallPattern", "TypeErrorDecoder_nullLiteralCallPattern", "get$TypeErrorDecoder_nullLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| null.$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "nullLiteralCallPattern", "TypeErrorDecoder_undefinedCallPattern", "get$TypeErrorDecoder_undefinedCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0)); |
| }, "undefinedCallPattern", "TypeErrorDecoder_undefinedLiteralCallPattern", "get$TypeErrorDecoder_undefinedLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| (void 0).$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "undefinedLiteralCallPattern", "TypeErrorDecoder_nullPropertyPattern", "get$TypeErrorDecoder_nullPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null)); |
| }, "nullPropertyPattern", "TypeErrorDecoder_nullLiteralPropertyPattern", "get$TypeErrorDecoder_nullLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| null.$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "nullLiteralPropertyPattern", "TypeErrorDecoder_undefinedPropertyPattern", "get$TypeErrorDecoder_undefinedPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0)); |
| }, "undefinedPropertyPattern", "TypeErrorDecoder_undefinedLiteralPropertyPattern", "get$TypeErrorDecoder_undefinedLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| (void 0).$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "undefinedLiteralPropertyPattern", "_AsyncRun_scheduleImmediateClosure", "get$_AsyncRun_scheduleImmediateClosure", function() { |
| return P._AsyncRun__initializeScheduleImmediate(); |
| }, "scheduleImmediateClosure", "_toStringVisiting", "get$_toStringVisiting", function() { |
| return []; |
| }, "_toStringVisiting"]); |
| ; |
| |
| { |
| init.metadata = [null]; |
| init.types = [{func: 1}, {func: 1, void: true}, {func: 1, args: [,]}, {func: 1, args: [, P.StackTrace]}, {func: 1, args: [{func: 1, void: true}]}, {func: 1, args: [,], opt: [,]}, {func: 1, ret: P.bool}, {func: 1, void: true, args: [P.Object], opt: [P.StackTrace]}, {func: 1, args: [,,]}, {func: 1, args: [P.Symbol,,]}, {func: 1, ret: P.String, args: [P.$int]}, {func: 1, void: true, args: [{func: 1, void: true}]}, {func: 1, ret: P.bool, args: [,,]}, {func: 1, ret: P.$int, args: [,]}, {func: 1, ret: P.bool, args: [P.Object, P.Object]}, {func: 1, ret: P.$int, args: [P.Object]}, {func: 1, ret: P.Future}]; |
| } |
| |
| $ = null; |
| Isolate = Isolate.$finishIsolateConstructor(Isolate); |
| $ = new Isolate(); |
| function convertToFastObject(properties) { |
| function MyClass() { |
| } |
| MyClass.prototype = properties; |
| new MyClass(); |
| return properties; |
| } |
| ; |
| function convertToSlowObject(properties) { |
| properties.__MAGIC_SLOW_PROPERTY = 1; |
| delete properties.__MAGIC_SLOW_PROPERTY; |
| 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 init() { |
| Isolate.$isolateProperties = Object.create(null); |
| init.allClasses = Object.create(null); |
| init.getTypeFromName = function(name) { |
| return init.allClasses[name]; |
| }; |
| init.interceptorsByTag = Object.create(null); |
| init.leafTags = Object.create(null); |
| init.finishedClasses = Object.create(null); |
| Isolate.$lazy = function(fieldName, getterName, lazyValue, staticName, prototype) { |
| if (!init.lazies) |
| init.lazies = Object.create(null); |
| init.lazies[fieldName] = getterName; |
| prototype = prototype || Isolate.$isolateProperties; |
| var sentinelUndefined = {}; |
| var sentinelInProgress = {}; |
| prototype[fieldName] = sentinelUndefined; |
| prototype[getterName] = function() { |
| var result = this[fieldName]; |
| try { |
| if (result === sentinelUndefined) { |
| this[fieldName] = sentinelInProgress; |
| try { |
| result = this[fieldName] = lazyValue(); |
| } finally { |
| if (result === sentinelUndefined) |
| this[fieldName] = null; |
| } |
| } else |
| if (result === sentinelInProgress) |
| H.throwCyclicInit(staticName || fieldName); |
| return result; |
| } finally { |
| this[getterName] = function() { |
| return this[fieldName]; |
| }; |
| } |
| }; |
| }; |
| Isolate.$finishIsolateConstructor = function(oldIsolate) { |
| var isolateProperties = oldIsolate.$isolateProperties; |
| function Isolate() { |
| var staticNames = Object.keys(isolateProperties); |
| for (var i = 0; i < staticNames.length; i++) { |
| var staticName = staticNames[i]; |
| this[staticName] = isolateProperties[staticName]; |
| } |
| var lazies = init.lazies; |
| var lazyInitializers = lazies ? Object.keys(lazies) : []; |
| for (var i = 0; i < lazyInitializers.length; i++) |
| this[lazies[lazyInitializers[i]]] = null; |
| function ForceEfficientMap() { |
| } |
| ForceEfficientMap.prototype = this; |
| new ForceEfficientMap(); |
| for (var i = 0; i < lazyInitializers.length; i++) { |
| var lazyInitName = lazies[lazyInitializers[i]]; |
| this[lazyInitName] = isolateProperties[lazyInitName]; |
| } |
| } |
| Isolate.prototype = oldIsolate.prototype; |
| Isolate.prototype.constructor = Isolate; |
| Isolate.$isolateProperties = isolateProperties; |
| return Isolate; |
| }; |
| } |
| ;// 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(a) { |
| H.startRootIsolate(V.main$closure(), a); |
| }, []); |
| else |
| (function(a) { |
| H.startRootIsolate(V.main$closure(), a); |
| })([]); |
| }); |
| ; |
| // END invoke [main]. |
| })() |
| |
| //# sourceMappingURL=out.js.map |