| // Generated by dart2js, the Dart to JavaScript compiler version: 1.13.0-dev.3.1. |
| // 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() { |
| // /* ::norenaming:: */ |
| 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; |
| } |
| // The global objects start as so-called "slow objects". For V8, this |
| // means that it won't try to make map transitions as we add properties |
| // to these objects. Later on, we attempt to turn these objects into |
| // fast objects by calling "convertToFastObject" (see |
| // [emitConvertToFastObjectFunction]). |
| 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(); |
| // Constructors are generated at runtime. |
| 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 && superclass.indexOf("+") > 0) { |
| var s = superclass.split("+"); |
| superclass = s[0]; |
| var mixinClass = s[1]; |
| finishClass(mixinClass); |
| var mixin = allClasses[mixinClass]; |
| var mixinPrototype = mixin.prototype; |
| var clsPrototype = allClasses[cls].prototype; |
| var properties = Object.keys(mixinPrototype); |
| for (var i = 0; i < properties.length; i++) { |
| var d = properties[i]; |
| if (!hasOwnProperty.call(clsPrototype, d)) |
| clsPrototype[d] = mixinPrototype[d]; |
| } |
| } |
| 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 (mixinPrototype) |
| prototype.$deferredAction = mixinDeferredActionHelper(mixinPrototype, prototype); |
| if (Object.prototype.hasOwnProperty.call(prototype, "%")) { |
| var nativeSpec = prototype["%"].split(";"); |
| if (nativeSpec[0]) { |
| var tags = nativeSpec[0].split("|"); |
| for (var i = 0; i < tags.length; i++) { |
| init.interceptorsByTag[tags[i]] = constructor; |
| init.leafTags[tags[i]] = true; |
| } |
| } |
| if (nativeSpec[1]) { |
| tags = nativeSpec[1].split("|"); |
| if (nativeSpec[2]) { |
| var subclasses = nativeSpec[2].split("|"); |
| for (var i = 0; i < subclasses.length; i++) { |
| var subclass = allClasses[subclasses[i]]; |
| subclass.$nativeSuperclassTag = tags[0]; |
| } |
| } |
| for (i = 0; i < tags.length; i++) { |
| init.interceptorsByTag[tags[i]] = constructor; |
| init.leafTags[tags[i]] = false; |
| } |
| } |
| prototype.$deferredAction(); |
| } |
| 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 mixinDeferredActionHelper(mixinPrototype, targetPrototype) { |
| var chain; |
| if (targetPrototype.hasOwnProperty("$deferredAction")) |
| chain = targetPrototype.$deferredAction; |
| return function foo() { |
| var prototype = this; |
| while (!prototype.hasOwnProperty("$deferredAction")) |
| prototype = prototype.__proto__; |
| if (chain) |
| prototype.$deferredAction = chain; |
| else { |
| delete prototype.$deferredAction; |
| convertToFastObject(prototype); |
| } |
| mixinPrototype.$deferredAction(); |
| 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); |
| } |
| Isolate.functionThatReturnsNull = function() { |
| }; |
| var dart = [["_foreign_helper", "dart:_foreign_helper",, H, { |
| "^": "", |
| JS_CONST: { |
| "^": "Object;code" |
| } |
| }], ["_interceptors", "dart:_interceptors",, J, { |
| "^": "", |
| getInterceptor: function(object) { |
| return void 0; |
| }, |
| makeDispatchRecord: function(interceptor, proto, extension, indexability) { |
| return {i: interceptor, p: proto, e: extension, x: indexability}; |
| }, |
| getNativeInterceptor: function(object) { |
| var record, proto, objectProto, interceptor; |
| record = object[init.dispatchPropertyName]; |
| if (record == null) |
| if ($.initNativeDispatchFlag == null) { |
| H.initNativeDispatch(); |
| record = object[init.dispatchPropertyName]; |
| } |
| if (record != null) { |
| proto = record.p; |
| if (false === proto) |
| return record.i; |
| if (true === proto) |
| return object; |
| objectProto = Object.getPrototypeOf(object); |
| if (proto === objectProto) |
| return record.i; |
| if (record.e === objectProto) |
| throw H.wrapException(new P.UnimplementedError("Return interceptor for " + H.S(proto(object, record)))); |
| } |
| interceptor = H.lookupAndCacheInterceptor(object); |
| if (interceptor == null) { |
| proto = Object.getPrototypeOf(object); |
| if (proto == null || proto === Object.prototype) |
| return C.PlainJavaScriptObject_methods; |
| else |
| return C.UnknownJavaScriptObject_methods; |
| } |
| return interceptor; |
| }, |
| Interceptor: { |
| "^": "Object;", |
| $eq: function(receiver, other) { |
| return receiver === other; |
| }, |
| get$hashCode: function(receiver) { |
| return H.Primitives_objectHashCode(receiver); |
| }, |
| toString$0: ["super$Interceptor$toString", function(receiver) { |
| return H.Primitives_objectToHumanReadableString(receiver); |
| }], |
| "%": "DOMImplementation|MediaError|MediaKeyError|Range|SVGAnimatedEnumeration|SVGAnimatedLength|SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedString" |
| }, |
| 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)); |
| }, |
| add$1: function(receiver, value) { |
| this.checkGrowable$1(receiver, "add"); |
| receiver.push(value); |
| }, |
| removeAt$1: function(receiver, index) { |
| this.checkGrowable$1(receiver, "removeAt"); |
| if (index >= receiver.length) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| return receiver.splice(index, 1)[0]; |
| }, |
| insert$2: function(receiver, index, value) { |
| this.checkGrowable$1(receiver, "insert"); |
| if (index > receiver.length) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| receiver.splice(index, 0, value); |
| }, |
| insertAll$2: function(receiver, index, iterable) { |
| var insertionLength, end; |
| this.checkGrowable$1(receiver, "insertAll"); |
| P.RangeError_checkValueInInterval(index, 0, receiver.length, "index", null); |
| insertionLength = iterable.length; |
| this.set$length(receiver, receiver.length + insertionLength); |
| end = index + insertionLength; |
| this.setRange$4(receiver, end, receiver.length, receiver, index); |
| this.setRange$3(receiver, index, end, iterable); |
| }, |
| removeLast$0: function(receiver) { |
| this.checkGrowable$1(receiver, "removeLast"); |
| if (receiver.length === 0) |
| throw H.wrapException(H.diagnoseIndexError(receiver, -1)); |
| return receiver.pop(); |
| }, |
| where$1: function(receiver, f) { |
| return H.setRuntimeTypeInfo(new H.WhereIterable(receiver, f), [H.getTypeArgumentByIndex(receiver, 0)]); |
| }, |
| 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]); |
| }, |
| join$1: function(receiver, separator) { |
| var t1, list, i, t2; |
| t1 = receiver.length; |
| list = new Array(t1); |
| list.fixed$length = Array; |
| for (i = 0; i < receiver.length; ++i) { |
| t2 = H.S(receiver[i]); |
| if (i >= t1) |
| return H.ioore(list, i); |
| list[i] = t2; |
| } |
| return list.join(separator); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| sublist$2: function(receiver, start, end) { |
| if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, "start", null)); |
| if (end < start || end > receiver.length) |
| throw H.wrapException(P.RangeError$range(end, start, receiver.length, "end", null)); |
| if (start === end) |
| return H.setRuntimeTypeInfo([], [H.getTypeArgumentByIndex(receiver, 0)]); |
| return H.setRuntimeTypeInfo(receiver.slice(start, end), [H.getTypeArgumentByIndex(receiver, 0)]); |
| }, |
| get$first: function(receiver) { |
| if (receiver.length > 0) |
| return receiver[0]; |
| throw H.wrapException(H.IterableElementError_noElement()); |
| }, |
| get$last: function(receiver) { |
| var t1 = receiver.length; |
| if (t1 > 0) |
| return receiver[t1 - 1]; |
| 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 < 0) |
| H.throwExpression(P.RangeError$range(skipCount, 0, null, "skipCount", null)); |
| if (skipCount + $length > iterable.length) |
| throw H.wrapException(H.IterableElementError_tooFew()); |
| if (skipCount < start) |
| for (i = $length - 1; i >= 0; --i) { |
| t1 = skipCount + i; |
| if (t1 < 0 || 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 < 0 || t1 >= iterable.length) |
| return H.ioore(iterable, t1); |
| receiver[start + i] = iterable[t1]; |
| } |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, |
| any$1: function(receiver, test) { |
| var end, i; |
| end = receiver.length; |
| for (i = 0; i < end; ++i) { |
| if (test.call$1(receiver[i]) === true) |
| return true; |
| if (receiver.length !== end) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| return false; |
| }, |
| indexOf$2: function(receiver, element, start) { |
| var i, t1; |
| if (start >= receiver.length) |
| return -1; |
| if (start < 0) |
| start = 0; |
| for (i = start; t1 = receiver.length, i < t1; ++i) { |
| if (i < 0) |
| return H.ioore(receiver, i); |
| if (J.$eq$(receiver[i], element)) |
| return i; |
| } |
| return -1; |
| }, |
| indexOf$1: function($receiver, element) { |
| return this.indexOf$2($receiver, element, 0); |
| }, |
| lastIndexOf$2: function(receiver, element, startIndex) { |
| var t1, i; |
| if (startIndex < 0) |
| return -1; |
| t1 = receiver.length; |
| if (startIndex >= t1) |
| startIndex = t1 - 1; |
| for (i = startIndex; i >= 0; --i) { |
| if (i >= receiver.length) |
| return H.ioore(receiver, i); |
| if (J.$eq$(receiver[i], element)) |
| return i; |
| } |
| return -1; |
| }, |
| contains$1: function(receiver, other) { |
| var i; |
| for (i = 0; i < receiver.length; ++i) |
| if (J.$eq$(receiver[i], other)) |
| return true; |
| return false; |
| }, |
| get$isEmpty: function(receiver) { |
| return receiver.length === 0; |
| }, |
| get$isNotEmpty: function(receiver) { |
| return receiver.length !== 0; |
| }, |
| toString$0: function(receiver) { |
| return P.IterableBase_iterableToFullString(receiver, "[", "]"); |
| }, |
| get$iterator: function(receiver) { |
| return H.setRuntimeTypeInfo(new J.ArrayIterator(receiver, receiver.length, 0, null), [H.getTypeArgumentByIndex(receiver, 0)]); |
| }, |
| 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$range(newLength, 0, null, "newLength", null)); |
| receiver.length = newLength; |
| }, |
| $index: function(receiver, index) { |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| if (index >= receiver.length || index < 0) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $indexSet: function(receiver, index, value) { |
| if (!!receiver.immutable$list) |
| H.throwExpression(new P.UnsupportedError("indexed set")); |
| if (index >= receiver.length || index < 0) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| receiver[index] = value; |
| }, |
| $isJSIndexable: 1, |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1, |
| static: {JSArray_JSArray$fixed: function($length, $E) { |
| var t1; |
| if (typeof $length !== "number" || Math.floor($length) !== $length) |
| throw H.wrapException(P.ArgumentError$value($length, "length", "is not an integer")); |
| if ($length < 0 || $length > 4294967295) |
| throw H.wrapException(P.RangeError$range($length, 0, 4294967295, "length", null)); |
| t1 = H.setRuntimeTypeInfo(new Array($length), [$E]); |
| t1.fixed$length = Array; |
| return t1; |
| }} |
| }, |
| JSUnmodifiableArray: { |
| "^": "JSArray;" |
| }, |
| ArrayIterator: { |
| "^": "Object;__interceptors$_iterable,__interceptors$_length,__interceptors$_index,__interceptors$_current", |
| get$current: function() { |
| return this.__interceptors$_current; |
| }, |
| moveNext$0: function() { |
| var t1, $length, t2; |
| t1 = this.__interceptors$_iterable; |
| $length = t1.length; |
| if (this.__interceptors$_length !== $length) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| t2 = this.__interceptors$_index; |
| if (t2 >= $length) { |
| this.__interceptors$_current = null; |
| return false; |
| } |
| this.__interceptors$_current = t1[t2]; |
| this.__interceptors$_index = t2 + 1; |
| return true; |
| } |
| }, |
| JSNumber: { |
| "^": "Interceptor;", |
| get$isNegative: function(receiver) { |
| return receiver === 0 ? 1 / receiver < 0 : receiver < 0; |
| }, |
| get$isNaN: function(receiver) { |
| return isNaN(receiver); |
| }, |
| remainder$1: function(receiver, b) { |
| return receiver % b; |
| }, |
| abs$0: function(receiver) { |
| return Math.abs(receiver); |
| }, |
| 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)); |
| }, |
| toRadixString$1: function(receiver, radix) { |
| var result, match, t1, exponent; |
| H.checkInt(radix); |
| if (radix < 2 || radix > 36) |
| throw H.wrapException(P.RangeError$range(radix, 2, 36, "radix", null)); |
| result = receiver.toString(radix); |
| if (C.JSString_methods.codeUnitAt$1(result, result.length - 1) !== 41) |
| return result; |
| match = /^([\da-z]+)(?:\.([\da-z]+))?\(e\+(\d+)\)$/.exec(result); |
| if (match == null) |
| H.throwExpression(new P.UnsupportedError("Unexpected toString result: " + result)); |
| t1 = J.getInterceptor$asx(match); |
| result = t1.$index(match, 1); |
| exponent = +t1.$index(match, 3); |
| if (t1.$index(match, 2) != null) { |
| result += t1.$index(match, 2); |
| exponent -= t1.$index(match, 2).length; |
| } |
| return result + C.JSString_methods.$mul("0", exponent); |
| }, |
| toString$0: function(receiver) { |
| if (receiver === 0 && 1 / receiver < 0) |
| return "-0.0"; |
| else |
| return "" + receiver; |
| }, |
| get$hashCode: function(receiver) { |
| return receiver & 0x1FFFFFFF; |
| }, |
| $negate: function(receiver) { |
| return -receiver; |
| }, |
| $add: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver + other; |
| }, |
| $sub: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver - other; |
| }, |
| _tdivFast$1: function(receiver, other) { |
| return (receiver | 0) === receiver ? receiver / other | 0 : this.toInt$0(receiver / other); |
| }, |
| $shl: function(receiver, other) { |
| if (other < 0) |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return other > 31 ? 0 : receiver << other >>> 0; |
| }, |
| _shlPositive$1: function(receiver, other) { |
| return other > 31 ? 0 : receiver << other >>> 0; |
| }, |
| _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; |
| }, |
| _shrReceiverPositive$1: function(receiver, other) { |
| if (other < 0) |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return other > 31 ? 0 : receiver >>> other; |
| }, |
| $or: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return (receiver | other) >>> 0; |
| }, |
| $lt: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver < other; |
| }, |
| $gt: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver > other; |
| }, |
| $isnum: 1 |
| }, |
| JSInt: { |
| "^": "JSNumber;", |
| $is$double: 1, |
| $isnum: 1, |
| $is$int: 1 |
| }, |
| JSDouble: { |
| "^": "JSNumber;", |
| $is$double: 1, |
| $isnum: 1 |
| }, |
| JSString: { |
| "^": "Interceptor;", |
| codeUnitAt$1: function(receiver, index) { |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| if (index < 0) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| if (index >= receiver.length) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| return receiver.charCodeAt(index); |
| }, |
| allMatches$2: function(receiver, string, start) { |
| H.checkString(string); |
| H.checkInt(start); |
| if (start > string.length) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| return new H._StringAllMatchesIterable(string, receiver, start); |
| }, |
| allMatches$1: function($receiver, string) { |
| return this.allMatches$2($receiver, string, 0); |
| }, |
| matchAsPrefix$2: function(receiver, string, start) { |
| var t1, i; |
| if (start < 0 || start > string.length) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| t1 = receiver.length; |
| if (start + t1 > string.length) |
| return; |
| for (i = 0; i < t1; ++i) |
| if (this.codeUnitAt$1(string, start + i) !== this.codeUnitAt$1(receiver, i)) |
| return; |
| return new H.StringMatch(start, string, receiver); |
| }, |
| $add: function(receiver, other) { |
| if (typeof other !== "string") |
| throw H.wrapException(P.ArgumentError$value(other, null, null)); |
| return receiver + other; |
| }, |
| endsWith$1: function(receiver, other) { |
| var otherLength, t1; |
| H.checkString(other); |
| otherLength = other.length; |
| t1 = receiver.length; |
| if (otherLength > t1) |
| return false; |
| return other === this.substring$1(receiver, t1 - otherLength); |
| }, |
| replaceAll$2: function(receiver, from, to) { |
| H.checkString(to); |
| return H.stringReplaceAllUnchecked(receiver, from, to); |
| }, |
| replaceAllMapped$2: function(receiver, from, convert) { |
| return H.stringReplaceAllFuncUnchecked(receiver, from, convert, null); |
| }, |
| split$1: function(receiver, pattern) { |
| return receiver.split(pattern); |
| }, |
| replaceRange$3: function(receiver, start, end, replacement) { |
| H.checkString(replacement); |
| H.checkInt(start); |
| end = P.RangeError_checkValidRange(start, end, receiver.length, null, null, null); |
| H.checkInt(end); |
| return H.stringReplaceRangeUnchecked(receiver, start, end, replacement); |
| }, |
| startsWith$2: function(receiver, pattern, index) { |
| var endIndex; |
| H.checkInt(index); |
| if (index < 0 || index > receiver.length) |
| throw H.wrapException(P.RangeError$range(index, 0, receiver.length, null, null)); |
| endIndex = index + pattern.length; |
| if (endIndex > receiver.length) |
| return false; |
| return pattern === receiver.substring(index, endIndex); |
| }, |
| startsWith$1: function($receiver, pattern) { |
| return this.startsWith$2($receiver, pattern, 0); |
| }, |
| substring$2: function(receiver, startIndex, endIndex) { |
| var t1; |
| if (typeof startIndex !== "number" || Math.floor(startIndex) !== startIndex) |
| H.throwExpression(H.argumentErrorValue(startIndex)); |
| if (endIndex == null) |
| endIndex = receiver.length; |
| if (typeof endIndex !== "number" || Math.floor(endIndex) !== endIndex) |
| H.throwExpression(H.argumentErrorValue(endIndex)); |
| t1 = J.getInterceptor$n(startIndex); |
| if (t1.$lt(startIndex, 0)) |
| throw H.wrapException(P.RangeError$value(startIndex, null, null)); |
| if (t1.$gt(startIndex, endIndex)) |
| throw H.wrapException(P.RangeError$value(startIndex, null, null)); |
| if (J.$gt$n(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); |
| }, |
| toLowerCase$0: function(receiver) { |
| return receiver.toLowerCase(); |
| }, |
| trim$0: function(receiver) { |
| var result, endIndex, startIndex, t1, endIndex0; |
| result = receiver.trim(); |
| endIndex = result.length; |
| if (endIndex === 0) |
| return result; |
| if (this.codeUnitAt$1(result, 0) === 133) { |
| startIndex = J.JSString__skipLeadingWhitespace(result, 1); |
| if (startIndex === endIndex) |
| return ""; |
| } else |
| startIndex = 0; |
| t1 = endIndex - 1; |
| endIndex0 = this.codeUnitAt$1(result, t1) === 133 ? J.JSString__skipTrailingWhitespace(result, t1) : endIndex; |
| if (startIndex === 0 && endIndex0 === endIndex) |
| return result; |
| return result.substring(startIndex, endIndex0); |
| }, |
| $mul: function(receiver, times) { |
| var s, result; |
| if (0 >= times) |
| return ""; |
| if (times === 1 || receiver.length === 0) |
| return receiver; |
| if (times !== times >>> 0) |
| throw H.wrapException(C.C_OutOfMemoryError); |
| for (s = receiver, result = ""; true;) { |
| if ((times & 1) === 1) |
| result = s + result; |
| times = times >>> 1; |
| if (times === 0) |
| break; |
| s += s; |
| } |
| return result; |
| }, |
| get$codeUnits: function(receiver) { |
| return new H.CodeUnits(receiver); |
| }, |
| indexOf$2: function(receiver, pattern, start) { |
| var t1, match, t2, i; |
| if (pattern == null) |
| H.throwExpression(H.argumentErrorValue(pattern)); |
| if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, null, null)); |
| if (typeof pattern === "string") |
| return receiver.indexOf(pattern, start); |
| t1 = J.getInterceptor(pattern); |
| if (!!t1.$isJSSyntaxRegExp) { |
| match = pattern._execGlobal$2(receiver, start); |
| return match == null ? -1 : match._match.index; |
| } |
| for (t2 = receiver.length, i = start; i <= t2; ++i) |
| if (t1.matchAsPrefix$2(pattern, receiver, i) != null) |
| return i; |
| return -1; |
| }, |
| indexOf$1: function($receiver, pattern) { |
| return this.indexOf$2($receiver, pattern, 0); |
| }, |
| lastIndexOf$2: function(receiver, pattern, start) { |
| var t1, t2; |
| if (start == null) |
| start = receiver.length; |
| else if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, null, null)); |
| t1 = pattern.length; |
| if (typeof start !== "number") |
| return start.$add(); |
| t2 = receiver.length; |
| if (start + t1 > t2) |
| start = t2 - t1; |
| return receiver.lastIndexOf(pattern, start); |
| }, |
| lastIndexOf$1: function($receiver, pattern) { |
| return this.lastIndexOf$2($receiver, pattern, null); |
| }, |
| contains$2: function(receiver, other, startIndex) { |
| if (other == null) |
| H.throwExpression(H.argumentErrorValue(other)); |
| if (startIndex > receiver.length) |
| throw H.wrapException(P.RangeError$range(startIndex, 0, receiver.length, null, null)); |
| return H.stringContainsUnchecked(receiver, other, startIndex); |
| }, |
| contains$1: function($receiver, other) { |
| return this.contains$2($receiver, other, 0); |
| }, |
| get$isEmpty: function(receiver) { |
| return receiver.length === 0; |
| }, |
| get$isNotEmpty: 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(H.diagnoseIndexError(receiver, index)); |
| if (index >= receiver.length || index < 0) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isJSIndexable: 1, |
| $isString: 1, |
| $isPattern: 1, |
| static: {JSString__isWhitespace: function(codeUnit) { |
| if (codeUnit < 256) |
| switch (codeUnit) { |
| case 9: |
| case 10: |
| case 11: |
| case 12: |
| case 13: |
| case 32: |
| case 133: |
| case 160: |
| return true; |
| default: |
| return false; |
| } |
| switch (codeUnit) { |
| case 5760: |
| case 6158: |
| case 8192: |
| case 8193: |
| case 8194: |
| case 8195: |
| case 8196: |
| case 8197: |
| case 8198: |
| case 8199: |
| case 8200: |
| case 8201: |
| case 8202: |
| case 8232: |
| case 8233: |
| case 8239: |
| case 8287: |
| case 12288: |
| case 65279: |
| return true; |
| default: |
| return false; |
| } |
| }, JSString__skipLeadingWhitespace: function(string, index) { |
| var t1, codeUnit; |
| for (t1 = string.length; index < t1;) { |
| codeUnit = C.JSString_methods.codeUnitAt$1(string, index); |
| if (codeUnit !== 32 && codeUnit !== 13 && !J.JSString__isWhitespace(codeUnit)) |
| break; |
| ++index; |
| } |
| return index; |
| }, JSString__skipTrailingWhitespace: function(string, index) { |
| var index0, codeUnit; |
| for (; index > 0; index = index0) { |
| index0 = index - 1; |
| codeUnit = C.JSString_methods.codeUnitAt$1(string, index0); |
| if (codeUnit !== 32 && codeUnit !== 13 && !J.JSString__isWhitespace(codeUnit)) |
| break; |
| } |
| return index; |
| }} |
| } |
| }], ["_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; |
| 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))); |
| init.globalState = new H._Manager(0, 0, 1, null, null, null, null, null, null, null, null, null, entry); |
| t2 = init.globalState; |
| t3 = self.window == null; |
| t4 = self.Worker; |
| t5 = t3 && !!self.postMessage; |
| t2.isWorker = t5; |
| t5 = !t5; |
| if (t5) |
| t4 = t4 != null && $.$get$IsolateNatives_thisScript() != null; |
| else |
| t4 = true; |
| t2.supportsWorkers = t4; |
| t2.fromCommandLine = t3 && t5; |
| t2.topEventLoop = new H._EventLoop(P.ListQueue$(null, H._IsolateEvent), 0); |
| t2.isolates = H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [P.$int, H._IsolateContext]); |
| t2.managers = H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [P.$int, null]); |
| if (t2.isWorker === true) { |
| t3 = new H._MainManagerStub(); |
| t2.mainManager = t3; |
| self.onmessage = function(f, a) { |
| return function(e) { |
| f(a, e); |
| }; |
| }(H.IsolateNatives__processWorkerMessage, t3); |
| 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); |
| } |
| if (init.globalState.isWorker === true) |
| return; |
| t2 = init.globalState.nextIsolateId++; |
| t3 = H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [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$asx(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 : init.globalFunctions[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 = H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [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) |
| J.send$1$x(t1.$index(msg, "port"), 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__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; |
| J.send$1$x(replyTo, ["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:1;__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:1;__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", |
| 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, -1); |
| $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) { |
| J.send$1$x(responsePort, 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; |
| 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 = new Array(2); |
| message.fixed$length = Array; |
| message[0] = J.toString$0$(error); |
| message[1] = stackTrace == null ? null : J.toString$0$(stackTrace); |
| for (t1 = H.setRuntimeTypeInfo(new P.LinkedHashSetIterator(t1, t1._collection$_modifications, null, null), [null]), t1._cell = t1._set._collection$_first; t1.moveNext$0();) |
| J.send$1$x(t1._collection$_current, 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() { |
| var t1 = this.ports; |
| if (t1.get$length(t1) - 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(t1), t2 = t2.get$iterator(t2); t2.moveNext$0();) |
| t2.get$current().__isolate_helper$_close$0(); |
| t1.clear$0(0); |
| 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); |
| J.send$1$x(responsePort, t1[t3]); |
| } |
| this.doneHandlers = null; |
| } |
| }, "call$0", "get$kill", 0, 0, 2] |
| }, |
| _IsolateContext_handlePing_respond: { |
| "^": "Closure:2;_captured_responsePort_0,_captured_response_1", |
| call$0: function() { |
| J.send$1$x(this._captured_responsePort_0, 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) |
| if (init.globalState.isolates.containsKey$1(init.globalState.rootContext.id)) |
| if (init.globalState.fromCommandLine === true) { |
| t1 = init.globalState.rootContext.ports; |
| t1 = t1.get$isEmpty(t1); |
| } else |
| t1 = false; |
| else |
| t1 = false; |
| else |
| t1 = false; |
| if (t1) |
| H.throwExpression(P.Exception_Exception("Program exited with open ReceivePorts.")); |
| t1 = init.globalState; |
| if (t1.isWorker === true) { |
| t2 = t1.isolates; |
| t2 = t2.get$isEmpty(t2) && t1.topEventLoop._activeJsAsyncCount === 0; |
| } else |
| t2 = false; |
| if (t2) { |
| 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:2;__isolate_helper$_captured_this_0", |
| call$0: function() { |
| if (!this.__isolate_helper$_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:1;_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:2;_captured_topLevel_0,_captured_args_1,_captured_message_2,_captured_isSpawnUri_3,_captured_context_4", |
| call$0: function() { |
| var t1, t2, t3, t4; |
| t1 = this._captured_context_4; |
| t1.initialized = true; |
| if (this._captured_isSpawnUri_3 !== true) |
| this._captured_topLevel_0.call$1(this._captured_message_2); |
| else { |
| t2 = this._captured_topLevel_0; |
| t3 = H.getDynamicRuntimeType(); |
| t4 = H.buildFunctionType(t3, [t3, t3])._isTest$1(t2); |
| if (t4) |
| t2.call$2(this._captured_args_1, this._captured_message_2); |
| else { |
| t3 = H.buildFunctionType(t3, [t3])._isTest$1(t2); |
| if (t3) |
| t2.call$1(this._captured_args_1); |
| else |
| t2.call$0(); |
| } |
| } |
| t1._updateGlobalState$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$asx(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:1;__isolate_helper$_captured_this_0,_captured_msg_1", |
| call$0: function() { |
| var t1 = this.__isolate_helper$_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<", |
| __isolate_helper$_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:2;__isolate_helper$_captured_this_0,_captured_callback_1", |
| call$0: function() { |
| this.__isolate_helper$_captured_this_0._handle = null; |
| this._captured_callback_1.call$0(); |
| } |
| }, |
| TimerImpl_internalCallback0: { |
| "^": "Closure:2;__isolate_helper$_captured_this_2,_captured_callback_3", |
| call$0: function() { |
| this.__isolate_helper$_captured_this_2._handle = null; |
| H.leaveJsAsync(); |
| this._captured_callback_3.call$0(); |
| } |
| }, |
| CapabilityImpl: { |
| "^": "Object;_id<", |
| get$hashCode: function(_) { |
| var hash = this._id; |
| if (typeof hash !== "number") |
| return hash.$shr(); |
| hash = C.JSNumber_methods._shrOtherPositive$1(hash, 0) ^ C.JSNumber_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) { |
| var t1, t2; |
| if (other == null) |
| return false; |
| if (other === this) |
| return true; |
| if (other instanceof H.CapabilityImpl) { |
| t1 = this._id; |
| t2 = other._id; |
| return t1 == null ? t2 == null : t1 === t2; |
| } |
| 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.get$length(t1)); |
| t1 = J.getInterceptor(x); |
| if (!!t1.$isNativeByteBuffer) |
| return ["buffer", x]; |
| if (!!t1.$isNativeTypedData) |
| return ["typed", x]; |
| if (!!t1.$isJSIndexable) |
| return this.serializeJSIndexable$1(x); |
| if (!!t1.$isInternalMap) { |
| serializeTearOff = this.get$serialize(); |
| t2 = x.get$keys(); |
| t2 = H.MappedIterable_MappedIterable(t2, serializeTearOff, H.getRuntimeTypeArgument(t2, "Iterable", 0), null); |
| t2 = P.List_List$from(t2, true, H.getRuntimeTypeArgument(t2, "Iterable", 0)); |
| t1 = t1.get$values(x); |
| t1 = H.MappedIterable_MappedIterable(t1, serializeTearOff, H.getRuntimeTypeArgument(t1, "Iterable", 0), null); |
| return ["map", t2, P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "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.$static_name; |
| if ($name == null) |
| this.unsupported$2(x, "Closures can't be transmitted:"); |
| return ["function", $name]; |
| } |
| if (!!t1.$isCapabilityImpl) |
| return ["capability", x._id]; |
| if (!(x instanceof P.Object)) |
| this.unsupported$1(x); |
| return ["dart", init.classIdExtractor(x), this.serializeArrayInPlace$1(init.classFieldsExtractor(x))]; |
| }, "call$1", "get$serialize", 2, 0, 0], |
| 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 "capability": |
| if (1 >= x.length) |
| return H.ioore(x, 1); |
| return new H.CapabilityImpl(x[1]); |
| 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, 0], |
| deserializeArrayInPlace$1: function(x) { |
| var t1, i, t2; |
| t1 = J.getInterceptor$asx(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$ax(keys, this.get$deserialize()).toList$0(0); |
| for (t1 = J.getInterceptor$asx(keys), t2 = J.getInterceptor$asx(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$asx(keys); |
| t2 = J.getInterceptor$asx(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]; |
| }, |
| isJsIndexable: function(object, record) { |
| var result; |
| if (record != null) { |
| result = record.x; |
| if (result != null) |
| return result; |
| } |
| return !!J.getInterceptor(object).$isJavaScriptIndexingBehavior; |
| }, |
| S: function(value) { |
| var res; |
| if (typeof value === "string") |
| return value; |
| if (typeof value === "number") { |
| if (value !== 0) |
| return "" + value; |
| } else if (true === value) |
| return "true"; |
| else if (false === value) |
| return "false"; |
| else if (value == null) |
| return "null"; |
| res = J.toString$0$(value); |
| if (typeof res !== "string") |
| throw H.wrapException(H.argumentErrorValue(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__parseIntError: function(source, handleError) { |
| throw H.wrapException(new P.FormatException(source, null, null)); |
| }, |
| Primitives_parseInt: function(source, radix, handleError) { |
| var match, decimalMatch, maxCharCode, digitsPart, t1, i; |
| H.checkString(source); |
| match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source); |
| if (match == null) |
| return H.Primitives__parseIntError(source, handleError); |
| if (3 >= match.length) |
| return H.ioore(match, 3); |
| decimalMatch = match[3]; |
| if (radix == null) { |
| if (decimalMatch != null) |
| return parseInt(source, 10); |
| if (match[2] != null) |
| return parseInt(source, 16); |
| return H.Primitives__parseIntError(source, handleError); |
| } |
| if (radix < 2 || radix > 36) |
| throw H.wrapException(P.RangeError$range(radix, 2, 36, "radix", null)); |
| if (radix === 10 && decimalMatch != null) |
| return parseInt(source, 10); |
| if (radix < 10 || decimalMatch == null) { |
| maxCharCode = radix <= 10 ? 47 + radix : 86 + radix; |
| digitsPart = match[1]; |
| for (t1 = digitsPart.length, i = 0; i < t1; ++i) |
| if ((C.JSString_methods.codeUnitAt$1(digitsPart, i) | 32) > maxCharCode) |
| return H.Primitives__parseIntError(source, handleError); |
| } |
| return parseInt(source, radix); |
| }, |
| 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_objectToHumanReadableString: function(object) { |
| return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; |
| }, |
| Primitives_currentUri: function() { |
| if (!!self.location) |
| return self.location.href; |
| return; |
| }, |
| Primitives__fromCharCodeApply: function(array) { |
| var end, result, i, i0, chunkEnd; |
| end = array.length; |
| if (end <= 500) |
| return String.fromCharCode.apply(null, array); |
| for (result = "", i = 0; i < end; i = i0) { |
| i0 = i + 500; |
| chunkEnd = i0 < end ? i0 : end; |
| result += String.fromCharCode.apply(null, array.slice(i, chunkEnd)); |
| } |
| return result; |
| }, |
| Primitives_stringFromCodePoints: function(codePoints) { |
| var a, t1, _i, i; |
| a = []; |
| a.$builtinTypeInfo = [P.$int]; |
| for (t1 = codePoints.length, _i = 0; _i < codePoints.length; codePoints.length === t1 || (0, H.throwConcurrentModificationError)(codePoints), ++_i) { |
| i = codePoints[_i]; |
| if (typeof i !== "number" || Math.floor(i) !== i) |
| throw H.wrapException(H.argumentErrorValue(i)); |
| if (i <= 65535) |
| a.push(i); |
| else if (i <= 1114111) { |
| a.push(55296 + (C.JSInt_methods._shrOtherPositive$1(i - 65536, 10) & 1023)); |
| a.push(56320 + (i & 1023)); |
| } else |
| throw H.wrapException(H.argumentErrorValue(i)); |
| } |
| return H.Primitives__fromCharCodeApply(a); |
| }, |
| Primitives_stringFromCharCodes: function(charCodes) { |
| var t1, _i, t2, i; |
| for (t1 = charCodes.length, _i = 0; t2 = charCodes.length, _i < t2; t2 === t1 || (0, H.throwConcurrentModificationError)(charCodes), ++_i) { |
| i = charCodes[_i]; |
| if (typeof i !== "number" || Math.floor(i) !== i) |
| throw H.wrapException(H.argumentErrorValue(i)); |
| if (i < 0) |
| throw H.wrapException(H.argumentErrorValue(i)); |
| if (i > 65535) |
| return H.Primitives_stringFromCodePoints(charCodes); |
| } |
| return H.Primitives__fromCharCodeApply(charCodes); |
| }, |
| Primitives_stringFromCharCode: function(charCode) { |
| var bits; |
| if (0 <= charCode) { |
| if (charCode <= 65535) |
| return String.fromCharCode(charCode); |
| if (charCode <= 1114111) { |
| bits = charCode - 65536; |
| return String.fromCharCode((55296 | C.JSInt_methods._shrOtherPositive$1(bits, 10)) >>> 0, 56320 | bits & 1023); |
| } |
| } |
| throw H.wrapException(P.RangeError$range(charCode, 0, 1114111, null, null)); |
| }, |
| Primitives_getProperty: function(object, key) { |
| if (object == null || typeof object === "boolean" || typeof object === "number" || typeof object === "string") |
| throw H.wrapException(H.argumentErrorValue(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.argumentErrorValue(object)); |
| object[key] = value; |
| }, |
| iae: function(argument) { |
| throw H.wrapException(H.argumentErrorValue(argument)); |
| }, |
| ioore: function(receiver, index) { |
| if (receiver == null) |
| J.get$length$asx(receiver); |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| }, |
| diagnoseIndexError: function(indexable, index) { |
| var $length, t1; |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| return new P.ArgumentError(true, index, "index", null); |
| $length = J.get$length$asx(indexable); |
| if (!(index < 0)) { |
| if (typeof $length !== "number") |
| return H.iae($length); |
| t1 = index >= $length; |
| } else |
| t1 = true; |
| if (t1) |
| return P.IndexError$(index, indexable, "index", null, $length); |
| return P.RangeError$value(index, "index", null); |
| }, |
| diagnoseRangeError: function(start, end, $length) { |
| if (start > $length) |
| return new P.RangeError(0, $length, true, start, "start", "Invalid value"); |
| if (end != null) |
| if (end < start || end > $length) |
| return new P.RangeError(start, $length, true, end, "end", "Invalid value"); |
| return new P.ArgumentError(true, end, "end", null); |
| }, |
| argumentErrorValue: 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.argumentErrorValue(value)); |
| return value; |
| }, |
| checkString: function(value) { |
| if (typeof value !== "string") |
| throw H.wrapException(H.argumentErrorValue(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); |
| }, |
| throwConcurrentModificationError: function(collection) { |
| throw H.wrapException(new P.ConcurrentModificationError(collection)); |
| }, |
| unwrapException: function(ex) { |
| var t1, message, number, ieErrorCode, t2, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, 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) { |
| nsme = $.$get$TypeErrorDecoder_noSuchMethodPattern(); |
| notClosure = $.$get$TypeErrorDecoder_notClosurePattern(); |
| nullCall = $.$get$TypeErrorDecoder_nullCallPattern(); |
| nullLiteralCall = $.$get$TypeErrorDecoder_nullLiteralCallPattern(); |
| undefCall = $.$get$TypeErrorDecoder_undefinedCallPattern(); |
| undefLiteralCall = $.$get$TypeErrorDecoder_undefinedLiteralCallPattern(); |
| nullProperty = $.$get$TypeErrorDecoder_nullPropertyPattern(); |
| $.$get$TypeErrorDecoder_nullLiteralPropertyPattern(); |
| undefProperty = $.$get$TypeErrorDecoder_undefinedPropertyPattern(); |
| undefLiteralProperty = $.$get$TypeErrorDecoder_undefinedLiteralPropertyPattern(); |
| match = nsme.matchTypeError$1(message); |
| if (match != null) |
| return t1.call$1(H.JsNoSuchMethodError$(message, match)); |
| else { |
| match = notClosure.matchTypeError$1(message); |
| if (match != null) { |
| match.method = "call"; |
| return t1.call$1(H.JsNoSuchMethodError$(message, match)); |
| } else { |
| match = nullCall.matchTypeError$1(message); |
| if (match == null) { |
| match = nullLiteralCall.matchTypeError$1(message); |
| if (match == null) { |
| match = undefCall.matchTypeError$1(message); |
| if (match == null) { |
| match = undefLiteralCall.matchTypeError$1(message); |
| if (match == null) { |
| match = nullProperty.matchTypeError$1(message); |
| if (match == null) { |
| match = nullLiteralCall.matchTypeError$1(message); |
| if (match == null) { |
| match = undefProperty.matchTypeError$1(message); |
| if (match == null) { |
| match = undefLiteralProperty.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(); |
| message = function(ex) { |
| try { |
| return String(ex); |
| } catch (e) { |
| } |
| return null; |
| }(ex); |
| return t1.call$1(new P.ArgumentError(false, null, null, typeof message === "string" ? message.replace(/^RangeError:\s*/, "") : message)); |
| } |
| if (typeof InternalError == "function" && ex instanceof InternalError) |
| if (typeof message === "string" && message === "too much recursion") |
| return new P.StackOverflowError(); |
| return ex; |
| }, |
| getTraceFromException: function(exception) { |
| var trace; |
| if (exception instanceof H.ExceptionAndStackTrace) |
| return exception.stackTrace; |
| if (exception == null) |
| return new H._StackTrace(exception, null); |
| trace = exception.$cachedTrace; |
| if (trace != null) |
| return trace; |
| return exception.$cachedTrace = 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; |
| if (closure == null) |
| return; |
| $function = closure.$identity; |
| if (!!$function) |
| return $function; |
| $function = function(closure, arity, context, invoke) { |
| return function(a1, a2, a3, a4) { |
| return invoke(closure, context, arity, a1, a2, a3, a4); |
| }; |
| }(closure, arity, 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.$static_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; |
| }, |
| setRuntimeTypeInfo: function(target, rti) { |
| if (target != null) |
| target.$builtinTypeInfo = rti; |
| 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(rti, onTypeVariable) { |
| if (rti == null) |
| return "dynamic"; |
| else if (typeof rti === "object" && rti !== null && rti.constructor === Array) |
| return rti[0].builtin$cls + H.joinArguments(rti, 1, onTypeVariable); |
| else if (typeof rti == "function") |
| return rti.builtin$cls; |
| else if (typeof rti === "number" && Math.floor(rti) === rti) |
| return C.JSInt_methods.toString$0(rti); |
| 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) + ">"; |
| }, |
| getRuntimeTypeString: function(object) { |
| var className = J.getInterceptor(object).constructor.builtin$cls; |
| if (object == null) |
| return className; |
| return className + H.joinArguments(object.$builtinTypeInfo, 0, null); |
| }, |
| 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); |
| }, |
| toStringForNativeObject: function(obj) { |
| var t1 = $.getTagFunction; |
| return "Instance of " + (t1 == null ? "<Unknown>" : t1.call$1(obj)); |
| }, |
| hashCodeForNativeObject: function(object) { |
| return H.Primitives_objectHashCode(object); |
| }, |
| defineProperty: function(obj, property, value) { |
| Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true}); |
| }, |
| lookupAndCacheInterceptor: function(obj) { |
| var tag, record, interceptor, interceptorClass, mark, t1; |
| tag = $.getTagFunction.call$1(obj); |
| record = $.dispatchRecordsForInstanceTags[tag]; |
| if (record != null) { |
| Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); |
| return record.i; |
| } |
| interceptor = $.interceptorsForUncacheableTags[tag]; |
| if (interceptor != null) |
| return interceptor; |
| interceptorClass = init.interceptorsByTag[tag]; |
| if (interceptorClass == null) { |
| tag = $.alternateTagFunction.call$2(obj, tag); |
| if (tag != null) { |
| record = $.dispatchRecordsForInstanceTags[tag]; |
| if (record != null) { |
| Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); |
| return record.i; |
| } |
| interceptor = $.interceptorsForUncacheableTags[tag]; |
| if (interceptor != null) |
| return interceptor; |
| interceptorClass = init.interceptorsByTag[tag]; |
| } |
| } |
| if (interceptorClass == null) |
| return; |
| interceptor = interceptorClass.prototype; |
| mark = tag[0]; |
| if (mark === "!") { |
| record = H.makeLeafDispatchRecord(interceptor); |
| $.dispatchRecordsForInstanceTags[tag] = record; |
| Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); |
| return record.i; |
| } |
| if (mark === "~") { |
| $.interceptorsForUncacheableTags[tag] = interceptor; |
| return interceptor; |
| } |
| if (mark === "-") { |
| t1 = H.makeLeafDispatchRecord(interceptor); |
| Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); |
| return t1.i; |
| } |
| if (mark === "+") |
| return H.patchInteriorProto(obj, interceptor); |
| if (mark === "*") |
| throw H.wrapException(new P.UnimplementedError(tag)); |
| if (init.leafTags[tag] === true) { |
| t1 = H.makeLeafDispatchRecord(interceptor); |
| Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true}); |
| return t1.i; |
| } else |
| return H.patchInteriorProto(obj, interceptor); |
| }, |
| patchInteriorProto: function(obj, interceptor) { |
| var proto = Object.getPrototypeOf(obj); |
| Object.defineProperty(proto, init.dispatchPropertyName, {value: J.makeDispatchRecord(interceptor, proto, null, null), enumerable: false, writable: true, configurable: true}); |
| return interceptor; |
| }, |
| makeLeafDispatchRecord: function(interceptor) { |
| return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); |
| }, |
| makeDefaultDispatchRecord: function(tag, interceptorClass, proto) { |
| var interceptor = interceptorClass.prototype; |
| if (init.leafTags[tag] === true) |
| return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior); |
| else |
| return J.makeDispatchRecord(interceptor, proto, null, null); |
| }, |
| initNativeDispatch: function() { |
| if (true === $.initNativeDispatchFlag) |
| return; |
| $.initNativeDispatchFlag = true; |
| H.initNativeDispatchContinue(); |
| }, |
| initNativeDispatchContinue: function() { |
| var map, tags, fun, i, tag, proto, record, interceptorClass; |
| $.dispatchRecordsForInstanceTags = Object.create(null); |
| $.interceptorsForUncacheableTags = Object.create(null); |
| H.initHooks(); |
| map = init.interceptorsByTag; |
| tags = Object.getOwnPropertyNames(map); |
| if (typeof window != "undefined") { |
| window; |
| fun = function() { |
| }; |
| for (i = 0; i < tags.length; ++i) { |
| tag = tags[i]; |
| proto = $.prototypeForTagFunction.call$1(tag); |
| if (proto != null) { |
| record = H.makeDefaultDispatchRecord(tag, map[tag], proto); |
| if (record != null) { |
| Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true}); |
| fun.prototype = proto; |
| } |
| } |
| } |
| } |
| for (i = 0; i < tags.length; ++i) { |
| tag = tags[i]; |
| if (/^[A-Za-z_]/.test(tag)) { |
| interceptorClass = map[tag]; |
| map["!" + tag] = interceptorClass; |
| map["~" + tag] = interceptorClass; |
| map["-" + tag] = interceptorClass; |
| map["+" + tag] = interceptorClass; |
| map["*" + tag] = interceptorClass; |
| } |
| } |
| }, |
| initHooks: function() { |
| var hooks, transformers, i, transformer, getTag, getUnknownTag, prototypeForTag; |
| hooks = C.JS_CONST_gkc(); |
| hooks = H.applyHooksTransformer(C.JS_CONST_0, H.applyHooksTransformer(C.JS_CONST_rr7, H.applyHooksTransformer(C.JS_CONST_Fs4, H.applyHooksTransformer(C.JS_CONST_Fs4, H.applyHooksTransformer(C.JS_CONST_gkc0, H.applyHooksTransformer(C.JS_CONST_4hp, H.applyHooksTransformer(C.JS_CONST_QJm(C.JS_CONST_8ZY), hooks))))))); |
| if (typeof dartNativeDispatchHooksTransformer != "undefined") { |
| transformers = dartNativeDispatchHooksTransformer; |
| if (typeof transformers == "function") |
| transformers = [transformers]; |
| if (transformers.constructor == Array) |
| for (i = 0; i < transformers.length; ++i) { |
| transformer = transformers[i]; |
| if (typeof transformer == "function") |
| hooks = transformer(hooks) || hooks; |
| } |
| } |
| getTag = hooks.getTag; |
| getUnknownTag = hooks.getUnknownTag; |
| prototypeForTag = hooks.prototypeForTag; |
| $.getTagFunction = new H.initHooks_closure(getTag); |
| $.alternateTagFunction = new H.initHooks_closure0(getUnknownTag); |
| $.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag); |
| }, |
| applyHooksTransformer: function(transformer, hooks) { |
| return transformer(hooks) || hooks; |
| }, |
| stringContainsUnchecked: function(receiver, other, startIndex) { |
| var t1; |
| if (typeof other === "string") |
| return receiver.indexOf(other, startIndex) >= 0; |
| else { |
| t1 = J.getInterceptor(other); |
| if (!!t1.$isJSSyntaxRegExp) { |
| t1 = C.JSString_methods.substring$1(receiver, startIndex); |
| return other._nativeRegExp.test(H.checkString(t1)); |
| } else { |
| t1 = t1.allMatches$1(other, C.JSString_methods.substring$1(receiver, startIndex)); |
| return !t1.get$isEmpty(t1); |
| } |
| } |
| }, |
| stringReplaceAllUnchecked: function(receiver, pattern, replacement) { |
| var $length, t1, i; |
| H.checkString(replacement); |
| if (pattern === "") |
| if (receiver === "") |
| return replacement; |
| else { |
| $length = receiver.length; |
| for (t1 = replacement, i = 0; i < $length; ++i) |
| t1 = t1 + receiver[i] + replacement; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| } |
| else |
| return receiver.replace(new RegExp(pattern.replace(new RegExp("[[\\]{}()*+?.\\\\^$|]", 'g'), "\\$&"), 'g'), replacement.replace(/\$/g, "$$$$")); |
| }, |
| _stringIdentity: [function(string) { |
| return string; |
| }, "call$1", "_js_helper___stringIdentity$closure", 2, 0, 9], |
| stringReplaceAllFuncUnchecked: function(receiver, pattern, onMatch, onNonMatch) { |
| var t1, buffer, startIndex, match, t2, t3; |
| onNonMatch = H._js_helper___stringIdentity$closure(); |
| t1 = J.getInterceptor(pattern); |
| if (!t1.$isPattern) |
| throw H.wrapException(P.ArgumentError$value(pattern, "pattern", "is not a Pattern")); |
| buffer = new P.StringBuffer(""); |
| for (t1 = t1.allMatches$1(pattern, receiver), t1 = new H._AllMatchesIterator(t1._re, t1._string, t1._start, null), startIndex = 0; t1.moveNext$0();) { |
| match = t1.__js_helper$_current; |
| t2 = match._match; |
| buffer._contents += H.S(onNonMatch.call$1(C.JSString_methods.substring$2(receiver, startIndex, t2.index))); |
| buffer._contents += H.S(onMatch.call$1(match)); |
| t3 = t2.index; |
| if (0 >= t2.length) |
| return H.ioore(t2, 0); |
| t2 = J.get$length$asx(t2[0]); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| startIndex = t3 + t2; |
| } |
| t1 = buffer._contents += H.S(onNonMatch.call$1(C.JSString_methods.substring$1(receiver, startIndex))); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| stringReplaceFirstUnchecked: function(receiver, pattern, replacement, startIndex) { |
| var index = receiver.indexOf(pattern, startIndex); |
| if (index < 0) |
| return receiver; |
| return H.stringReplaceRangeUnchecked(receiver, index, index + pattern.length, replacement); |
| }, |
| stringReplaceRangeUnchecked: function(receiver, start, end, replacement) { |
| var prefix, suffix; |
| prefix = receiver.substring(0, start); |
| suffix = receiver.substring(end); |
| return prefix + replacement + suffix; |
| }, |
| 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; |
| } |
| }, |
| ExceptionAndStackTrace: { |
| "^": "Object;dartException,stackTrace<" |
| }, |
| unwrapException_saveStackTrace: { |
| "^": "Closure:0;_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:1;_captured_closure_0", |
| call$0: function() { |
| return this._captured_closure_0.call$0(); |
| } |
| }, |
| invokeClosure_closure0: { |
| "^": "Closure:1;_captured_closure_1,_captured_arg1_2", |
| call$0: function() { |
| return this._captured_closure_1.call$1(this._captured_arg1_2); |
| } |
| }, |
| invokeClosure_closure1: { |
| "^": "Closure:1;_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:1;_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:1;_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.$static_name; |
| if ($name == null) |
| return "Closure of unknown static method"; |
| return "Closure '" + $name + "'"; |
| } |
| }, |
| BoundClosure: { |
| "^": "TearOffClosure;_self,__js_helper$_target,_receiver,__js_helper$_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.__js_helper$_target === other.__js_helper$_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); |
| t1 = H.Primitives_objectHashCode(this.__js_helper$_target); |
| if (typeof receiverHashCode !== "number") |
| return receiverHashCode.$xor(); |
| return (receiverHashCode ^ t1) >>> 0; |
| }, |
| toString$0: function(_) { |
| var receiver = this._receiver; |
| if (receiver == null) |
| receiver = this._self; |
| return "Closure '" + H.S(this.__js_helper$_name) + "' of " + H.Primitives_objectToHumanReadableString(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: " + H.S(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; |
| } |
| }, |
| TypeImpl: { |
| "^": "Object;_typeName,_unmangledName", |
| toString$0: function(_) { |
| var t1, unmangledName; |
| t1 = this._unmangledName; |
| if (t1 != null) |
| return t1; |
| unmangledName = this._typeName.replace(/[^<,> ]+/g, function(m) { |
| return init.mangledGlobalNames[m] || m; |
| }); |
| this._unmangledName = unmangledName; |
| return unmangledName; |
| }, |
| get$hashCode: function(_) { |
| return J.get$hashCode$(this._typeName); |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| return other instanceof H.TypeImpl && J.$eq$(this._typeName, other._typeName); |
| } |
| }, |
| JsLinkedHashMap: { |
| "^": "Object;__js_helper$_length,_strings,_nums,_rest,_first,__js_helper$_last,_modifications", |
| get$length: function(_) { |
| return this.__js_helper$_length; |
| }, |
| get$isEmpty: function(_) { |
| return this.__js_helper$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return !this.get$isEmpty(this); |
| }, |
| get$keys: function() { |
| return H.setRuntimeTypeInfo(new H.LinkedHashMapKeyIterable(this), [H.getTypeArgumentByIndex(this, 0)]); |
| }, |
| get$values: function(_) { |
| return H.MappedIterable_MappedIterable(this.get$keys(), new H.JsLinkedHashMap_values_closure(this), H.getTypeArgumentByIndex(this, 0), H.getTypeArgumentByIndex(this, 1)); |
| }, |
| containsKey$1: function(key) { |
| var strings, nums; |
| if (typeof key === "string") { |
| strings = this._strings; |
| if (strings == null) |
| return false; |
| return this._containsTableEntry$2(strings, key); |
| } else if (typeof key === "number" && (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, rest, hash, bucket, index; |
| 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 { |
| 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)); |
| } |
| } |
| }, |
| putIfAbsent$2: function(key, ifAbsent) { |
| var value; |
| if (this.containsKey$1(key)) |
| return this.$index(0, key); |
| value = ifAbsent.call$0(); |
| this.$indexSet(0, key, value); |
| return value; |
| }, |
| remove$1: function(_, key) { |
| if (typeof key === "string") |
| return this.__js_helper$_removeHashTableEntry$2(this._strings, key); |
| else if (typeof key === "number" && (key & 0x3ffffff) === key) |
| return this.__js_helper$_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.__js_helper$_unlinkCell$1(cell); |
| return cell.get$hashMapCellValue(); |
| }, |
| clear$0: function(_) { |
| if (this.__js_helper$_length > 0) { |
| this.__js_helper$_last = null; |
| this._first = null; |
| this._rest = null; |
| this._nums = null; |
| this._strings = null; |
| this.__js_helper$_length = 0; |
| this._modifications = this._modifications + 1 & 67108863; |
| } |
| }, |
| forEach$1: function(_, action) { |
| var cell, modifications; |
| cell = this._first; |
| modifications = this._modifications; |
| for (; cell != null;) { |
| action.call$2(cell.hashMapCellKey, cell.hashMapCellValue); |
| if (modifications !== this._modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| cell = cell._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); |
| }, |
| __js_helper$_removeHashTableEntry$2: function(table, key) { |
| var cell; |
| if (table == null) |
| return; |
| cell = this._getTableEntry$2(table, key); |
| if (cell == null) |
| return; |
| this.__js_helper$_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.__js_helper$_last = cell; |
| this._first = cell; |
| } else { |
| last = this.__js_helper$_last; |
| cell.__js_helper$_previous = last; |
| last._next = cell; |
| this.__js_helper$_last = cell; |
| } |
| ++this.__js_helper$_length; |
| this._modifications = this._modifications + 1 & 67108863; |
| return cell; |
| }, |
| __js_helper$_unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$__js_helper$_previous(); |
| next = cell._next; |
| if (previous == null) |
| this._first = next; |
| else |
| previous._next = next; |
| if (next == null) |
| this.__js_helper$_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:0;__js_helper$_captured_this_0", |
| call$1: function(each) { |
| return this.__js_helper$_captured_this_0.$index(0, each); |
| } |
| }, |
| LinkedHashMapCell: { |
| "^": "Object;hashMapCellKey<,hashMapCellValue@,_next,__js_helper$_previous<" |
| }, |
| LinkedHashMapKeyIterable: { |
| "^": "Iterable;_map", |
| get$length: function(_) { |
| return this._map.__js_helper$_length; |
| }, |
| get$isEmpty: function(_) { |
| return this._map.__js_helper$_length === 0; |
| }, |
| get$iterator: function(_) { |
| var t1, t2; |
| t1 = this._map; |
| t2 = new H.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); |
| t2.$builtinTypeInfo = this.$builtinTypeInfo; |
| t2.__js_helper$_cell = t1._first; |
| return t2; |
| }, |
| contains$1: function(_, element) { |
| return this._map.containsKey$1(element); |
| }, |
| 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._next; |
| } |
| }, |
| $isEfficientLength: 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._next; |
| return true; |
| } |
| } |
| } |
| }, |
| initHooks_closure: { |
| "^": "Closure:0;_captured_getTag_0", |
| call$1: function(o) { |
| return this._captured_getTag_0(o); |
| } |
| }, |
| initHooks_closure0: { |
| "^": "Closure:11;_captured_getUnknownTag_1", |
| call$2: function(o, tag) { |
| return this._captured_getUnknownTag_1(o, tag); |
| } |
| }, |
| initHooks_closure1: { |
| "^": "Closure:12;_captured_prototypeForTag_2", |
| call$1: function(tag) { |
| return this._captured_prototypeForTag_2(tag); |
| } |
| }, |
| JSSyntaxRegExp: { |
| "^": "Object;pattern,_nativeRegExp,_nativeGlobalRegExp,_nativeAnchoredRegExp", |
| toString$0: function(_) { |
| return "RegExp/" + this.pattern + "/"; |
| }, |
| get$_nativeGlobalVersion: function() { |
| var t1 = this._nativeGlobalRegExp; |
| if (t1 != null) |
| return t1; |
| t1 = this._nativeRegExp; |
| t1 = H.JSSyntaxRegExp_makeNative(this.pattern, t1.multiline, !t1.ignoreCase, true); |
| this._nativeGlobalRegExp = t1; |
| return t1; |
| }, |
| get$_nativeAnchoredVersion: function() { |
| var t1 = this._nativeAnchoredRegExp; |
| if (t1 != null) |
| return t1; |
| t1 = this._nativeRegExp; |
| t1 = H.JSSyntaxRegExp_makeNative(this.pattern + "|()", t1.multiline, !t1.ignoreCase, true); |
| this._nativeAnchoredRegExp = t1; |
| return t1; |
| }, |
| allMatches$2: function(_, string, start) { |
| H.checkString(string); |
| H.checkInt(start); |
| if (start > string.length) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| return new H._AllMatchesIterable(this, string, start); |
| }, |
| allMatches$1: function($receiver, string) { |
| return this.allMatches$2($receiver, string, 0); |
| }, |
| _execGlobal$2: function(string, start) { |
| var regexp, match; |
| regexp = this.get$_nativeGlobalVersion(); |
| regexp.lastIndex = start; |
| match = regexp.exec(string); |
| if (match == null) |
| return; |
| return H._MatchImplementation$(this, match); |
| }, |
| _execAnchored$2: function(string, start) { |
| var regexp, match, t1, t2; |
| regexp = this.get$_nativeAnchoredVersion(); |
| regexp.lastIndex = start; |
| match = regexp.exec(string); |
| if (match == null) |
| return; |
| t1 = match.length; |
| t2 = t1 - 1; |
| if (t2 < 0) |
| return H.ioore(match, t2); |
| if (match[t2] != null) |
| return; |
| C.JSArray_methods.set$length(match, t2); |
| return H._MatchImplementation$(this, match); |
| }, |
| matchAsPrefix$2: function(_, string, start) { |
| if (start < 0 || start > string.length) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| return this._execAnchored$2(string, start); |
| }, |
| $isPattern: 1, |
| static: {JSSyntaxRegExp_makeNative: function(source, multiLine, caseSensitive, global) { |
| var m, i, g, regexp; |
| H.checkString(source); |
| m = multiLine ? "m" : ""; |
| i = caseSensitive ? "" : "i"; |
| g = global ? "g" : ""; |
| regexp = function() { |
| try { |
| return new RegExp(source, m + i + g); |
| } catch (e) { |
| return e; |
| } |
| }(); |
| if (regexp instanceof RegExp) |
| return regexp; |
| throw H.wrapException(new P.FormatException("Illegal RegExp pattern (" + String(regexp) + ")", source, null)); |
| }} |
| }, |
| _MatchImplementation: { |
| "^": "Object;pattern,_match", |
| group$1: function(index) { |
| var t1 = this._match; |
| if (index >>> 0 !== index || index >= t1.length) |
| return H.ioore(t1, index); |
| return t1[index]; |
| }, |
| $index: function(_, index) { |
| var t1 = this._match; |
| if (index >>> 0 !== index || index >= t1.length) |
| return H.ioore(t1, index); |
| return t1[index]; |
| }, |
| _MatchImplementation$2: function(pattern, _match) { |
| }, |
| static: {_MatchImplementation$: function(pattern, _match) { |
| var t1 = new H._MatchImplementation(pattern, _match); |
| t1._MatchImplementation$2(pattern, _match); |
| return t1; |
| }} |
| }, |
| _AllMatchesIterable: { |
| "^": "IterableBase;_re,_string,_start", |
| get$iterator: function(_) { |
| return new H._AllMatchesIterator(this._re, this._string, this._start, null); |
| }, |
| $asIterableBase: function() { |
| return [P.Match]; |
| }, |
| $asIterable: function() { |
| return [P.Match]; |
| } |
| }, |
| _AllMatchesIterator: { |
| "^": "Object;_regExp,_string,_nextIndex,__js_helper$_current", |
| get$current: function() { |
| return this.__js_helper$_current; |
| }, |
| moveNext$0: function() { |
| var t1, t2, match, t3, nextIndex; |
| t1 = this._string; |
| if (t1 == null) |
| return false; |
| t2 = this._nextIndex; |
| if (t2 <= t1.length) { |
| match = this._regExp._execGlobal$2(t1, t2); |
| if (match != null) { |
| this.__js_helper$_current = match; |
| t1 = match._match; |
| t2 = t1.index; |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t3 = J.get$length$asx(t1[0]); |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| nextIndex = t2 + t3; |
| this._nextIndex = t1.index === nextIndex ? nextIndex + 1 : nextIndex; |
| return true; |
| } |
| } |
| this.__js_helper$_current = null; |
| this._string = null; |
| return false; |
| } |
| }, |
| StringMatch: { |
| "^": "Object;start,input,pattern", |
| $index: function(_, g) { |
| return this.group$1(g); |
| }, |
| group$1: function(group_) { |
| if (group_ !== 0) |
| throw H.wrapException(P.RangeError$value(group_, null, null)); |
| return this.pattern; |
| } |
| }, |
| _StringAllMatchesIterable: { |
| "^": "Iterable;_input,_pattern,__js_helper$_index", |
| get$iterator: function(_) { |
| return new H._StringAllMatchesIterator(this._input, this._pattern, this.__js_helper$_index, null); |
| }, |
| $asIterable: function() { |
| return [P.Match]; |
| } |
| }, |
| _StringAllMatchesIterator: { |
| "^": "Object;_input,_pattern,__js_helper$_index,__js_helper$_current", |
| moveNext$0: function() { |
| var t1, t2, t3, t4, t5, index, end; |
| t1 = this.__js_helper$_index; |
| t2 = this._pattern; |
| t3 = t2.length; |
| t4 = this._input; |
| t5 = t4.length; |
| if (t1 + t3 > t5) { |
| this.__js_helper$_current = null; |
| return false; |
| } |
| index = t4.indexOf(t2, t1); |
| if (index < 0) { |
| this.__js_helper$_index = t5 + 1; |
| this.__js_helper$_current = null; |
| return false; |
| } |
| end = index + t3; |
| this.__js_helper$_current = new H.StringMatch(index, t4, t2); |
| this.__js_helper$_index = end === this.__js_helper$_index ? end + 1 : end; |
| return true; |
| }, |
| get$current: function() { |
| return this.__js_helper$_current; |
| } |
| } |
| }], ["dart._internal", "dart:_internal",, H, { |
| "^": "", |
| IterableElementError_noElement: function() { |
| return new P.StateError("No element"); |
| }, |
| IterableElementError_tooMany: function() { |
| return new P.StateError("Too many elements"); |
| }, |
| IterableElementError_tooFew: function() { |
| return new P.StateError("Too few elements"); |
| }, |
| Symbol_getName: function(symbol) { |
| return symbol.get$_name(); |
| }, |
| CodeUnits: { |
| "^": "UnmodifiableListBase;__internal$_string", |
| get$length: function(_) { |
| return this.__internal$_string.length; |
| }, |
| $index: function(_, i) { |
| return C.JSString_methods.codeUnitAt$1(this.__internal$_string, i); |
| }, |
| $asUnmodifiableListBase: function() { |
| return [P.$int]; |
| }, |
| $asListBase: function() { |
| return [P.$int]; |
| }, |
| $asObject_ListMixin: function() { |
| return [P.$int]; |
| }, |
| $asList: function() { |
| return [P.$int]; |
| } |
| }, |
| ListIterable: { |
| "^": "Iterable;", |
| get$iterator: function(_) { |
| return H.setRuntimeTypeInfo(new H.ListIterator(this, this.get$length(this), 0, null), [H.getRuntimeTypeArgument(this, "ListIterable", 0)]); |
| }, |
| 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)); |
| } |
| }, |
| get$isEmpty: function(_) { |
| return this.get$length(this) === 0; |
| }, |
| get$last: function(_) { |
| if (this.get$length(this) === 0) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| return this.elementAt$1(0, this.get$length(this) - 1); |
| }, |
| contains$1: function(_, element) { |
| var $length, i; |
| $length = this.get$length(this); |
| for (i = 0; i < $length; ++i) { |
| if (J.$eq$(this.elementAt$1(0, i), element)) |
| return true; |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| return false; |
| }, |
| join$1: function(_, separator) { |
| var $length, first, buffer, i, t1; |
| $length = this.get$length(this); |
| if (separator.length !== 0) { |
| if ($length === 0) |
| return ""; |
| first = H.S(this.elementAt$1(0, 0)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| buffer = new P.StringBuffer(first); |
| for (i = 1; i < $length; ++i) { |
| buffer._contents += separator; |
| buffer._contents += H.S(this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| } else { |
| buffer = new P.StringBuffer(""); |
| for (i = 0; i < $length; ++i) { |
| buffer._contents += H.S(this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| } |
| }, |
| where$1: function(_, test) { |
| return this.super$Iterable$where(this, test); |
| }, |
| 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(new 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); |
| }, |
| $isEfficientLength: 1 |
| }, |
| SubListIterable: { |
| "^": "ListIterable;_iterable,__internal$_start,_endOrLength", |
| get$_endIndex: function() { |
| var $length, t1, t2; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this._endOrLength; |
| if (t1 != null) { |
| if (typeof t1 !== "number") |
| return t1.$gt(); |
| t2 = t1 > $length; |
| } else |
| t2 = true; |
| if (t2) |
| return $length; |
| return t1; |
| }, |
| get$_startIndex: function() { |
| var $length, t1; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this.__internal$_start; |
| if (t1 > $length) |
| return $length; |
| return t1; |
| }, |
| get$length: function(_) { |
| var $length, t1, t2, t3; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this.__internal$_start; |
| if (t1 >= $length) |
| return 0; |
| t2 = this._endOrLength; |
| if (t2 != null) { |
| if (typeof t2 !== "number") |
| return t2.$ge(); |
| t3 = t2 >= $length; |
| } else |
| t3 = true; |
| if (t3) |
| return $length - t1; |
| if (typeof t2 !== "number") |
| return t2.$sub(); |
| return t2 - t1; |
| }, |
| elementAt$1: function(_, index) { |
| var realIndex, t1; |
| realIndex = this.get$_startIndex() + index; |
| if (index >= 0) { |
| t1 = this.get$_endIndex(); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| t1 = realIndex >= t1; |
| } else |
| t1 = true; |
| if (t1) |
| throw H.wrapException(P.IndexError$(index, this, "index", null, null)); |
| return J.elementAt$1$ax(this._iterable, realIndex); |
| } |
| }, |
| ListIterator: { |
| "^": "Object;_iterable,__internal$_length,_index,__internal$_current", |
| get$current: function() { |
| return this.__internal$_current; |
| }, |
| moveNext$0: function() { |
| var t1, t2, $length, t3; |
| t1 = this._iterable; |
| t2 = J.getInterceptor$asx(t1); |
| $length = t2.get$length(t1); |
| if (this.__internal$_length !== $length) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| t3 = this._index; |
| if (t3 >= $length) { |
| this.__internal$_current = null; |
| return false; |
| } |
| this.__internal$_current = t2.elementAt$1(t1, t3); |
| ++this._index; |
| return true; |
| } |
| }, |
| MappedIterable: { |
| "^": "Iterable;_iterable,_f", |
| get$iterator: function(_) { |
| var t1 = new H.MappedIterator(null, J.get$iterator$ax(this._iterable), this._f); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| return t1; |
| }, |
| get$length: function(_) { |
| return J.get$length$asx(this._iterable); |
| }, |
| get$isEmpty: function(_) { |
| return J.get$isEmpty$asx(this._iterable); |
| }, |
| get$last: function(_) { |
| return this._f$1(J.get$last$ax(this._iterable)); |
| }, |
| _f$1: function(arg0) { |
| return this._f.call$1(arg0); |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| }, |
| static: {MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { |
| if (!!J.getInterceptor(iterable).$isEfficientLength) |
| return H.setRuntimeTypeInfo(new H.EfficientLengthMappedIterable(iterable, $function), [$S, $T]); |
| return H.setRuntimeTypeInfo(new H.MappedIterable(iterable, $function), [$S, $T]); |
| }} |
| }, |
| EfficientLengthMappedIterable: { |
| "^": "MappedIterable;_iterable,_f", |
| $isEfficientLength: 1 |
| }, |
| 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); |
| }, |
| $asIterator: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| MappedListIterable: { |
| "^": "ListIterable;_source,_f", |
| get$length: function(_) { |
| return J.get$length$asx(this._source); |
| }, |
| elementAt$1: function(_, index) { |
| return this._f$1(J.elementAt$1$ax(this._source, index)); |
| }, |
| _f$1: function(arg0) { |
| return this._f.call$1(arg0); |
| }, |
| $asListIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| WhereIterable: { |
| "^": "Iterable;_iterable,_f", |
| get$iterator: function(_) { |
| var t1 = new H.WhereIterator(J.get$iterator$ax(this._iterable), this._f); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| return t1; |
| } |
| }, |
| WhereIterator: { |
| "^": "Iterator;_iterator,_f", |
| moveNext$0: function() { |
| for (var t1 = this._iterator; t1.moveNext$0();) |
| if (this._f$1(t1.get$current()) === true) |
| return true; |
| return false; |
| }, |
| get$current: function() { |
| return this._iterator.get$current(); |
| }, |
| _f$1: function(arg0) { |
| return this._f.call$1(arg0); |
| } |
| }, |
| FixedLengthListMixin: { |
| "^": "Object;", |
| set$length: function(receiver, newLength) { |
| throw H.wrapException(new P.UnsupportedError("Cannot change the length of a fixed-length list")); |
| }, |
| add$1: function(receiver, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot add to a fixed-length list")); |
| } |
| }, |
| UnmodifiableListMixin: { |
| "^": "Object;", |
| $indexSet: function(_, index, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify an unmodifiable list")); |
| }, |
| set$length: function(_, newLength) { |
| throw H.wrapException(new P.UnsupportedError("Cannot change the length of an unmodifiable list")); |
| }, |
| add$1: function(_, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot add to an unmodifiable list")); |
| }, |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1 |
| }, |
| UnmodifiableListBase: { |
| "^": "ListBase+UnmodifiableListMixin;", |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1 |
| } |
| }], ["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.async__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.async__AsyncRun__scheduleImmediateWithSetImmediate$closure(); |
| return P.async__AsyncRun__scheduleImmediateWithTimer$closure(); |
| }, |
| _AsyncRun__scheduleImmediateJsOverride: [function(callback) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| self.scheduleImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateJsOverride_internalCallback(callback), 0)); |
| }, "call$1", "async__AsyncRun__scheduleImmediateJsOverride$closure", 2, 0, 4], |
| _AsyncRun__scheduleImmediateWithSetImmediate: [function(callback) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| self.setImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(callback), 0)); |
| }, "call$1", "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", 2, 0, 4], |
| _AsyncRun__scheduleImmediateWithTimer: [function(callback) { |
| P.Timer__createTimer(C.Duration_0, callback); |
| }, "call$1", "async__AsyncRun__scheduleImmediateWithTimer$closure", 2, 0, 4], |
| _asyncHelper: function(object, bodyFunctionOrErrorCode, completer) { |
| if (bodyFunctionOrErrorCode === 0) { |
| J.complete$1$x(completer, object); |
| return; |
| } else if (bodyFunctionOrErrorCode === 1) { |
| completer.completeError$2(H.unwrapException(object), H.getTraceFromException(object)); |
| return; |
| } |
| P._awaitOnObject(object, bodyFunctionOrErrorCode); |
| return completer.get$future(); |
| }, |
| _awaitOnObject: function(object, bodyFunction) { |
| var thenCallback, errorCallback, t1, future; |
| thenCallback = new P._awaitOnObject_closure(bodyFunction); |
| errorCallback = new P._awaitOnObject_closure0(bodyFunction); |
| t1 = J.getInterceptor(object); |
| if (!!t1.$is_Future) |
| object._thenNoZoneRegistration$2(thenCallback, errorCallback); |
| else if (!!t1.$isFuture) |
| object.then$2$onError(thenCallback, errorCallback); |
| else { |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| future._setValue$1(object); |
| future._thenNoZoneRegistration$2(thenCallback, null); |
| } |
| }, |
| _wrapJsFunctionForAsync: function($function) { |
| var $protected = function(errorCode, result) { |
| while (true) |
| try { |
| $function(errorCode, result); |
| break; |
| } catch (error) { |
| result = error; |
| errorCode = 1; |
| } |
| }; |
| $.Zone__current.toString; |
| return new P._wrapJsFunctionForAsync_closure($protected); |
| }, |
| _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$sync: function($T) { |
| return H.setRuntimeTypeInfo(new P._SyncCompleter(H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [$T])), [$T]); |
| }, |
| _completeWithErrorCallback: function(result, error, stackTrace) { |
| $.Zone__current.toString; |
| result._completeError$2(error, stackTrace); |
| }, |
| _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.async___microtaskLoopEntry$closure()); |
| } |
| }, "call$0", "async___microtaskLoopEntry$closure", 0, 0, 2], |
| _scheduleAsyncCallback: function(newEntry) { |
| if ($._nextCallback == null) { |
| $._lastCallback = newEntry; |
| $._nextCallback = newEntry; |
| if (!$._isInCallbackLoop) |
| $.$get$_AsyncRun_scheduleImmediateClosure().call$1(P.async___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$_async$_onData(); |
| t3 = t1.get$_onError(); |
| t1._subscription = stream.listen$4$cancelOnError$onDone$onError(t2, true, t1.get$_onDone(), t3); |
| return t1; |
| }, |
| _runUserCode: function(userCode, onSuccess, onError) { |
| var e, s, replacement, error, stackTrace, exception, t1; |
| try { |
| onSuccess.call$1(userCode.call$0()); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| $.Zone__current.toString; |
| replacement = null; |
| if (replacement == null) |
| onError.call$2(e, s); |
| else { |
| t1 = J.get$error$x(replacement); |
| error = t1; |
| stackTrace = replacement.get$stackTrace(); |
| onError.call$2(error, stackTrace); |
| } |
| } |
| }, |
| _cancelAndError: function(subscription, future, error, stackTrace) { |
| var cancelFuture = subscription.cancel$0(); |
| if (!!J.getInterceptor(cancelFuture).$isFuture) |
| cancelFuture.whenComplete$1(new P._cancelAndError_closure(future, error, stackTrace)); |
| else |
| future._completeError$2(error, stackTrace); |
| }, |
| _cancelAndErrorClosure: function(subscription, future) { |
| return new P._cancelAndErrorClosure_closure(subscription, future); |
| }, |
| _cancelAndValue: function(subscription, future, value) { |
| var cancelFuture = subscription.cancel$0(); |
| if (!!J.getInterceptor(cancelFuture).$isFuture) |
| cancelFuture.whenComplete$1(new P._cancelAndValue_closure(future, value)); |
| else |
| future._complete$1(value); |
| }, |
| _addErrorWithReplacement: function(sink, error, stackTrace) { |
| $.Zone__current.toString; |
| sink._addError$2(error, stackTrace); |
| }, |
| 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:0;_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:13;_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:1;_captured_callback_0", |
| call$0: function() { |
| H.leaveJsAsync(); |
| this._captured_callback_0.call$0(); |
| } |
| }, |
| _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: { |
| "^": "Closure:1;_captured_callback_0", |
| call$0: function() { |
| H.leaveJsAsync(); |
| this._captured_callback_0.call$0(); |
| } |
| }, |
| _awaitOnObject_closure: { |
| "^": "Closure:0;_captured_bodyFunction_0", |
| call$1: function(result) { |
| return this._captured_bodyFunction_0.call$2(0, result); |
| } |
| }, |
| _awaitOnObject_closure0: { |
| "^": "Closure:5;_captured_bodyFunction_1", |
| call$2: function(error, stackTrace) { |
| this._captured_bodyFunction_1.call$2(1, new H.ExceptionAndStackTrace(error, stackTrace)); |
| } |
| }, |
| _wrapJsFunctionForAsync_closure: { |
| "^": "Closure:14;_captured_protected_0", |
| call$2: function(errorCode, result) { |
| this._captured_protected_0(errorCode, result); |
| } |
| }, |
| _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); |
| }, function(error) { |
| return this.completeError$2(error, null); |
| }, "completeError$1", "call$2", "call$1", "get$completeError", 2, 2, 6, 0] |
| }, |
| _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); |
| } |
| }, |
| _SyncCompleter: { |
| "^": "_Completer;future", |
| complete$1: function(_, value) { |
| var t1 = this.future; |
| if (t1._state !== 0) |
| throw H.wrapException(new P.StateError("Future already completed")); |
| t1._complete$1(value); |
| }, |
| _completeError$2: function(error, stackTrace) { |
| this.future._completeError$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 currentZone = $.Zone__current; |
| if (currentZone !== C.C__RootZone) { |
| currentZone.toString; |
| if (onError != null) |
| onError = P._registerErrorHandler(onError, currentZone); |
| } |
| return this._thenNoZoneRegistration$2(f, onError); |
| }, |
| then$1: function(f) { |
| return this.then$2$onError(f, null); |
| }, |
| _thenNoZoneRegistration$2: function(f, onError) { |
| var result = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| this._addListener$1(new P._FutureListener(null, result, onError == null ? 1 : 3, f, onError)); |
| return result; |
| }, |
| whenComplete$1: function(action) { |
| var t1, result; |
| t1 = $.Zone__current; |
| result = new P._Future(0, t1, null); |
| result.$builtinTypeInfo = this.$builtinTypeInfo; |
| if (t1 !== C.C__RootZone) |
| t1.toString; |
| this._addListener$1(new P._FutureListener(null, result, 8, action, null)); |
| 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); |
| }, function(error) { |
| return this._completeError$2(error, null); |
| }, "_completeError$1", "call$2", "call$1", "get$_completeError", 2, 2, 15, 0], |
| _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 = J.get$error$x(asyncError); |
| 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 = J.get$error$x(asyncError); |
| 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:1;_captured_this_0,_captured_listener_1", |
| call$0: function() { |
| P._Future__propagateToListeners(this._captured_this_0, this._captured_listener_1); |
| } |
| }, |
| _Future__chainForeignFuture_closure: { |
| "^": "Closure:0;_captured_target_0", |
| call$1: function(value) { |
| this._captured_target_0._completeWithValue$1(value); |
| } |
| }, |
| _Future__chainForeignFuture_closure0: { |
| "^": "Closure:7;_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:1;_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:1;_captured_this_0,_captured_coreFuture_1", |
| call$0: function() { |
| P._Future__chainCoreFuture(this._captured_coreFuture_1, this._captured_this_0); |
| } |
| }, |
| _Future__asyncComplete_closure0: { |
| "^": "Closure:1;_captured_this_2,_captured_value_3", |
| call$0: function() { |
| this._captured_this_2._completeWithValue$1(this._captured_value_3); |
| } |
| }, |
| _Future__asyncCompleteError_closure: { |
| "^": "Closure:1;_captured_this_0,_captured_error_1,_captured_stackTrace_2", |
| call$0: function() { |
| this._captured_this_0._completeError$2(this._captured_error_1, this._captured_stackTrace_2); |
| } |
| }, |
| _Future__propagateToListeners_handleValueCallback: { |
| "^": "Closure:16;_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:2;_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, J.get$error$x(asyncError)); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| t1 = J.get$error$x(asyncError); |
| 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, J.get$error$x(asyncError), asyncError.get$stackTrace()); |
| else |
| t4._captured_listenerValueOrError_2 = t3.runUnary$2(errorCallback, J.get$error$x(asyncError)); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e0 = t1; |
| s0 = H.getTraceFromException(exception); |
| t1 = J.get$error$x(asyncError); |
| 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:2;_box_2,_box_1,_captured_hasError_8,_captured_listener_9,_captured_zone_10", |
| call$0: function() { |
| var t1, e, s, completeResult, t2, exception, t3, 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 = J.get$error$x(this._box_2._captured_source_4.get$_error()); |
| t2 = e; |
| t2 = t1 == null ? t2 == null : t1 === t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| t2 = this._box_1; |
| if (t1) |
| t2._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) { |
| t3 = this._captured_listener_9; |
| result = t3.get$result(t3); |
| 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:0;_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:7;_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(); |
| } |
| }, |
| Stream: { |
| "^": "Object;", |
| map$1: function(_, convert) { |
| return H.setRuntimeTypeInfo(new P._MapStream(convert, this), [H.getRuntimeTypeArgument(this, "Stream", 0), null]); |
| }, |
| contains$1: function(_, needle) { |
| var t1, future; |
| t1 = {}; |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [P.bool]); |
| t1._captured_subscription_0 = null; |
| t1._captured_subscription_0 = this.listen$4$cancelOnError$onDone$onError(new P.Stream_contains_closure(t1, this, needle, future), true, new P.Stream_contains_closure0(future), future.get$_completeError()); |
| return future; |
| }, |
| forEach$1: function(_, action) { |
| var t1, future; |
| t1 = {}; |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [null]); |
| t1._captured_subscription_0 = null; |
| t1._captured_subscription_0 = this.listen$4$cancelOnError$onDone$onError(new P.Stream_forEach_closure(t1, this, action, future), true, new P.Stream_forEach_closure0(future), future.get$_completeError()); |
| return future; |
| }, |
| get$length: function(_) { |
| var t1, future; |
| t1 = {}; |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [P.$int]); |
| t1._captured_count_0 = 0; |
| this.listen$4$cancelOnError$onDone$onError(new P.Stream_length_closure(t1), true, new P.Stream_length_closure0(t1, future), future.get$_completeError()); |
| return future; |
| }, |
| get$isEmpty: function(_) { |
| var t1, future; |
| t1 = {}; |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [P.bool]); |
| t1._captured_subscription_0 = null; |
| t1._captured_subscription_0 = this.listen$4$cancelOnError$onDone$onError(new P.Stream_isEmpty_closure(t1, future), true, new P.Stream_isEmpty_closure0(future), future.get$_completeError()); |
| return future; |
| }, |
| toList$0: function(_) { |
| var result, future; |
| result = H.setRuntimeTypeInfo([], [H.getRuntimeTypeArgument(this, "Stream", 0)]); |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [[P.List, H.getRuntimeTypeArgument(this, "Stream", 0)]]); |
| this.listen$4$cancelOnError$onDone$onError(new P.Stream_toList_closure(this, result), true, new P.Stream_toList_closure0(result, future), future.get$_completeError()); |
| return future; |
| }, |
| get$last: function(_) { |
| var t1, future; |
| t1 = {}; |
| future = H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [H.getRuntimeTypeArgument(this, "Stream", 0)]); |
| t1._captured_result_0 = null; |
| t1._captured_foundResult_1 = false; |
| this.listen$4$cancelOnError$onDone$onError(new P.Stream_last_closure(t1, this), true, new P.Stream_last_closure0(t1, future), future.get$_completeError()); |
| return future; |
| } |
| }, |
| Stream_contains_closure: { |
| "^": "Closure;_box_0,_async$_captured_this_1,_captured_needle_2,_captured_future_3", |
| call$1: function(element) { |
| var t1, t2; |
| t1 = this._box_0; |
| t2 = this._captured_future_3; |
| P._runUserCode(new P.Stream_contains__closure(this._captured_needle_2, element), new P.Stream_contains__closure0(t1, t2), P._cancelAndErrorClosure(t1._captured_subscription_0, t2)); |
| }, |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this._async$_captured_this_1, "Stream"); |
| } |
| }, |
| Stream_contains__closure: { |
| "^": "Closure:1;_captured_needle_4,_captured_element_5", |
| call$0: function() { |
| return J.$eq$(this._captured_element_5, this._captured_needle_4); |
| } |
| }, |
| Stream_contains__closure0: { |
| "^": "Closure:17;_box_0,_captured_future_6", |
| call$1: function(isMatch) { |
| if (isMatch === true) |
| P._cancelAndValue(this._box_0._captured_subscription_0, this._captured_future_6, true); |
| } |
| }, |
| Stream_contains_closure0: { |
| "^": "Closure:1;_captured_future_7", |
| call$0: function() { |
| this._captured_future_7._complete$1(false); |
| } |
| }, |
| Stream_forEach_closure: { |
| "^": "Closure;_box_0,_async$_captured_this_1,_captured_action_2,_captured_future_3", |
| call$1: function(element) { |
| P._runUserCode(new P.Stream_forEach__closure(this._captured_action_2, element), new P.Stream_forEach__closure0(), P._cancelAndErrorClosure(this._box_0._captured_subscription_0, this._captured_future_3)); |
| }, |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this._async$_captured_this_1, "Stream"); |
| } |
| }, |
| Stream_forEach__closure: { |
| "^": "Closure:1;_captured_action_4,_captured_element_5", |
| call$0: function() { |
| return this._captured_action_4.call$1(this._captured_element_5); |
| } |
| }, |
| Stream_forEach__closure0: { |
| "^": "Closure:0;", |
| call$1: function(_) { |
| } |
| }, |
| Stream_forEach_closure0: { |
| "^": "Closure:1;_captured_future_6", |
| call$0: function() { |
| this._captured_future_6._complete$1(null); |
| } |
| }, |
| Stream_length_closure: { |
| "^": "Closure:0;_box_0", |
| call$1: function(_) { |
| ++this._box_0._captured_count_0; |
| } |
| }, |
| Stream_length_closure0: { |
| "^": "Closure:1;_box_0,_captured_future_1", |
| call$0: function() { |
| this._captured_future_1._complete$1(this._box_0._captured_count_0); |
| } |
| }, |
| Stream_isEmpty_closure: { |
| "^": "Closure:0;_box_0,_captured_future_1", |
| call$1: function(_) { |
| P._cancelAndValue(this._box_0._captured_subscription_0, this._captured_future_1, false); |
| } |
| }, |
| Stream_isEmpty_closure0: { |
| "^": "Closure:1;_captured_future_2", |
| call$0: function() { |
| this._captured_future_2._complete$1(true); |
| } |
| }, |
| Stream_toList_closure: { |
| "^": "Closure;_captured_this_0,_async$_captured_result_1", |
| call$1: function(data) { |
| this._async$_captured_result_1.push(data); |
| }, |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this._captured_this_0, "Stream"); |
| } |
| }, |
| Stream_toList_closure0: { |
| "^": "Closure:1;_captured_result_2,_captured_future_3", |
| call$0: function() { |
| this._captured_future_3._complete$1(this._captured_result_2); |
| } |
| }, |
| Stream_last_closure: { |
| "^": "Closure;_box_0,_async$_captured_this_1", |
| call$1: function(value) { |
| var t1 = this._box_0; |
| t1._captured_foundResult_1 = true; |
| t1._captured_result_0 = value; |
| }, |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this._async$_captured_this_1, "Stream"); |
| } |
| }, |
| Stream_last_closure0: { |
| "^": "Closure:1;_box_0,_captured_future_2", |
| call$0: function() { |
| var e, s, t1, exception; |
| t1 = this._box_0; |
| if (t1._captured_foundResult_1) { |
| this._captured_future_2._complete$1(t1._captured_result_0); |
| return; |
| } |
| try { |
| t1 = H.IterableElementError_noElement(); |
| throw H.wrapException(t1); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| P._completeWithErrorCallback(this._captured_future_2, e, s); |
| } |
| } |
| }, |
| StreamSubscription: { |
| "^": "Object;" |
| }, |
| _EventSink: { |
| "^": "Object;" |
| }, |
| _BufferingStreamSubscription: { |
| "^": "Object;_zone<,_state?", |
| pause$1: function(_, resumeSignal) { |
| var t1 = this._state; |
| if ((t1 & 8) !== 0) |
| return; |
| this._state = (t1 + 128 | 4) >>> 0; |
| if (t1 < 128 && this._pending != null) |
| this._pending.cancelSchedule$0(); |
| if ((t1 & 4) === 0 && (this._state & 32) === 0) |
| this._guardCallback$1(this.get$_onPause()); |
| }, |
| pause$0: function($receiver) { |
| return this.pause$1($receiver, null); |
| }, |
| resume$0: function() { |
| var t1 = this._state; |
| if ((t1 & 8) !== 0) |
| return; |
| if (t1 >= 128) { |
| t1 -= 128; |
| this._state = t1; |
| if (t1 < 128) { |
| if ((t1 & 64) !== 0) { |
| t1 = this._pending; |
| t1 = !t1.get$isEmpty(t1); |
| } else |
| t1 = false; |
| if (t1) |
| this._pending.schedule$1(this); |
| else { |
| t1 = (this._state & 4294967291) >>> 0; |
| this._state = t1; |
| if ((t1 & 32) === 0) |
| this._guardCallback$1(this.get$_onResume()); |
| } |
| } |
| } |
| }, |
| cancel$0: function() { |
| var t1 = (this._state & 4294967279) >>> 0; |
| this._state = t1; |
| if ((t1 & 8) !== 0) |
| return this._cancelFuture; |
| this._cancel$0(); |
| return this._cancelFuture; |
| }, |
| _cancel$0: function() { |
| var t1 = (this._state | 8) >>> 0; |
| this._state = t1; |
| if ((t1 & 64) !== 0) |
| this._pending.cancelSchedule$0(); |
| if ((this._state & 32) === 0) |
| this._pending = null; |
| this._cancelFuture = this._onCancel$0(); |
| }, |
| _async$_add$1: ["super$_BufferingStreamSubscription$_add", function(data) { |
| var t1 = this._state; |
| if ((t1 & 8) !== 0) |
| return; |
| if (t1 < 32) |
| this._sendData$1(data); |
| else |
| this._addPending$1(H.setRuntimeTypeInfo(new P._DelayedData(data, null), [null])); |
| }], |
| _addError$2: ["super$_BufferingStreamSubscription$_addError", function(error, stackTrace) { |
| var t1 = this._state; |
| if ((t1 & 8) !== 0) |
| return; |
| if (t1 < 32) |
| this._sendError$2(error, stackTrace); |
| else |
| this._addPending$1(new P._DelayedError(error, stackTrace, null)); |
| }], |
| _close$0: function() { |
| var t1 = this._state; |
| if ((t1 & 8) !== 0) |
| return; |
| t1 = (t1 | 2) >>> 0; |
| this._state = t1; |
| if (t1 < 32) |
| this._sendDone$0(); |
| else |
| this._addPending$1(C.C__DelayedDone); |
| }, |
| _onPause$0: [function() { |
| }, "call$0", "get$_onPause", 0, 0, 2], |
| _onResume$0: [function() { |
| }, "call$0", "get$_onResume", 0, 0, 2], |
| _onCancel$0: function() { |
| return; |
| }, |
| _addPending$1: function($event) { |
| var pending, t1; |
| pending = this._pending; |
| if (pending == null) { |
| pending = new P._StreamImplEvents(null, null, 0); |
| this._pending = pending; |
| } |
| pending.add$1(0, $event); |
| t1 = this._state; |
| if ((t1 & 64) === 0) { |
| t1 = (t1 | 64) >>> 0; |
| this._state = t1; |
| if (t1 < 128) |
| this._pending.schedule$1(this); |
| } |
| }, |
| _sendData$1: function(data) { |
| var t1 = this._state; |
| this._state = (t1 | 32) >>> 0; |
| this._zone.runUnaryGuarded$2(this._async$_onData, data); |
| this._state = (this._state & 4294967263) >>> 0; |
| this._checkState$1((t1 & 4) !== 0); |
| }, |
| _sendError$2: function(error, stackTrace) { |
| var t1, t2; |
| t1 = this._state; |
| t2 = new P._BufferingStreamSubscription__sendError_sendError(this, error, stackTrace); |
| if ((t1 & 1) !== 0) { |
| this._state = (t1 | 16) >>> 0; |
| this._cancel$0(); |
| t1 = this._cancelFuture; |
| if (!!J.getInterceptor(t1).$isFuture) |
| t1.whenComplete$1(t2); |
| else |
| t2.call$0(); |
| } else { |
| t2.call$0(); |
| this._checkState$1((t1 & 4) !== 0); |
| } |
| }, |
| _sendDone$0: function() { |
| var t1, t2; |
| t1 = new P._BufferingStreamSubscription__sendDone_sendDone(this); |
| this._cancel$0(); |
| this._state = (this._state | 16) >>> 0; |
| t2 = this._cancelFuture; |
| if (!!J.getInterceptor(t2).$isFuture) |
| t2.whenComplete$1(t1); |
| else |
| t1.call$0(); |
| }, |
| _guardCallback$1: function(callback) { |
| var t1 = this._state; |
| this._state = (t1 | 32) >>> 0; |
| callback.call$0(); |
| this._state = (this._state & 4294967263) >>> 0; |
| this._checkState$1((t1 & 4) !== 0); |
| }, |
| _checkState$1: function(wasInputPaused) { |
| var t1, isInputPaused; |
| if ((this._state & 64) !== 0) { |
| t1 = this._pending; |
| t1 = t1.get$isEmpty(t1); |
| } else |
| t1 = false; |
| if (t1) { |
| t1 = (this._state & 4294967231) >>> 0; |
| this._state = t1; |
| if ((t1 & 4) !== 0) |
| if (t1 < 128) { |
| t1 = this._pending; |
| t1 = t1 == null || t1.get$isEmpty(t1); |
| } else |
| t1 = false; |
| else |
| t1 = false; |
| if (t1) |
| this._state = (this._state & 4294967291) >>> 0; |
| } |
| for (; true; wasInputPaused = isInputPaused) { |
| t1 = this._state; |
| if ((t1 & 8) !== 0) { |
| this._pending = null; |
| return; |
| } |
| isInputPaused = (t1 & 4) !== 0; |
| if (wasInputPaused === isInputPaused) |
| break; |
| this._state = (t1 ^ 32) >>> 0; |
| if (isInputPaused) |
| this._onPause$0(); |
| else |
| this._onResume$0(); |
| this._state = (this._state & 4294967263) >>> 0; |
| } |
| t1 = this._state; |
| if ((t1 & 64) !== 0 && t1 < 128) |
| this._pending.schedule$1(this); |
| }, |
| _BufferingStreamSubscription$4: function(onData, onError, onDone, cancelOnError, $T) { |
| var t1 = this._zone; |
| t1.toString; |
| this._async$_onData = onData; |
| this._onError = P._registerErrorHandler(onError, t1); |
| this._onDone = onDone; |
| } |
| }, |
| _BufferingStreamSubscription__sendError_sendError: { |
| "^": "Closure:2;_captured_this_0,_captured_error_1,_captured_stackTrace_2", |
| call$0: function() { |
| var t1, t2, t3, t4, t5, t6; |
| t1 = this._captured_this_0; |
| t2 = t1._state; |
| if ((t2 & 8) !== 0 && (t2 & 16) === 0) |
| return; |
| t1._state = (t2 | 32) >>> 0; |
| t2 = t1._onError; |
| t3 = H.getDynamicRuntimeType(); |
| t3 = H.buildFunctionType(t3, [t3, t3])._isTest$1(t2); |
| t4 = t1._zone; |
| t5 = this._captured_error_1; |
| t6 = t1._onError; |
| if (t3) |
| t4.runBinaryGuarded$3(t6, t5, this._captured_stackTrace_2); |
| else |
| t4.runUnaryGuarded$2(t6, t5); |
| t1._state = (t1._state & 4294967263) >>> 0; |
| } |
| }, |
| _BufferingStreamSubscription__sendDone_sendDone: { |
| "^": "Closure:2;_captured_this_0", |
| call$0: function() { |
| var t1, t2; |
| t1 = this._captured_this_0; |
| t2 = t1._state; |
| if ((t2 & 16) === 0) |
| return; |
| t1._state = (t2 | 42) >>> 0; |
| t1._zone.runGuarded$1(t1._onDone); |
| t1._state = (t1._state & 4294967263) >>> 0; |
| } |
| }, |
| _DelayedEvent: { |
| "^": "Object;next@" |
| }, |
| _DelayedData: { |
| "^": "_DelayedEvent;value,next", |
| perform$1: function(dispatch) { |
| dispatch._sendData$1(this.value); |
| } |
| }, |
| _DelayedError: { |
| "^": "_DelayedEvent;error>,stackTrace<,next", |
| perform$1: function(dispatch) { |
| dispatch._sendError$2(this.error, this.stackTrace); |
| } |
| }, |
| _DelayedDone: { |
| "^": "Object;", |
| perform$1: function(dispatch) { |
| dispatch._sendDone$0(); |
| }, |
| get$next: function() { |
| return; |
| }, |
| set$next: function(_) { |
| throw H.wrapException(new P.StateError("No events after a done.")); |
| } |
| }, |
| _PendingEvents: { |
| "^": "Object;_state?", |
| schedule$1: function(dispatch) { |
| var t1 = this._state; |
| if (t1 === 1) |
| return; |
| if (t1 >= 1) { |
| this._state = 1; |
| return; |
| } |
| P.scheduleMicrotask(new P._PendingEvents_schedule_closure(this, dispatch)); |
| this._state = 1; |
| }, |
| cancelSchedule$0: function() { |
| if (this._state === 1) |
| this._state = 3; |
| } |
| }, |
| _PendingEvents_schedule_closure: { |
| "^": "Closure:1;_captured_this_0,_captured_dispatch_1", |
| call$0: function() { |
| var t1, oldState; |
| t1 = this._captured_this_0; |
| oldState = t1._state; |
| t1._state = 0; |
| if (oldState === 3) |
| return; |
| t1.handleNext$1(this._captured_dispatch_1); |
| } |
| }, |
| _StreamImplEvents: { |
| "^": "_PendingEvents;firstPendingEvent,lastPendingEvent,_state", |
| get$isEmpty: function(_) { |
| return this.lastPendingEvent == null; |
| }, |
| add$1: function(_, $event) { |
| var t1 = this.lastPendingEvent; |
| if (t1 == null) { |
| this.lastPendingEvent = $event; |
| this.firstPendingEvent = $event; |
| } else { |
| t1.set$next($event); |
| this.lastPendingEvent = $event; |
| } |
| }, |
| handleNext$1: function(dispatch) { |
| var $event, t1; |
| $event = this.firstPendingEvent; |
| t1 = $event.get$next(); |
| this.firstPendingEvent = t1; |
| if (t1 == null) |
| this.lastPendingEvent = null; |
| $event.perform$1(dispatch); |
| } |
| }, |
| _StreamIteratorImpl: { |
| "^": "Object;_subscription,_async$_current,_futureOrPrefetch,_state?", |
| _clear$0: function(_) { |
| this._subscription = null; |
| this._futureOrPrefetch = null; |
| this._async$_current = null; |
| this._state = 1; |
| }, |
| _async$_onData$1: [function(data) { |
| var hasNext; |
| if (this._state === 2) { |
| this._async$_current = data; |
| hasNext = this._futureOrPrefetch; |
| this._futureOrPrefetch = null; |
| this._state = 0; |
| hasNext._complete$1(true); |
| return; |
| } |
| this._subscription.pause$0(0); |
| this._futureOrPrefetch = data; |
| this._state = 3; |
| }, "call$1", "get$_async$_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(0); |
| hasNext._completeError$2(error, stackTrace); |
| return; |
| } |
| this._subscription.pause$0(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, 6, 0], |
| _onDone$0: [function() { |
| if (this._state === 2) { |
| var hasNext = this._futureOrPrefetch; |
| this._clear$0(0); |
| hasNext._complete$1(false); |
| return; |
| } |
| this._subscription.pause$0(0); |
| this._futureOrPrefetch = null; |
| this._state = 5; |
| }, "call$0", "get$_onDone", 0, 0, 2] |
| }, |
| _cancelAndError_closure: { |
| "^": "Closure:1;_captured_future_0,_captured_error_1,_captured_stackTrace_2", |
| call$0: function() { |
| return this._captured_future_0._completeError$2(this._captured_error_1, this._captured_stackTrace_2); |
| } |
| }, |
| _cancelAndErrorClosure_closure: { |
| "^": "Closure:5;_captured_subscription_0,_captured_future_1", |
| call$2: function(error, stackTrace) { |
| return P._cancelAndError(this._captured_subscription_0, this._captured_future_1, error, stackTrace); |
| } |
| }, |
| _cancelAndValue_closure: { |
| "^": "Closure:1;_captured_future_0,_captured_value_1", |
| call$0: function() { |
| return this._captured_future_0._complete$1(this._captured_value_1); |
| } |
| }, |
| _ForwardingStream: { |
| "^": "Stream;", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| return this._createSubscription$4(onData, onError, onDone, true === cancelOnError); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| }, |
| _createSubscription$4: function(onData, onError, onDone, cancelOnError) { |
| return P._ForwardingStreamSubscription$(this, onData, onError, onDone, cancelOnError, H.getRuntimeTypeArgument(this, "_ForwardingStream", 0), H.getRuntimeTypeArgument(this, "_ForwardingStream", 1)); |
| }, |
| _handleData$2: function(data, sink) { |
| sink._async$_add$1(data); |
| }, |
| $asStream: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| _ForwardingStreamSubscription: { |
| "^": "_BufferingStreamSubscription;_stream,_subscription,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending", |
| _async$_add$1: function(data) { |
| if ((this._state & 2) !== 0) |
| return; |
| this.super$_BufferingStreamSubscription$_add(data); |
| }, |
| _addError$2: function(error, stackTrace) { |
| if ((this._state & 2) !== 0) |
| return; |
| this.super$_BufferingStreamSubscription$_addError(error, stackTrace); |
| }, |
| _onPause$0: [function() { |
| var t1 = this._subscription; |
| if (t1 == null) |
| return; |
| t1.pause$0(0); |
| }, "call$0", "get$_onPause", 0, 0, 2], |
| _onResume$0: [function() { |
| var t1 = this._subscription; |
| if (t1 == null) |
| return; |
| t1.resume$0(); |
| }, "call$0", "get$_onResume", 0, 0, 2], |
| _onCancel$0: function() { |
| var t1 = this._subscription; |
| if (t1 != null) { |
| this._subscription = null; |
| return t1.cancel$0(); |
| } |
| return; |
| }, |
| _handleData$1: [function(data) { |
| this._stream._handleData$2(data, this); |
| }, "call$1", "get$_handleData", 2, 0, function() { |
| return H.computeSignature(function(S, T) { |
| return {func: 1, void: true, args: [S]}; |
| }, this.$receiver, "_ForwardingStreamSubscription"); |
| }], |
| _handleError$2: [function(error, stackTrace) { |
| this._addError$2(error, stackTrace); |
| }, "call$2", "get$_handleError", 4, 0, 18], |
| _handleDone$0: [function() { |
| this._close$0(); |
| }, "call$0", "get$_handleDone", 0, 0, 2], |
| _ForwardingStreamSubscription$5: function(_stream, onData, onError, onDone, cancelOnError, $S, $T) { |
| var t1, t2; |
| t1 = this.get$_handleData(); |
| t2 = this.get$_handleError(); |
| this._subscription = this._stream._async$_source.listen$3$onDone$onError(t1, this.get$_handleDone(), t2); |
| }, |
| $as_BufferingStreamSubscription: function($S, $T) { |
| return [$T]; |
| }, |
| static: {_ForwardingStreamSubscription$: function(_stream, onData, onError, onDone, cancelOnError, $S, $T) { |
| var t1 = $.Zone__current; |
| t1 = H.setRuntimeTypeInfo(new P._ForwardingStreamSubscription(_stream, null, null, null, null, t1, cancelOnError ? 1 : 0, null, null), [$S, $T]); |
| t1._BufferingStreamSubscription$4(onData, onError, onDone, cancelOnError, $T); |
| t1._ForwardingStreamSubscription$5(_stream, onData, onError, onDone, cancelOnError, $S, $T); |
| return t1; |
| }} |
| }, |
| _MapStream: { |
| "^": "_ForwardingStream;_transform,_async$_source", |
| _handleData$2: function(inputEvent, sink) { |
| var outputEvent, e, s, exception, t1; |
| outputEvent = null; |
| try { |
| outputEvent = this._transform$1(inputEvent); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| P._addErrorWithReplacement(sink, e, s); |
| return; |
| } |
| sink._async$_add$1(outputEvent); |
| }, |
| _transform$1: function(arg0) { |
| return this._transform.call$1(arg0); |
| } |
| }, |
| AsyncError: { |
| "^": "Object;error>,stackTrace<", |
| toString$0: function(_) { |
| return H.S(this.error); |
| }, |
| $isError: 1 |
| }, |
| _Zone: { |
| "^": "Object;" |
| }, |
| _rootHandleUncaughtError_closure: { |
| "^": "Closure:1;_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); |
| } |
| }, |
| runUnaryGuarded$2: function(f, arg) { |
| var e, s, t1, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| t1 = f.call$1(arg); |
| return t1; |
| } |
| t1 = P._rootRunUnary(null, null, this, f, arg); |
| return t1; |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| s = H.getTraceFromException(exception); |
| return P._rootHandleUncaughtError(null, null, this, e, s); |
| } |
| }, |
| runBinaryGuarded$3: function(f, arg1, arg2) { |
| var e, s, t1, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| t1 = f.call$2(arg1, arg2); |
| return t1; |
| } |
| t1 = P._rootRunBinary(null, null, this, f, arg1, arg2); |
| 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); |
| }, |
| bindUnaryCallback$2$runGuarded: function(f, runGuarded) { |
| if (runGuarded) |
| return new P._RootZone_bindUnaryCallback_closure(this, f); |
| else |
| return new P._RootZone_bindUnaryCallback_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:1;_captured_this_0,_captured_f_1", |
| call$0: function() { |
| return this._captured_this_0.runGuarded$1(this._captured_f_1); |
| } |
| }, |
| _RootZone_bindCallback_closure0: { |
| "^": "Closure:1;_captured_this_2,_captured_f_3", |
| call$0: function() { |
| return this._captured_this_2.run$1(this._captured_f_3); |
| } |
| }, |
| _RootZone_bindUnaryCallback_closure: { |
| "^": "Closure:0;_captured_this_0,_captured_f_1", |
| call$1: function(arg) { |
| return this._captured_this_0.runUnaryGuarded$2(this._captured_f_1, arg); |
| } |
| }, |
| _RootZone_bindUnaryCallback_closure0: { |
| "^": "Closure:0;_captured_this_2,_captured_f_3", |
| call$1: function(arg) { |
| return this._captured_this_2.runUnary$2(this._captured_f_3, arg); |
| } |
| } |
| }], ["dart.collection", "dart:collection",, P, { |
| "^": "", |
| LinkedHashMap_LinkedHashMap$_empty: function($K, $V) { |
| return H.setRuntimeTypeInfo(new H.JsLinkedHashMap(0, null, null, null, null, null, 0), [$K, $V]); |
| }, |
| 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])); |
| }, |
| HashSet_HashSet: function(equals, hashCode, isValidKey, $E) { |
| return H.setRuntimeTypeInfo(new P._HashSet(0, null, null, null, null), [$E]); |
| }, |
| 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, -1); |
| 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, -1); |
| 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, -1); |
| ultimateString = parts.pop(); |
| if (0 >= parts.length) |
| return H.ioore(parts, -1); |
| 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, -1); |
| penultimateString = parts.pop(); |
| $length += ultimateString.length + 2; |
| } else { |
| ultimate = it.get$current(); |
| ++count; |
| for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { |
| ultimate0 = it.get$current(); |
| ++count; |
| if (count > 100) { |
| while (true) { |
| if (!($length > 75 && count > 3)) |
| break; |
| if (0 >= parts.length) |
| return H.ioore(parts, -1); |
| $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, -1); |
| $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$identity: function($K, $V) { |
| return P._LinkedIdentityHashMap__LinkedIdentityHashMap$es6($K, $V); |
| }, |
| LinkedHashSet_LinkedHashSet: function(equals, hashCode, isValidKey, $E) { |
| return H.setRuntimeTypeInfo(new P._LinkedHashSet(0, null, null, null, null, null, 0), [$E]); |
| }, |
| LinkedHashSet_LinkedHashSet$from: function(elements, $E) { |
| var result, t1, _i; |
| result = P.LinkedHashSet_LinkedHashSet(null, null, null, $E); |
| for (t1 = elements.length, _i = 0; _i < elements.length; elements.length === t1 || (0, H.throwConcurrentModificationError)(elements), ++_i) |
| result.add$1(0, elements[_i]); |
| return result; |
| }, |
| 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$ax(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, -1); |
| t1.pop(); |
| } |
| t1 = result.get$_contents(); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _LinkedIdentityHashMap: { |
| "^": "JsLinkedHashMap;__js_helper$_length,_strings,_nums,_rest,_first,__js_helper$_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; |
| }, |
| static: {_LinkedIdentityHashMap__LinkedIdentityHashMap$es6: function($K, $V) { |
| return H.setRuntimeTypeInfo(new P._LinkedIdentityHashMap(0, null, null, null, null, null, 0), [$K, $V]); |
| }} |
| }, |
| _HashSet: { |
| "^": "_HashSetBase;_collection$_length,_collection$_strings,_collection$_nums,_collection$_rest,_elements", |
| get$iterator: function(_) { |
| var t1 = new P.HashSetIterator(this, this._computeElements$0(), 0, null); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| return t1; |
| }, |
| get$length: function(_) { |
| return this._collection$_length; |
| }, |
| get$isEmpty: function(_) { |
| return this._collection$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._collection$_length !== 0; |
| }, |
| contains$1: function(_, object) { |
| var strings, nums; |
| if (typeof object === "string" && object !== "__proto__") { |
| strings = this._collection$_strings; |
| return strings == null ? false : strings[object] != null; |
| } else if (typeof object === "number" && (object & 0x3ffffff) === object) { |
| nums = this._collection$_nums; |
| return nums == null ? false : 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; |
| 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$asx(bucket, index); |
| }, |
| add$1: function(_, element) { |
| var strings, table, nums; |
| if (typeof element === "string" && element !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) { |
| table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| this._collection$_strings = table; |
| strings = table; |
| } |
| return this._addHashTableEntry$2(strings, element); |
| } else if (typeof element === "number" && (element & 0x3ffffff) === element) { |
| nums = this._collection$_nums; |
| if (nums == null) { |
| table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| this._collection$_nums = table; |
| nums = table; |
| } |
| 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._HashSet__newHashTable(); |
| this._collection$_rest = rest; |
| } |
| hash = this._computeHashCode$1(element); |
| bucket = rest[hash]; |
| if (bucket == null) |
| rest[hash] = [element]; |
| else { |
| if (this._findBucketIndex$2(bucket, element) >= 0) |
| return false; |
| bucket.push(element); |
| } |
| ++this._collection$_length; |
| this._elements = null; |
| return true; |
| }, |
| _computeElements$0: function() { |
| var t1, result, strings, names, entries, index, i, nums, rest, bucket, $length, i0; |
| t1 = this._elements; |
| if (t1 != null) |
| return t1; |
| result = new Array(this._collection$_length); |
| result.fixed$length = Array; |
| strings = this._collection$_strings; |
| if (strings != null) { |
| names = Object.getOwnPropertyNames(strings); |
| entries = names.length; |
| for (index = 0, i = 0; i < entries; ++i) { |
| result[index] = names[i]; |
| ++index; |
| } |
| } else |
| index = 0; |
| nums = this._collection$_nums; |
| if (nums != null) { |
| names = Object.getOwnPropertyNames(nums); |
| entries = names.length; |
| for (i = 0; i < entries; ++i) { |
| result[index] = +names[i]; |
| ++index; |
| } |
| } |
| rest = this._collection$_rest; |
| if (rest != null) { |
| names = Object.getOwnPropertyNames(rest); |
| entries = names.length; |
| for (i = 0; i < entries; ++i) { |
| bucket = rest[names[i]]; |
| $length = bucket.length; |
| for (i0 = 0; i0 < $length; ++i0) { |
| result[index] = bucket[i0]; |
| ++index; |
| } |
| } |
| } |
| this._elements = result; |
| return result; |
| }, |
| _addHashTableEntry$2: function(table, element) { |
| if (table[element] != null) |
| return false; |
| table[element] = 0; |
| ++this._collection$_length; |
| this._elements = null; |
| return true; |
| }, |
| _computeHashCode$1: function(element) { |
| return J.get$hashCode$(element) & 0x3ffffff; |
| }, |
| _findBucketIndex$2: function(bucket, element) { |
| var $length, i; |
| if (bucket == null) |
| return -1; |
| $length = bucket.length; |
| for (i = 0; i < $length; ++i) |
| if (J.$eq$(bucket[i], element)) |
| return i; |
| return -1; |
| }, |
| $isEfficientLength: 1, |
| static: {_HashSet__newHashTable: function() { |
| var table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| return table; |
| }} |
| }, |
| HashSetIterator: { |
| "^": "Object;_set,_elements,_offset,_collection$_current", |
| get$current: function() { |
| return this._collection$_current; |
| }, |
| moveNext$0: function() { |
| var elements, offset, t1; |
| elements = this._elements; |
| offset = this._offset; |
| t1 = this._set; |
| if (elements !== t1._elements) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| else if (offset >= elements.length) { |
| this._collection$_current = null; |
| return false; |
| } else { |
| this._collection$_current = elements[offset]; |
| this._offset = offset + 1; |
| return true; |
| } |
| } |
| }, |
| _LinkedHashSet: { |
| "^": "_HashSetBase;_collection$_length,_collection$_strings,_collection$_nums,_collection$_rest,_collection$_first,_last,_collection$_modifications", |
| get$iterator: function(_) { |
| var t1 = H.setRuntimeTypeInfo(new P.LinkedHashSetIterator(this, this._collection$_modifications, null, null), [null]); |
| t1._cell = t1._set._collection$_first; |
| return t1; |
| }, |
| get$length: function(_) { |
| return this._collection$_length; |
| }, |
| get$isEmpty: function(_) { |
| return this._collection$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._collection$_length !== 0; |
| }, |
| 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$asx(bucket, index).get$_collection$_element(); |
| }, |
| forEach$1: function(_, action) { |
| var cell, modifications; |
| cell = this._collection$_first; |
| modifications = this._collection$_modifications; |
| for (; cell != null;) { |
| action.call$1(cell._collection$_element); |
| if (modifications !== this._collection$_modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| cell = cell._collection$_next; |
| } |
| }, |
| get$last: function(_) { |
| var t1 = this._last; |
| if (t1 == null) |
| throw H.wrapException(new P.StateError("No elements")); |
| return t1._collection$_element; |
| }, |
| add$1: function(_, element) { |
| var strings, table, nums; |
| if (typeof element === "string" && element !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) { |
| table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| this._collection$_strings = table; |
| strings = table; |
| } |
| return this._addHashTableEntry$2(strings, element); |
| } else if (typeof element === "number" && (element & 0x3ffffff) === element) { |
| nums = this._collection$_nums; |
| if (nums == null) { |
| table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| this._collection$_nums = table; |
| nums = table; |
| } |
| 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._removeHashTableEntry$2(this._collection$_strings, object); |
| else if (typeof object === "number" && (object & 0x3ffffff) === object) |
| return this._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._unlinkCell$1(bucket.splice(index, 1)[0]); |
| return true; |
| }, |
| clear$0: function(_) { |
| if (this._collection$_length > 0) { |
| this._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; |
| }, |
| _removeHashTableEntry$2: function(table, element) { |
| var cell; |
| if (table == null) |
| return false; |
| cell = table[element]; |
| if (cell == null) |
| return false; |
| this._unlinkCell$1(cell); |
| delete table[element]; |
| return true; |
| }, |
| _newLinkedCell$1: function(element) { |
| var cell, last; |
| cell = new P.LinkedHashSetCell(element, null, null); |
| if (this._collection$_first == null) { |
| this._last = cell; |
| this._collection$_first = cell; |
| } else { |
| last = this._last; |
| cell._previous = last; |
| last._collection$_next = cell; |
| this._last = cell; |
| } |
| ++this._collection$_length; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| return cell; |
| }, |
| _unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$_previous(); |
| next = cell._collection$_next; |
| if (previous == null) |
| this._collection$_first = next; |
| else |
| previous._collection$_next = next; |
| if (next == null) |
| this._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$_collection$_element(), element)) |
| return i; |
| return -1; |
| }, |
| $isEfficientLength: 1, |
| static: {_LinkedHashSet__newHashTable: function() { |
| var table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| return table; |
| }} |
| }, |
| LinkedHashSetCell: { |
| "^": "Object;_collection$_element<,_collection$_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._collection$_element; |
| this._cell = t1._collection$_next; |
| return true; |
| } |
| } |
| } |
| }, |
| UnmodifiableListView: { |
| "^": "UnmodifiableListBase;_collection$_source", |
| get$length: function(_) { |
| return this._collection$_source.length; |
| }, |
| $index: function(_, index) { |
| var t1 = this._collection$_source; |
| if (index >>> 0 !== index || index >= t1.length) |
| return H.ioore(t1, index); |
| return t1[index]; |
| } |
| }, |
| _HashSetBase: { |
| "^": "SetBase;" |
| }, |
| IterableBase: { |
| "^": "Iterable;" |
| }, |
| ListBase: { |
| "^": "Object_ListMixin;" |
| }, |
| Object_ListMixin: { |
| "^": "Object+ListMixin;", |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1 |
| }, |
| ListMixin: { |
| "^": "Object;", |
| get$iterator: function(receiver) { |
| return H.setRuntimeTypeInfo(new H.ListIterator(receiver, this.get$length(receiver), 0, null), [H.getRuntimeTypeArgument(receiver, "ListMixin", 0)]); |
| }, |
| elementAt$1: function(receiver, index) { |
| return this.$index(receiver, index); |
| }, |
| forEach$1: function(receiver, action) { |
| var $length, i; |
| $length = this.get$length(receiver); |
| for (i = 0; i < $length; ++i) { |
| action.call$1(this.$index(receiver, i)); |
| if ($length !== this.get$length(receiver)) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| }, |
| get$isEmpty: function(receiver) { |
| return this.get$length(receiver) === 0; |
| }, |
| get$isNotEmpty: function(receiver) { |
| return this.get$length(receiver) !== 0; |
| }, |
| get$last: function(receiver) { |
| if (this.get$length(receiver) === 0) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| return this.$index(receiver, this.get$length(receiver) - 1); |
| }, |
| contains$1: function(receiver, element) { |
| var $length, i; |
| $length = this.get$length(receiver); |
| for (i = 0; i < this.get$length(receiver); ++i) { |
| if (J.$eq$(this.$index(receiver, i), element)) |
| return true; |
| if ($length !== this.get$length(receiver)) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| return false; |
| }, |
| where$1: function(receiver, test) { |
| return H.setRuntimeTypeInfo(new H.WhereIterable(receiver, test), [H.getRuntimeTypeArgument(receiver, "ListMixin", 0)]); |
| }, |
| map$1: function(receiver, f) { |
| return H.setRuntimeTypeInfo(new H.MappedListIterable(receiver, f), [null, null]); |
| }, |
| add$1: function(receiver, element) { |
| var t1 = this.get$length(receiver); |
| this.set$length(receiver, t1 + 1); |
| this.$indexSet(receiver, t1, element); |
| }, |
| indexOf$2: function(receiver, element, startIndex) { |
| var i; |
| if (startIndex >= this.get$length(receiver)) |
| return -1; |
| if (startIndex < 0) |
| startIndex = 0; |
| for (i = startIndex; i < this.get$length(receiver); ++i) |
| if (J.$eq$(this.$index(receiver, i), element)) |
| return i; |
| return -1; |
| }, |
| indexOf$1: function($receiver, element) { |
| return this.indexOf$2($receiver, element, 0); |
| }, |
| lastIndexOf$2: function(receiver, element, startIndex) { |
| var i; |
| if (startIndex < 0) |
| return -1; |
| if (startIndex >= this.get$length(receiver)) |
| startIndex = this.get$length(receiver) - 1; |
| for (i = startIndex; i >= 0; --i) |
| if (J.$eq$(this.$index(receiver, i), element)) |
| return i; |
| return -1; |
| }, |
| toString$0: function(receiver) { |
| return P.IterableBase_iterableToFullString(receiver, "[", "]"); |
| }, |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1 |
| }, |
| Maps_mapToString_closure: { |
| "^": "Closure:3;_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(_) { |
| var t1 = new P._ListQueueIterator(this, this._tail, this._modificationCount, this._head, null); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| return t1; |
| }, |
| 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; |
| }, |
| get$last: function(_) { |
| var t1, t2, t3; |
| t1 = this._head; |
| t2 = this._tail; |
| if (t1 === t2) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| t1 = this._table; |
| t3 = t1.length; |
| t2 = (t2 - 1 & t3 - 1) >>> 0; |
| if (t2 < 0 || t2 >= t3) |
| return H.ioore(t1, t2); |
| return t1[t2]; |
| }, |
| add$1: function(_, value) { |
| this._add$1(value); |
| }, |
| 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 < 0 || 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 = new 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 = new Array(8); |
| t1.fixed$length = Array; |
| this._table = H.setRuntimeTypeInfo(t1, [$E]); |
| }, |
| $isEfficientLength: 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,_collection$_position,_collection$_current", |
| get$current: function() { |
| return this._collection$_current; |
| }, |
| moveNext$0: function() { |
| var t1, t2, t3; |
| t1 = this._queue; |
| if (this._modificationCount !== t1._modificationCount) |
| H.throwExpression(new P.ConcurrentModificationError(t1)); |
| t2 = this._collection$_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._collection$_position = (t2 + 1 & t3 - 1) >>> 0; |
| return true; |
| } |
| }, |
| SetMixin: { |
| "^": "Object;", |
| get$isEmpty: function(_) { |
| return this.get$length(this) === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this.get$length(this) !== 0; |
| }, |
| addAll$1: function(_, elements) { |
| var t1; |
| for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) |
| this.add$1(0, t1.get$current()); |
| }, |
| 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.get$current()); |
| }, |
| join$1: function(_, separator) { |
| var iterator, buffer, t1; |
| iterator = this.get$iterator(this); |
| if (!iterator.moveNext$0()) |
| return ""; |
| buffer = new P.StringBuffer(""); |
| if (separator === "") { |
| do |
| buffer._contents += H.S(iterator.get$current()); |
| while (iterator.moveNext$0()); |
| } else { |
| buffer._contents = H.S(iterator.get$current()); |
| for (; iterator.moveNext$0();) { |
| buffer._contents += separator; |
| buffer._contents += H.S(iterator.get$current()); |
| } |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| get$last: function(_) { |
| var it, result; |
| it = this.get$iterator(this); |
| if (!it.moveNext$0()) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| do |
| result = it.get$current(); |
| while (it.moveNext$0()); |
| return result; |
| }, |
| $isEfficientLength: 1 |
| }, |
| SetBase: { |
| "^": "SetMixin;" |
| } |
| }], ["dart.convert", "dart:convert",, P, { |
| "^": "", |
| _convertJsonToDartLazy: function(object) { |
| var i; |
| if (object == null) |
| return; |
| if (typeof object != "object") |
| return object; |
| if (Object.getPrototypeOf(object) !== Array.prototype) |
| return new P._JsonMap(object, Object.create(null), null); |
| for (i = 0; i < object.length; ++i) |
| object[i] = P._convertJsonToDartLazy(object[i]); |
| return object; |
| }, |
| _parseJson: function(source, reviver) { |
| var parsed, e, t1, exception; |
| t1 = source; |
| if (typeof t1 !== "string") |
| throw H.wrapException(H.argumentErrorValue(source)); |
| parsed = null; |
| try { |
| parsed = JSON.parse(source); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| e = t1; |
| throw H.wrapException(new P.FormatException(String(e), null, null)); |
| } |
| return P._convertJsonToDartLazy(parsed); |
| }, |
| _isLeadSurrogate: function(codeUnit) { |
| codeUnit.$and(0, 64512); |
| return false; |
| }, |
| _combineSurrogatePair: function(lead, tail) { |
| return (C.JSInt_methods.$add(65536, lead.$and(0, 1023).$shl(0, 10)) | tail & 1023) >>> 0; |
| }, |
| _JsonMap: { |
| "^": "Object;_original,_processed,_data", |
| $index: function(_, key) { |
| var t1, result; |
| t1 = this._processed; |
| if (t1 == null) |
| return this._data.$index(0, key); |
| else if (typeof key !== "string") |
| return; |
| else { |
| result = t1[key]; |
| return typeof result == "undefined" ? this._process$1(key) : result; |
| } |
| }, |
| get$length: function(_) { |
| var t1; |
| if (this._processed == null) { |
| t1 = this._data; |
| t1 = t1.get$length(t1); |
| } else |
| t1 = this._computeKeys$0().length; |
| return t1; |
| }, |
| get$isEmpty: function(_) { |
| var t1; |
| if (this._processed == null) { |
| t1 = this._data; |
| t1 = t1.get$length(t1); |
| } else |
| t1 = this._computeKeys$0().length; |
| return t1 === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| var t1; |
| if (this._processed == null) { |
| t1 = this._data; |
| t1 = t1.get$length(t1); |
| } else |
| t1 = this._computeKeys$0().length; |
| return t1 > 0; |
| }, |
| get$values: function(_) { |
| var t1; |
| if (this._processed == null) { |
| t1 = this._data; |
| return t1.get$values(t1); |
| } |
| return H.MappedIterable_MappedIterable(this._computeKeys$0(), new P._JsonMap_values_closure(this), null, null); |
| }, |
| $indexSet: function(_, key, value) { |
| var processed, original; |
| if (this._processed == null) |
| this._data.$indexSet(0, key, value); |
| else if (this.containsKey$1(key)) { |
| processed = this._processed; |
| processed[key] = value; |
| original = this._original; |
| if (original == null ? processed != null : original !== processed) |
| original[key] = null; |
| } else |
| this._upgrade$0().$indexSet(0, key, value); |
| }, |
| containsKey$1: function(key) { |
| if (this._processed == null) |
| return this._data.containsKey$1(key); |
| if (typeof key !== "string") |
| return false; |
| return Object.prototype.hasOwnProperty.call(this._original, key); |
| }, |
| putIfAbsent$2: function(key, ifAbsent) { |
| var value; |
| if (this.containsKey$1(key)) |
| return this.$index(0, key); |
| value = ifAbsent.call$0(); |
| this.$indexSet(0, key, value); |
| return value; |
| }, |
| forEach$1: function(_, f) { |
| var keys, i, key, value; |
| if (this._processed == null) |
| return this._data.forEach$1(0, f); |
| keys = this._computeKeys$0(); |
| for (i = 0; i < keys.length; ++i) { |
| key = keys[i]; |
| value = this._processed[key]; |
| if (typeof value == "undefined") { |
| value = P._convertJsonToDartLazy(this._original[key]); |
| this._processed[key] = value; |
| } |
| f.call$2(key, value); |
| if (keys !== this._data) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| toString$0: function(_) { |
| return P.Maps_mapToString(this); |
| }, |
| _computeKeys$0: function() { |
| var keys = this._data; |
| if (keys == null) { |
| keys = Object.keys(this._original); |
| this._data = keys; |
| } |
| return keys; |
| }, |
| _upgrade$0: function() { |
| var result, keys, i, t1, key; |
| if (this._processed == null) |
| return this._data; |
| result = P.LinkedHashMap__makeEmpty(); |
| keys = this._computeKeys$0(); |
| for (i = 0; t1 = keys.length, i < t1; ++i) { |
| key = keys[i]; |
| result.$indexSet(0, key, this.$index(0, key)); |
| } |
| if (t1 === 0) |
| keys.push(null); |
| else |
| C.JSArray_methods.set$length(keys, 0); |
| this._processed = null; |
| this._original = null; |
| this._data = result; |
| return result; |
| }, |
| _process$1: function(key) { |
| var result; |
| if (!Object.prototype.hasOwnProperty.call(this._original, key)) |
| return; |
| result = P._convertJsonToDartLazy(this._original[key]); |
| return this._processed[key] = result; |
| } |
| }, |
| _JsonMap_values_closure: { |
| "^": "Closure:0;_convert$_captured_this_0", |
| call$1: function(each) { |
| return this._convert$_captured_this_0.$index(0, each); |
| } |
| }, |
| Codec: { |
| "^": "Object;" |
| }, |
| Converter: { |
| "^": "Object;" |
| }, |
| Encoding: { |
| "^": "Codec;", |
| $asCodec: function() { |
| return [P.String, [P.List, P.$int]]; |
| } |
| }, |
| HtmlEscapeMode: { |
| "^": "Object;_convert$_name,escapeLtGt,escapeQuot,escapeApos,escapeSlash", |
| toString$0: function(_) { |
| return this._convert$_name; |
| } |
| }, |
| HtmlEscape: { |
| "^": "Converter;mode", |
| _convert$3: function(text, start, end) { |
| var t1, t2, t3, t4, t5, i, result, replacement, t6; |
| if (typeof end !== "number") |
| return H.iae(end); |
| t1 = J.getInterceptor$asx(text); |
| t2 = this.mode; |
| t3 = t2.escapeSlash; |
| t4 = t2.escapeLtGt; |
| t5 = t2.escapeApos; |
| t2 = t2.escapeQuot; |
| i = start; |
| result = null; |
| for (; i < end; ++i) { |
| switch (t1.$index(text, i)) { |
| case "&": |
| replacement = "&"; |
| break; |
| case "\"": |
| replacement = t2 ? """ : null; |
| break; |
| case "'": |
| replacement = t5 ? "'" : null; |
| break; |
| case "<": |
| replacement = t4 ? "<" : null; |
| break; |
| case ">": |
| replacement = t4 ? ">" : null; |
| break; |
| case "/": |
| replacement = t3 ? "/" : null; |
| break; |
| default: |
| replacement = null; |
| } |
| if (replacement != null) { |
| if (result == null) |
| result = new P.StringBuffer(""); |
| if (i > start) { |
| t6 = t1.substring$2(text, start, i); |
| result._contents = result._contents + t6; |
| } |
| result._contents = result._contents + replacement; |
| start = i + 1; |
| } |
| } |
| if (result == null) |
| return; |
| if (end > start) |
| result._contents += t1.substring$2(text, start, end); |
| t1 = result._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| $asConverter: function() { |
| return [P.String, P.String]; |
| } |
| }, |
| JsonCodec: { |
| "^": "Codec;_reviver,_toEncodable", |
| decode$2$reviver: function(source, reviver) { |
| return P._parseJson(source, this.get$decoder()._reviver); |
| }, |
| decode$1: function(source) { |
| return this.decode$2$reviver(source, null); |
| }, |
| get$decoder: function() { |
| return C.JsonDecoder_null; |
| }, |
| $asCodec: function() { |
| return [P.Object, P.String]; |
| } |
| }, |
| JsonDecoder: { |
| "^": "Converter;_reviver", |
| $asConverter: function() { |
| return [P.String, P.Object]; |
| } |
| }, |
| Utf8Codec: { |
| "^": "Encoding;_allowMalformed", |
| get$name: function(_) { |
| return "utf-8"; |
| }, |
| get$encoder: function() { |
| return C.C_Utf8Encoder; |
| } |
| }, |
| Utf8Encoder: { |
| "^": "Converter;", |
| convert$3: function(string, start, end) { |
| var stringLength, $length, t1, encoder; |
| stringLength = string.get$length(string); |
| P.RangeError_checkValidRange(start, end, stringLength, null, null, null); |
| $length = stringLength.$sub(0, start); |
| t1 = $length.$mul(0, 3); |
| t1 = new Uint8Array(t1); |
| encoder = new P._Utf8Encoder(0, 0, t1); |
| encoder._fillBuffer$3(string, start, stringLength); |
| encoder._writeSurrogate$2(string.codeUnitAt$1(0, stringLength.$sub(0, 1)), 0); |
| return new Uint8Array(t1.subarray(0, H._checkValidRange(0, encoder._bufferIndex, t1.length))); |
| }, |
| convert$1: function(string) { |
| return this.convert$3(string, 0, null); |
| }, |
| $asConverter: function() { |
| return [P.String, [P.List, P.$int]]; |
| } |
| }, |
| _Utf8Encoder: { |
| "^": "Object;_carry,_bufferIndex,_buffer", |
| _writeSurrogate$2: function(leadingSurrogate, nextCodeUnit) { |
| var t1, t2, t3, t4; |
| if ((nextCodeUnit & 64512) === 56320) |
| P._combineSurrogatePair(leadingSurrogate, nextCodeUnit); |
| else { |
| t1 = this._buffer; |
| t2 = this._bufferIndex++; |
| t3 = C.JSInt_methods.$or(224, leadingSurrogate.$shr(0, 12)); |
| t4 = t1.length; |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = t3; |
| t3 = this._bufferIndex++; |
| t2 = C.JSInt_methods.$or(128, leadingSurrogate.$shr(0, 6).$and(0, 63)); |
| if (t3 >= t4) |
| return H.ioore(t1, t3); |
| t1[t3] = t2; |
| t2 = this._bufferIndex++; |
| t3 = C.JSInt_methods.$or(128, leadingSurrogate.$and(0, 63)); |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = t3; |
| return false; |
| } |
| }, |
| _fillBuffer$3: function(str, start, end) { |
| var t1, t2, stringIndex, codeUnit, t3, stringIndex0, t4; |
| if (P._isLeadSurrogate(str.codeUnitAt$1(0, end.$sub(0, 1)))) |
| end = end.$sub(0, 1); |
| for (t1 = this._buffer, t2 = t1.length, stringIndex = start; C.JSInt_methods.$lt(stringIndex, end); ++stringIndex) { |
| codeUnit = str.codeUnitAt$1(0, stringIndex); |
| if (codeUnit.$le(0, 127)) { |
| t3 = this._bufferIndex; |
| if (t3 >= t2) |
| break; |
| this._bufferIndex = t3 + 1; |
| t1[t3] = codeUnit; |
| } else if (P._isLeadSurrogate(codeUnit)) { |
| if (this._bufferIndex + 3 >= t2) |
| break; |
| stringIndex0 = stringIndex + 1; |
| if (this._writeSurrogate$2(codeUnit, str.codeUnitAt$1(0, stringIndex0))) |
| stringIndex = stringIndex0; |
| } else if (codeUnit.$le(0, 2047)) { |
| t3 = this._bufferIndex; |
| t4 = t3 + 1; |
| if (t4 >= t2) |
| break; |
| this._bufferIndex = t4; |
| t4 = C.JSInt_methods.$or(192, codeUnit.$shr(0, 6)); |
| if (t3 >= t2) |
| return H.ioore(t1, t3); |
| t1[t3] = t4; |
| t4 = this._bufferIndex++; |
| t3 = C.JSInt_methods.$or(128, codeUnit.$and(0, 63)); |
| if (t4 >= t2) |
| return H.ioore(t1, t4); |
| t1[t4] = t3; |
| } else { |
| t3 = this._bufferIndex; |
| if (t3 + 2 >= t2) |
| break; |
| this._bufferIndex = t3 + 1; |
| t4 = C.JSInt_methods.$or(224, codeUnit.$shr(0, 12)); |
| if (t3 >= t2) |
| return H.ioore(t1, t3); |
| t1[t3] = t4; |
| t4 = this._bufferIndex++; |
| t3 = C.JSInt_methods.$or(128, codeUnit.$shr(0, 6).$and(0, 63)); |
| if (t4 >= t2) |
| return H.ioore(t1, t4); |
| t1[t4] = t3; |
| t3 = this._bufferIndex++; |
| t4 = C.JSInt_methods.$or(128, codeUnit.$and(0, 63)); |
| if (t3 >= t2) |
| return H.ioore(t1, t3); |
| t1[t3] = t4; |
| } |
| } |
| return stringIndex; |
| } |
| }, |
| Utf8Decoder: { |
| "^": "Converter;_allowMalformed", |
| convert$3: function(codeUnits, start, end) { |
| var $length, buffer, t1, decoder; |
| $length = J.get$length$asx(codeUnits); |
| P.RangeError_checkValidRange(start, end, $length, null, null, null); |
| buffer = new P.StringBuffer(""); |
| t1 = this._allowMalformed; |
| decoder = new P._Utf8Decoder(t1, buffer, true, 0, 0, 0); |
| decoder.convert$3(codeUnits, start, $length); |
| if (decoder._expectedUnits > 0) { |
| if (!t1) |
| H.throwExpression(new P.FormatException("Unfinished UTF-8 octet sequence", null, null)); |
| buffer._contents += H.Primitives_stringFromCharCode(65533); |
| decoder._convert$_value = 0; |
| decoder._expectedUnits = 0; |
| decoder._extraUnits = 0; |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| convert$1: function(codeUnits) { |
| return this.convert$3(codeUnits, 0, null); |
| }, |
| $asConverter: function() { |
| return [[P.List, P.$int], P.String]; |
| } |
| }, |
| _Utf8Decoder: { |
| "^": "Object;_allowMalformed,_stringSink,_isFirstCharacter,_convert$_value,_expectedUnits,_extraUnits", |
| convert$3: function(codeUnits, startIndex, endIndex) { |
| var value, expectedUnits, extraUnits, t1, t2, t3, t4, t5, i, unit, t6, oneBytes, i0; |
| value = this._convert$_value; |
| expectedUnits = this._expectedUnits; |
| extraUnits = this._extraUnits; |
| this._convert$_value = 0; |
| this._expectedUnits = 0; |
| this._extraUnits = 0; |
| t1 = new P._Utf8Decoder_convert_scanOneByteCharacters(endIndex); |
| t2 = new P._Utf8Decoder_convert_addSingleBytes(this, codeUnits, startIndex, endIndex); |
| $loop$0: |
| for (t3 = this._stringSink, t4 = !this._allowMalformed, t5 = J.getInterceptor$asx(codeUnits), i = startIndex; true; i = i0) { |
| $multibyte$2: |
| if (expectedUnits > 0) { |
| do { |
| if (i === endIndex) |
| break $loop$0; |
| unit = t5.$index(codeUnits, i); |
| if (typeof unit !== "number") |
| return unit.$and(); |
| if ((unit & 192) !== 128) { |
| if (t4) |
| throw H.wrapException(new P.FormatException("Bad UTF-8 encoding 0x" + C.JSNumber_methods.toRadixString$1(unit, 16), null, null)); |
| this._isFirstCharacter = false; |
| t3._contents += H.Primitives_stringFromCharCode(65533); |
| expectedUnits = 0; |
| break $multibyte$2; |
| } else { |
| value = (value << 6 | unit & 63) >>> 0; |
| --expectedUnits; |
| ++i; |
| } |
| } while (expectedUnits > 0); |
| t6 = extraUnits - 1; |
| if (t6 < 0 || t6 >= 4) |
| return H.ioore(C.List_127_2047_65535_1114111, t6); |
| if (value <= C.List_127_2047_65535_1114111[t6]) { |
| if (t4) |
| throw H.wrapException(new P.FormatException("Overlong encoding of 0x" + C.JSInt_methods.toRadixString$1(value, 16), null, null)); |
| value = 65533; |
| expectedUnits = 0; |
| extraUnits = 0; |
| } |
| if (value > 1114111) { |
| if (t4) |
| throw H.wrapException(new P.FormatException("Character outside valid Unicode range: 0x" + C.JSInt_methods.toRadixString$1(value, 16), null, null)); |
| value = 65533; |
| } |
| if (!this._isFirstCharacter || value !== 65279) |
| t3._contents += H.Primitives_stringFromCharCode(value); |
| this._isFirstCharacter = false; |
| } |
| for (; i < endIndex; i = i0) { |
| oneBytes = t1.call$2(codeUnits, i); |
| if (J.$gt$n(oneBytes, 0)) { |
| this._isFirstCharacter = false; |
| if (typeof oneBytes !== "number") |
| return H.iae(oneBytes); |
| i0 = i + oneBytes; |
| t2.call$2(i, i0); |
| if (i0 === endIndex) |
| break; |
| i = i0; |
| } |
| i0 = i + 1; |
| unit = t5.$index(codeUnits, i); |
| t6 = J.getInterceptor$n(unit); |
| if (t6.$lt(unit, 0)) { |
| if (t4) |
| throw H.wrapException(new P.FormatException("Negative UTF-8 code unit: -0x" + J.toRadixString$1$n(t6.$negate(unit), 16), null, null)); |
| t3._contents += H.Primitives_stringFromCharCode(65533); |
| } else { |
| if (typeof unit !== "number") |
| return unit.$and(); |
| if ((unit & 224) === 192) { |
| value = unit & 31; |
| expectedUnits = 1; |
| extraUnits = 1; |
| continue $loop$0; |
| } |
| if ((unit & 240) === 224) { |
| value = unit & 15; |
| expectedUnits = 2; |
| extraUnits = 2; |
| continue $loop$0; |
| } |
| if ((unit & 248) === 240 && unit < 245) { |
| value = unit & 7; |
| expectedUnits = 3; |
| extraUnits = 3; |
| continue $loop$0; |
| } |
| if (t4) |
| throw H.wrapException(new P.FormatException("Bad UTF-8 encoding 0x" + C.JSNumber_methods.toRadixString$1(unit, 16), null, null)); |
| this._isFirstCharacter = false; |
| t3._contents += H.Primitives_stringFromCharCode(65533); |
| value = 65533; |
| expectedUnits = 0; |
| extraUnits = 0; |
| } |
| } |
| break $loop$0; |
| } |
| if (expectedUnits > 0) { |
| this._convert$_value = value; |
| this._expectedUnits = expectedUnits; |
| this._extraUnits = extraUnits; |
| } |
| } |
| }, |
| _Utf8Decoder_convert_scanOneByteCharacters: { |
| "^": "Closure:19;_captured_endIndex_0", |
| call$2: function(units, from) { |
| var to, t1, i, unit; |
| to = this._captured_endIndex_0; |
| for (t1 = J.getInterceptor$asx(units), i = from; i < to; ++i) { |
| unit = t1.$index(units, i); |
| if (typeof unit !== "number") |
| return unit.$and(); |
| if ((unit & 127) !== unit) |
| return i - from; |
| } |
| return to - from; |
| } |
| }, |
| _Utf8Decoder_convert_addSingleBytes: { |
| "^": "Closure:20;_captured_this_1,_captured_codeUnits_2,_captured_startIndex_3,_captured_endIndex_4", |
| call$2: function(from, to) { |
| this._captured_this_1._stringSink._contents += P.String_String$fromCharCodes(this._captured_codeUnits_2, from, to); |
| } |
| } |
| }], ["dart.core", "dart:core",, P, { |
| "^": "", |
| _symbolToString: function(symbol) { |
| return H.Symbol_getName(symbol); |
| }, |
| String__stringFromIterable: function(charCodes, start, end) { |
| var t1, it, i, list; |
| if (start < 0) |
| throw H.wrapException(P.RangeError$range(start, 0, J.get$length$asx(charCodes), null, null)); |
| t1 = end == null; |
| if (!t1 && end < start) |
| throw H.wrapException(P.RangeError$range(end, start, J.get$length$asx(charCodes), null, null)); |
| it = J.get$iterator$ax(charCodes); |
| for (i = 0; i < start; ++i) |
| if (!it.moveNext$0()) |
| throw H.wrapException(P.RangeError$range(start, 0, i, null, null)); |
| list = []; |
| if (t1) |
| for (; it.moveNext$0();) |
| list.push(it.get$current()); |
| else |
| for (i = start; i < end; ++i) { |
| if (!it.moveNext$0()) |
| throw H.wrapException(P.RangeError$range(end, start, i, null, null)); |
| list.push(it.get$current()); |
| } |
| return H.Primitives_stringFromCharCodes(list); |
| }, |
| 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_objectToHumanReadableString(object); |
| }, |
| Exception_Exception: function(message) { |
| return new P._Exception(message); |
| }, |
| List_List$filled: function($length, fill, $E) { |
| var result, t1, i; |
| result = J.JSArray_JSArray$fixed($length, $E); |
| if ($length !== 0 && true) |
| for (t1 = result.length, i = 0; i < t1; ++i) |
| result[i] = fill; |
| return result; |
| }, |
| List_List$from: function(elements, growable, $E) { |
| var list, t1; |
| list = H.setRuntimeTypeInfo([], [$E]); |
| for (t1 = J.get$iterator$ax(elements); t1.moveNext$0();) |
| list.push(t1.get$current()); |
| if (growable) |
| return list; |
| list.fixed$length = Array; |
| return list; |
| }, |
| List_List$generate: function($length, generator, growable, $E) { |
| var result, t1, i; |
| if (growable) { |
| result = H.setRuntimeTypeInfo([], [$E]); |
| C.JSArray_methods.set$length(result, $length); |
| } else { |
| t1 = new Array($length); |
| t1.fixed$length = Array; |
| result = H.setRuntimeTypeInfo(t1, [$E]); |
| } |
| for (i = 0; i < $length; ++i) { |
| t1 = generator.call$1(i); |
| if (i >= result.length) |
| return H.ioore(result, i); |
| result[i] = t1; |
| } |
| return result; |
| }, |
| print: function(object) { |
| var line = H.S(object); |
| H.printString(line); |
| }, |
| RegExp_RegExp: function(source, caseSensitive, multiLine) { |
| return new H.JSSyntaxRegExp(source, H.JSSyntaxRegExp_makeNative(source, multiLine, caseSensitive, false), null, null); |
| }, |
| String_String$fromCharCodes: function(charCodes, start, end) { |
| var len; |
| if (charCodes.constructor === Array) { |
| len = charCodes.length; |
| end = P.RangeError_checkValidRange(start, end, len, null, null, null); |
| return H.Primitives_stringFromCharCodes(start > 0 || end < len ? C.JSArray_methods.sublist$2(charCodes, start, end) : charCodes); |
| } |
| return P.String__stringFromIterable(charCodes, start, end); |
| }, |
| NoSuchMethodError_toString_closure: { |
| "^": "Closure:21;_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, |
| DateTime: { |
| "^": "Object;" |
| }, |
| $double: { |
| "^": "num;" |
| }, |
| "+double": 0, |
| Duration: { |
| "^": "Object;_duration<", |
| $add: function(_, other) { |
| return new P.Duration(this._duration + other.get$_duration()); |
| }, |
| $sub: function(_, other) { |
| return new P.Duration(this._duration - other.get$_duration()); |
| }, |
| $lt: function(_, other) { |
| return this._duration < other.get$_duration(); |
| }, |
| $gt: function(_, other) { |
| return 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); |
| }, |
| abs$0: function(_) { |
| return new P.Duration(Math.abs(this._duration)); |
| }, |
| $negate: function(_) { |
| return new P.Duration(-this._duration); |
| } |
| }, |
| Duration_toString_sixDigits: { |
| "^": "Closure:8;", |
| 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:8;", |
| 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); |
| }, ArgumentError$value: function(value, $name, message) { |
| return new P.ArgumentError(true, value, $name, 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$: function(message) { |
| return new P.RangeError(null, null, false, null, null, message); |
| }, 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_checkValueInInterval: function(value, minValue, maxValue, $name, message) { |
| if (value < minValue || value > maxValue) |
| throw H.wrapException(P.RangeError$range(value, minValue, maxValue, $name, message)); |
| }, 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 (end != null) { |
| if (start > end || end > $length) |
| throw H.wrapException(P.RangeError$range(end, start, $length, "end", message)); |
| return end; |
| } |
| return $length; |
| }} |
| }, |
| IndexError: { |
| "^": "ArgumentError;indexable,length>,_hasValue,invalidValue,name,message", |
| get$_errorName: function() { |
| return "RangeError"; |
| }, |
| get$_errorExplanation: function() { |
| if (J.$lt$n(this.invalidValue, 0)) |
| return ": index must not be negative"; |
| var t1 = this.length; |
| if (J.$eq$(t1, 0)) |
| return ": no indices are valid"; |
| return ": index should be less than " + H.S(t1); |
| }, |
| static: {IndexError$: function(invalidValue, indexable, $name, message, $length) { |
| var t1 = $length != null ? $length : J.get$length$asx(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; |
| } |
| }, |
| UnimplementedError: { |
| "^": "Error;message>", |
| toString$0: function(_) { |
| var t1 = this.message; |
| return t1 != null ? "UnimplementedError: " + H.S(t1) : "UnimplementedError"; |
| } |
| }, |
| 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)) + "."; |
| } |
| }, |
| OutOfMemoryError: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "Out of Memory"; |
| }, |
| get$stackTrace: function() { |
| return; |
| }, |
| $isError: 1 |
| }, |
| 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"; |
| } |
| }, |
| _Exception: { |
| "^": "Object;message>", |
| toString$0: function(_) { |
| var t1 = this.message; |
| if (t1 == null) |
| return "Exception"; |
| return "Exception: " + H.S(t1); |
| } |
| }, |
| FormatException: { |
| "^": "Object;message>,source,offset", |
| toString$0: function(_) { |
| var t1, report, offset, source, lineNum, lineStart, lastWasCR, i, $char, lineEnd, end, start, prefix, postfix, slice; |
| t1 = this.message; |
| report = t1 != null && "" !== t1 ? "FormatException: " + H.S(t1) : "FormatException"; |
| offset = this.offset; |
| source = this.source; |
| if (typeof source !== "string") |
| return offset != null ? report + (" (at offset " + H.S(offset) + ")") : report; |
| if (offset != null) |
| t1 = offset < 0 || offset > source.length; |
| else |
| t1 = false; |
| if (t1) |
| offset = null; |
| if (offset == null) { |
| if (source.length > 78) |
| source = J.substring$2$s(source, 0, 75) + "..."; |
| return report + "\n" + H.S(source); |
| } |
| for (t1 = J.getInterceptor$s(source), lineNum = 1, lineStart = 0, lastWasCR = null, i = 0; i < offset; ++i) { |
| $char = t1.codeUnitAt$1(source, i); |
| if ($char === 10) { |
| if (lineStart !== i || lastWasCR !== true) |
| ++lineNum; |
| lineStart = i + 1; |
| lastWasCR = false; |
| } else if ($char === 13) { |
| ++lineNum; |
| lineStart = i + 1; |
| lastWasCR = true; |
| } |
| } |
| report = lineNum > 1 ? report + (" (at line " + lineNum + ", character " + (offset - lineStart + 1) + ")\n") : report + (" (at character " + (offset + 1) + ")\n"); |
| lineEnd = source.length; |
| for (i = offset; i < lineEnd; ++i) { |
| $char = t1.codeUnitAt$1(source, i); |
| if ($char === 10 || $char === 13) { |
| lineEnd = i; |
| break; |
| } |
| } |
| if (lineEnd - lineStart > 78) |
| if (offset - lineStart < 75) { |
| end = lineStart + 75; |
| start = lineStart; |
| prefix = ""; |
| postfix = "..."; |
| } else { |
| if (lineEnd - offset < 75) { |
| start = lineEnd - 75; |
| end = lineEnd; |
| postfix = ""; |
| } else { |
| start = offset - 36; |
| end = offset + 36; |
| postfix = "..."; |
| } |
| prefix = "..."; |
| } |
| else { |
| end = lineEnd; |
| start = lineStart; |
| prefix = ""; |
| postfix = ""; |
| } |
| slice = t1.substring$2(source, start, end); |
| return report + prefix + slice + postfix + "\n" + C.JSString_methods.$mul(" ", offset - start + prefix.length) + "^\n"; |
| } |
| }, |
| 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; |
| } |
| }, |
| Function: { |
| "^": "Object;" |
| }, |
| $int: { |
| "^": "num;" |
| }, |
| "+int": 0, |
| Iterable: { |
| "^": "Object;", |
| map$1: function(_, f) { |
| return H.MappedIterable_MappedIterable(this, f, H.getRuntimeTypeArgument(this, "Iterable", 0), null); |
| }, |
| where$1: ["super$Iterable$where", function(_, f) { |
| return H.setRuntimeTypeInfo(new H.WhereIterable(this, f), [H.getRuntimeTypeArgument(this, "Iterable", 0)]); |
| }], |
| contains$1: function(_, element) { |
| var t1; |
| for (t1 = this.get$iterator(this); t1.moveNext$0();) |
| if (J.$eq$(t1.get$current(), element)) |
| return true; |
| return false; |
| }, |
| 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; |
| }, |
| get$isEmpty: function(_) { |
| return !this.get$iterator(this).moveNext$0(); |
| }, |
| get$isNotEmpty: function(_) { |
| return this.get$isEmpty(this) !== true; |
| }, |
| get$last: function(_) { |
| var it, result; |
| it = this.get$iterator(this); |
| if (!it.moveNext$0()) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| do |
| result = it.get$current(); |
| while (it.moveNext$0()); |
| return result; |
| }, |
| get$single: function(_) { |
| var it, result; |
| it = this.get$iterator(this); |
| if (!it.moveNext$0()) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| result = it.get$current(); |
| if (it.moveNext$0()) |
| throw H.wrapException(H.IterableElementError_tooMany()); |
| return result; |
| }, |
| 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;", |
| $asList: null, |
| $isEfficientLength: 1 |
| }, |
| "+List": 0, |
| Map: { |
| "^": "Object;" |
| }, |
| 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_objectToHumanReadableString(this); |
| } |
| }, |
| Match: { |
| "^": "Object;" |
| }, |
| StackTrace: { |
| "^": "Object;" |
| }, |
| String: { |
| "^": "Object;", |
| $isPattern: 1 |
| }, |
| "+String": 0, |
| StringBuffer: { |
| "^": "Object;_contents<", |
| get$length: function(_) { |
| return this._contents.length; |
| }, |
| get$isEmpty: function(_) { |
| return this._contents.length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._contents.length !== 0; |
| }, |
| 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$ax(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;" |
| }, |
| Uri: { |
| "^": "Object;_host,_port,_path,scheme<,_userInfo,_query,_fragment,_pathSegments,_queryParameters", |
| get$host: function(_) { |
| var t1 = this._host; |
| if (t1 == null) |
| return ""; |
| if (J.getInterceptor$s(t1).startsWith$1(t1, "[")) |
| return C.JSString_methods.substring$2(t1, 1, t1.length - 1); |
| return t1; |
| }, |
| get$port: function(_) { |
| var t1 = this._port; |
| if (t1 == null) |
| return P.Uri__defaultPort(this.scheme); |
| return t1; |
| }, |
| get$pathSegments: function() { |
| var t1, pathToSplit; |
| t1 = this._pathSegments; |
| if (t1 == null) { |
| pathToSplit = this._path; |
| if (pathToSplit.length !== 0 && C.JSString_methods.codeUnitAt$1(pathToSplit, 0) === 47) |
| pathToSplit = C.JSString_methods.substring$1(pathToSplit, 1); |
| t1 = H.setRuntimeTypeInfo(new P.UnmodifiableListView(pathToSplit === "" ? C.List_empty0 : H.setRuntimeTypeInfo(new H.MappedListIterable(pathToSplit.split("/"), P.core_Uri_decodeComponent$closure()), [null, null]).toList$1$growable(0, false)), [null]); |
| this._pathSegments = t1; |
| } |
| return t1; |
| }, |
| _mergePaths$2: function(base, reference) { |
| var backCount, refStart, baseEnd, newEnd, delta, t1; |
| for (backCount = 0, refStart = 0; C.JSString_methods.startsWith$2(reference, "../", refStart);) { |
| refStart += 3; |
| ++backCount; |
| } |
| baseEnd = C.JSString_methods.lastIndexOf$1(base, "/"); |
| while (true) { |
| if (!(baseEnd > 0 && backCount > 0)) |
| break; |
| newEnd = C.JSString_methods.lastIndexOf$2(base, "/", baseEnd - 1); |
| if (newEnd < 0) |
| break; |
| delta = baseEnd - newEnd; |
| t1 = delta !== 2; |
| if (!t1 || delta === 3) |
| if (C.JSString_methods.codeUnitAt$1(base, newEnd + 1) === 46) |
| t1 = !t1 || C.JSString_methods.codeUnitAt$1(base, newEnd + 2) === 46; |
| else |
| t1 = false; |
| else |
| t1 = false; |
| if (t1) |
| break; |
| --backCount; |
| baseEnd = newEnd; |
| } |
| return C.JSString_methods.replaceRange$3(base, baseEnd + 1, null, C.JSString_methods.substring$1(reference, refStart - 3 * backCount)); |
| }, |
| toFilePath$1$windows: function(windows) { |
| var t1 = this.scheme; |
| if (t1 !== "" && t1 !== "file") |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a " + t1 + " URI")); |
| t1 = this._query; |
| if ((t1 == null ? "" : t1) !== "") |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a URI with a query component")); |
| t1 = this._fragment; |
| if ((t1 == null ? "" : t1) !== "") |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a URI with a fragment component")); |
| if (this.get$host(this) !== "") |
| H.throwExpression(new P.UnsupportedError("Cannot extract a non-Windows file path from a file URI with an authority")); |
| P.Uri__checkNonWindowsPathReservedCharacters(this.get$pathSegments(), false); |
| t1 = this.get$_isPathAbsolute() ? "/" : ""; |
| t1 = P.StringBuffer__writeAll(t1, this.get$pathSegments(), "/"); |
| t1 = t1.charCodeAt(0) == 0 ? t1 : t1; |
| return t1; |
| }, |
| toFilePath$0: function() { |
| return this.toFilePath$1$windows(null); |
| }, |
| get$_isPathAbsolute: function() { |
| if (this._path.length === 0) |
| return false; |
| return C.JSString_methods.startsWith$1(this._path, "/"); |
| }, |
| toString$0: function(_) { |
| var t1, t2, t3, t4; |
| t1 = this.scheme; |
| t2 = "" !== t1 ? t1 + ":" : ""; |
| t3 = this._host; |
| t4 = t3 == null; |
| if (!t4 || C.JSString_methods.startsWith$1(this._path, "//") || t1 === "file") { |
| t1 = t2 + "//"; |
| t2 = this._userInfo; |
| if (t2.length !== 0) |
| t1 = t1 + t2 + "@"; |
| if (!t4) |
| t1 += H.S(t3); |
| t2 = this._port; |
| if (t2 != null) |
| t1 = t1 + ":" + H.S(t2); |
| } else |
| t1 = t2; |
| t1 += this._path; |
| t2 = this._query; |
| if (t2 != null) |
| t1 = t1 + "?" + H.S(t2); |
| t2 = this._fragment; |
| if (t2 != null) |
| t1 = t1 + "#" + H.S(t2); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| $eq: function(_, other) { |
| var t1, t2, t3, t4; |
| if (other == null) |
| return false; |
| t1 = J.getInterceptor(other); |
| if (!t1.$isUri) |
| return false; |
| if (this.scheme === other.scheme) |
| if (this._host != null === (other._host != null)) |
| if (this._userInfo === other._userInfo) { |
| t2 = this.get$host(this); |
| t3 = t1.get$host(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = this.get$port(this); |
| t1 = t1.get$port(other); |
| if (t2 == null ? t1 == null : t2 === t1) |
| if (this._path === other._path) { |
| t1 = this._query; |
| t2 = t1 == null; |
| t3 = other._query; |
| t4 = t3 == null; |
| if (!t2 === !t4) { |
| if (t2) |
| t1 = ""; |
| if (t1 == null ? (t4 ? "" : t3) == null : t1 === (t4 ? "" : t3)) { |
| t1 = this._fragment; |
| t2 = t1 == null; |
| t3 = other._fragment; |
| t4 = t3 == null; |
| if (!t2 === !t4) { |
| if (t2) |
| t1 = ""; |
| t1 = t1 == null ? (t4 ? "" : t3) == null : t1 === (t4 ? "" : t3); |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| else |
| t1 = false; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| else |
| t1 = false; |
| else |
| t1 = false; |
| return t1; |
| }, |
| get$hashCode: function(_) { |
| var t1, t2, t3, t4, t5; |
| t1 = new P.Uri_hashCode_combine(); |
| t2 = this.get$host(this); |
| t3 = this.get$port(this); |
| t4 = this._query; |
| if (t4 == null) |
| t4 = ""; |
| t5 = this._fragment; |
| return t1.call$2(this.scheme, t1.call$2(this._userInfo, t1.call$2(t2, t1.call$2(t3, t1.call$2(this._path, t1.call$2(t4, t1.call$2(t5 == null ? "" : t5, 1))))))); |
| }, |
| static: {Uri__defaultPort: function(scheme) { |
| if (scheme === "http") |
| return 80; |
| if (scheme === "https") |
| return 443; |
| return 0; |
| }, Uri_parse: function(uri, start, end) { |
| var t1, pathStart, state, i, t2, $char, index, path, numberSignIndex, query, fragment, t3; |
| t1 = {}; |
| t1._captured_end_0 = end; |
| t1._captured_scheme_1 = ""; |
| t1._captured_userinfo_2 = ""; |
| t1._captured_host_3 = null; |
| t1._captured_port_4 = null; |
| t1._captured_end_0 = uri.length; |
| t1._captured_index_5 = start; |
| t1._captured_char_6 = -1; |
| i = start; |
| while (true) { |
| t2 = t1._captured_end_0; |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) { |
| pathStart = start; |
| state = 0; |
| break; |
| } |
| $char = C.JSString_methods.codeUnitAt$1(uri, i); |
| t1._captured_char_6 = $char; |
| if ($char === 63 || $char === 35) { |
| pathStart = start; |
| state = 0; |
| break; |
| } |
| if ($char === 47) { |
| state = i === start ? 2 : 1; |
| pathStart = start; |
| break; |
| } |
| if ($char === 58) { |
| if (i === start) |
| P.Uri__fail(uri, start, "Invalid empty scheme"); |
| t1._captured_scheme_1 = P.Uri__makeScheme(uri, start, i); |
| ++i; |
| if (i === t1._captured_end_0) { |
| t1._captured_char_6 = -1; |
| state = 0; |
| } else { |
| $char = C.JSString_methods.codeUnitAt$1(uri, i); |
| t1._captured_char_6 = $char; |
| if ($char === 63 || $char === 35) |
| state = 0; |
| else |
| state = $char === 47 ? 2 : 1; |
| } |
| pathStart = i; |
| break; |
| } |
| ++i; |
| t1._captured_char_6 = -1; |
| } |
| t1._captured_index_5 = i; |
| if (state === 2) { |
| index = i + 1; |
| t1._captured_index_5 = index; |
| if (index === t1._captured_end_0) { |
| t1._captured_char_6 = -1; |
| state = 0; |
| } else { |
| $char = C.JSString_methods.codeUnitAt$1(uri, index); |
| t1._captured_char_6 = $char; |
| if ($char === 47) { |
| t2 = t1._captured_index_5; |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| t1._captured_index_5 = t2 + 1; |
| new P.Uri_parse_parseAuth(t1, uri, -1).call$0(); |
| pathStart = t1._captured_index_5; |
| } |
| t2 = t1._captured_char_6; |
| state = t2 === 63 || t2 === 35 || t2 === -1 ? 0 : 1; |
| } |
| } |
| if (state === 1) |
| while (true) { |
| t2 = t1._captured_index_5; |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| index = t2 + 1; |
| t1._captured_index_5 = index; |
| t2 = t1._captured_end_0; |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(index < t2)) |
| break; |
| $char = C.JSString_methods.codeUnitAt$1(uri, index); |
| t1._captured_char_6 = $char; |
| if ($char === 63 || $char === 35) |
| break; |
| t1._captured_char_6 = -1; |
| } |
| t2 = t1._captured_host_3; |
| path = P.Uri__makePath(uri, pathStart, t1._captured_index_5, null, t1._captured_scheme_1, t2 != null); |
| t2 = t1._captured_char_6; |
| if (t2 === 63) { |
| t2 = t1._captured_index_5; |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| i = t2 + 1; |
| while (true) { |
| t2 = t1._captured_end_0; |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) { |
| numberSignIndex = -1; |
| break; |
| } |
| if (C.JSString_methods.codeUnitAt$1(uri, i) === 35) { |
| numberSignIndex = i; |
| break; |
| } |
| ++i; |
| } |
| t2 = t1._captured_index_5; |
| if (numberSignIndex < 0) { |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| query = P.Uri__makeQuery(uri, t2 + 1, t1._captured_end_0, null); |
| fragment = null; |
| } else { |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| query = P.Uri__makeQuery(uri, t2 + 1, numberSignIndex, null); |
| fragment = P.Uri__makeFragment(uri, numberSignIndex + 1, t1._captured_end_0); |
| } |
| } else { |
| if (t2 === 35) { |
| t2 = t1._captured_index_5; |
| if (typeof t2 !== "number") |
| return t2.$add(); |
| fragment = P.Uri__makeFragment(uri, t2 + 1, t1._captured_end_0); |
| } else |
| fragment = null; |
| query = null; |
| } |
| t2 = t1._captured_scheme_1; |
| t3 = t1._captured_userinfo_2; |
| return new P.Uri(t1._captured_host_3, t1._captured_port_4, path, t2, t3, query, fragment, null, null); |
| }, Uri__fail: function(uri, index, message) { |
| throw H.wrapException(new P.FormatException(message, uri, index)); |
| }, Uri_base: function() { |
| var uri = H.Primitives_currentUri(); |
| if (uri != null) |
| return P.Uri_parse(uri, 0, null); |
| throw H.wrapException(new P.UnsupportedError("'Uri.base' is not supported")); |
| }, Uri__checkNonWindowsPathReservedCharacters: function(segments, argumentError) { |
| segments.forEach$1(segments, new P.Uri__checkNonWindowsPathReservedCharacters_closure(argumentError)); |
| }, Uri__makePort: function(port, scheme) { |
| if (port != null && port === P.Uri__defaultPort(scheme)) |
| return; |
| return port; |
| }, Uri__makeHost: function(host, start, end, strictIPv6) { |
| var t1, i; |
| if (host == null) |
| return; |
| if (start == null ? end == null : start === end) |
| return ""; |
| if (C.JSString_methods.codeUnitAt$1(host, start) === 91) { |
| if (typeof end !== "number") |
| return end.$sub(); |
| t1 = end - 1; |
| if (C.JSString_methods.codeUnitAt$1(host, t1) !== 93) |
| P.Uri__fail(host, start, "Missing end `]` to match `[` in host"); |
| if (typeof start !== "number") |
| return start.$add(); |
| P.Uri_parseIPv6Address(host, start + 1, t1); |
| return C.JSString_methods.substring$2(host, start, end).toLowerCase(); |
| } |
| if (!strictIPv6) { |
| i = start; |
| while (true) { |
| if (typeof i !== "number") |
| return i.$lt(); |
| if (typeof end !== "number") |
| return H.iae(end); |
| if (!(i < end)) |
| break; |
| if (C.JSString_methods.codeUnitAt$1(host, i) === 58) { |
| P.Uri_parseIPv6Address(host, start, end); |
| return "[" + host + "]"; |
| } |
| ++i; |
| } |
| } |
| return P.Uri__normalizeRegName(host, start, end); |
| }, Uri__normalizeRegName: function(host, start, end) { |
| var index, sectionStart, buffer, isNormalized, $char, replacement, t1, slice, sourceLength, tail; |
| index = start; |
| sectionStart = index; |
| buffer = null; |
| isNormalized = true; |
| while (true) { |
| if (typeof index !== "number") |
| return index.$lt(); |
| if (typeof end !== "number") |
| return H.iae(end); |
| if (!(index < end)) |
| break; |
| c$0: { |
| $char = C.JSString_methods.codeUnitAt$1(host, index); |
| if ($char === 37) { |
| replacement = P.Uri__normalizeEscape(host, index, true); |
| t1 = replacement == null; |
| if (t1 && isNormalized) { |
| index += 3; |
| break c$0; |
| } |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| slice = C.JSString_methods.substring$2(host, sectionStart, index); |
| if (!isNormalized) |
| slice = slice.toLowerCase(); |
| buffer._contents = buffer._contents + slice; |
| if (t1) { |
| replacement = C.JSString_methods.substring$2(host, index, index + 3); |
| sourceLength = 3; |
| } else if (replacement === "%") { |
| replacement = "%25"; |
| sourceLength = 1; |
| } else |
| sourceLength = 3; |
| buffer._contents += replacement; |
| index += sourceLength; |
| sectionStart = index; |
| isNormalized = true; |
| } else { |
| if ($char < 127) { |
| t1 = $char >>> 4; |
| if (t1 >= 8) |
| return H.ioore(C.List_qNA, t1); |
| t1 = (C.List_qNA[t1] & C.JSInt_methods._shlPositive$1(1, $char & 15)) !== 0; |
| } else |
| t1 = false; |
| if (t1) { |
| if (isNormalized && 65 <= $char && 90 >= $char) { |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| if (typeof sectionStart !== "number") |
| return sectionStart.$lt(); |
| if (sectionStart < index) { |
| t1 = C.JSString_methods.substring$2(host, sectionStart, index); |
| buffer._contents = buffer._contents + t1; |
| sectionStart = index; |
| } |
| isNormalized = false; |
| } |
| ++index; |
| } else { |
| if ($char <= 93) { |
| t1 = $char >>> 4; |
| if (t1 >= 8) |
| return H.ioore(C.List_2Vk, t1); |
| t1 = (C.List_2Vk[t1] & C.JSInt_methods._shlPositive$1(1, $char & 15)) !== 0; |
| } else |
| t1 = false; |
| if (t1) |
| P.Uri__fail(host, index, "Invalid character"); |
| else { |
| if (($char & 64512) === 55296 && index + 1 < end) { |
| tail = C.JSString_methods.codeUnitAt$1(host, index + 1); |
| if ((tail & 64512) === 56320) { |
| $char = (65536 | ($char & 1023) << 10 | tail & 1023) >>> 0; |
| sourceLength = 2; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| slice = C.JSString_methods.substring$2(host, sectionStart, index); |
| if (!isNormalized) |
| slice = slice.toLowerCase(); |
| buffer._contents = buffer._contents + slice; |
| buffer._contents += P.Uri__escapeChar($char); |
| index += sourceLength; |
| sectionStart = index; |
| } |
| } |
| } |
| } |
| } |
| if (buffer == null) |
| return C.JSString_methods.substring$2(host, start, end); |
| if (typeof sectionStart !== "number") |
| return sectionStart.$lt(); |
| if (sectionStart < end) { |
| slice = C.JSString_methods.substring$2(host, sectionStart, end); |
| buffer._contents += !isNormalized ? slice.toLowerCase() : slice; |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, Uri__makeScheme: function(scheme, start, end) { |
| var firstCodeUnit, t1, i, containsUpperCase, codeUnit; |
| if (start === end) |
| return ""; |
| firstCodeUnit = C.JSString_methods.codeUnitAt$1(scheme, start); |
| if (!(firstCodeUnit >= 97 && firstCodeUnit <= 122)) |
| t1 = firstCodeUnit >= 65 && firstCodeUnit <= 90; |
| else |
| t1 = true; |
| if (!t1) |
| P.Uri__fail(scheme, start, "Scheme not starting with alphabetic character"); |
| for (i = start, containsUpperCase = false; i < end; ++i) { |
| codeUnit = C.JSString_methods.codeUnitAt$1(scheme, i); |
| if (codeUnit < 128) { |
| t1 = codeUnit >>> 4; |
| if (t1 >= 8) |
| return H.ioore(C.List_JYB, t1); |
| t1 = (C.List_JYB[t1] & C.JSInt_methods._shlPositive$1(1, codeUnit & 15)) !== 0; |
| } else |
| t1 = false; |
| if (!t1) |
| P.Uri__fail(scheme, i, "Illegal scheme character"); |
| if (65 <= codeUnit && codeUnit <= 90) |
| containsUpperCase = true; |
| } |
| scheme = C.JSString_methods.substring$2(scheme, start, end); |
| return containsUpperCase ? scheme.toLowerCase() : scheme; |
| }, Uri__makeUserInfo: function(userInfo, start, end) { |
| return P.Uri__normalize(userInfo, start, end, C.List_gRj); |
| }, Uri__makePath: function(path, start, end, pathSegments, scheme, hasAuthority) { |
| var isFile, ensureLeadingSlash, result; |
| isFile = scheme === "file"; |
| ensureLeadingSlash = isFile || hasAuthority; |
| result = P.Uri__normalize(path, start, end, C.List_qg4); |
| if (result.length === 0) { |
| if (isFile) |
| return "/"; |
| } else if (ensureLeadingSlash && !C.JSString_methods.startsWith$1(result, "/")) |
| result = "/" + result; |
| return P.Uri__normalizePath(result, scheme, hasAuthority); |
| }, Uri__normalizePath: function(path, scheme, hasAuthority) { |
| if (scheme.length === 0 && !hasAuthority && !C.JSString_methods.startsWith$1(path, "/")) |
| return P.Uri__normalizeRelativePath(path); |
| return P.Uri__removeDotSegments(path); |
| }, Uri__makeQuery: function(query, start, end, queryParameters) { |
| var t1, t2, result; |
| t1 = {}; |
| t2 = query == null; |
| if (t2 && true) |
| return; |
| t2 = !t2; |
| if (t2) |
| ; |
| if (t2) |
| return P.Uri__normalize(query, start, end, C.List_CVk); |
| result = new P.StringBuffer(""); |
| t1._captured_first_0 = true; |
| C.JSNull_methods.forEach$1(queryParameters, new P.Uri__makeQuery_closure(t1, result)); |
| t1 = result._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, Uri__makeFragment: function(fragment, start, end) { |
| if (fragment == null) |
| return; |
| return P.Uri__normalize(fragment, start, end, C.List_CVk); |
| }, Uri__isHexDigit: function($char) { |
| if (57 >= $char) |
| return 48 <= $char; |
| $char |= 32; |
| return 97 <= $char && 102 >= $char; |
| }, Uri__hexValue: function($char) { |
| if (57 >= $char) |
| return $char - 48; |
| return ($char | 32) - 87; |
| }, Uri__normalizeEscape: function(source, index, lowerCase) { |
| var t1, firstDigit, secondDigit, value; |
| t1 = index + 2; |
| if (t1 >= source.length) |
| return "%"; |
| firstDigit = C.JSString_methods.codeUnitAt$1(source, index + 1); |
| secondDigit = C.JSString_methods.codeUnitAt$1(source, t1); |
| if (!P.Uri__isHexDigit(firstDigit) || !P.Uri__isHexDigit(secondDigit)) |
| return "%"; |
| value = P.Uri__hexValue(firstDigit) * 16 + P.Uri__hexValue(secondDigit); |
| if (value < 127) { |
| t1 = C.JSInt_methods._shrOtherPositive$1(value, 4); |
| if (t1 >= 8) |
| return H.ioore(C.List_nxB, t1); |
| t1 = (C.List_nxB[t1] & C.JSInt_methods._shlPositive$1(1, value & 15)) !== 0; |
| } else |
| t1 = false; |
| if (t1) |
| return H.Primitives_stringFromCharCode(lowerCase && 65 <= value && 90 >= value ? (value | 32) >>> 0 : value); |
| if (firstDigit >= 97 || secondDigit >= 97) |
| return C.JSString_methods.substring$2(source, index, index + 3).toUpperCase(); |
| return; |
| }, Uri__escapeChar: function($char) { |
| var codeUnits, flag, encodedBytes, t1, index, $byte, t2, t3; |
| if ($char < 128) { |
| codeUnits = new Array(3); |
| codeUnits.fixed$length = Array; |
| codeUnits[0] = 37; |
| codeUnits[1] = C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $char >>> 4); |
| codeUnits[2] = C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $char & 15); |
| } else { |
| if ($char > 2047) |
| if ($char > 65535) { |
| flag = 240; |
| encodedBytes = 4; |
| } else { |
| flag = 224; |
| encodedBytes = 3; |
| } |
| else { |
| flag = 192; |
| encodedBytes = 2; |
| } |
| t1 = 3 * encodedBytes; |
| codeUnits = new Array(t1); |
| codeUnits.fixed$length = Array; |
| for (index = 0; --encodedBytes, encodedBytes >= 0; flag = 128) { |
| $byte = C.JSInt_methods._shrReceiverPositive$1($char, 6 * encodedBytes) & 63 | flag; |
| if (index >= t1) |
| return H.ioore(codeUnits, index); |
| codeUnits[index] = 37; |
| t2 = index + 1; |
| t3 = C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $byte >>> 4); |
| if (t2 >= t1) |
| return H.ioore(codeUnits, t2); |
| codeUnits[t2] = t3; |
| t3 = index + 2; |
| t2 = C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $byte & 15); |
| if (t3 >= t1) |
| return H.ioore(codeUnits, t3); |
| codeUnits[t3] = t2; |
| index += 3; |
| } |
| } |
| return P.String_String$fromCharCodes(codeUnits, 0, null); |
| }, Uri__normalize: function(component, start, end, charTable) { |
| var index, sectionStart, buffer, $char, t1, replacement, sourceLength, tail; |
| index = start; |
| sectionStart = index; |
| buffer = null; |
| while (true) { |
| if (typeof index !== "number") |
| return index.$lt(); |
| if (typeof end !== "number") |
| return H.iae(end); |
| if (!(index < end)) |
| break; |
| c$0: { |
| $char = C.JSString_methods.codeUnitAt$1(component, index); |
| if ($char < 127) { |
| t1 = $char >>> 4; |
| if (t1 >= 8) |
| return H.ioore(charTable, t1); |
| t1 = (charTable[t1] & C.JSInt_methods._shlPositive$1(1, $char & 15)) !== 0; |
| } else |
| t1 = false; |
| if (t1) |
| ++index; |
| else { |
| if ($char === 37) { |
| replacement = P.Uri__normalizeEscape(component, index, false); |
| if (replacement == null) { |
| index += 3; |
| break c$0; |
| } |
| if ("%" === replacement) { |
| replacement = "%25"; |
| sourceLength = 1; |
| } else |
| sourceLength = 3; |
| } else { |
| if ($char <= 93) { |
| t1 = $char >>> 4; |
| if (t1 >= 8) |
| return H.ioore(C.List_2Vk, t1); |
| t1 = (C.List_2Vk[t1] & C.JSInt_methods._shlPositive$1(1, $char & 15)) !== 0; |
| } else |
| t1 = false; |
| if (t1) { |
| P.Uri__fail(component, index, "Invalid character"); |
| replacement = null; |
| sourceLength = null; |
| } else { |
| if (($char & 64512) === 55296) { |
| t1 = index + 1; |
| if (t1 < end) { |
| tail = C.JSString_methods.codeUnitAt$1(component, t1); |
| if ((tail & 64512) === 56320) { |
| $char = (65536 | ($char & 1023) << 10 | tail & 1023) >>> 0; |
| sourceLength = 2; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| replacement = P.Uri__escapeChar($char); |
| } |
| } |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| t1 = C.JSString_methods.substring$2(component, sectionStart, index); |
| buffer._contents = buffer._contents + t1; |
| buffer._contents += H.S(replacement); |
| if (typeof sourceLength !== "number") |
| return H.iae(sourceLength); |
| index += sourceLength; |
| sectionStart = index; |
| } |
| } |
| } |
| if (buffer == null) |
| return C.JSString_methods.substring$2(component, start, end); |
| if (typeof sectionStart !== "number") |
| return sectionStart.$lt(); |
| if (sectionStart < end) |
| buffer._contents += C.JSString_methods.substring$2(component, sectionStart, end); |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, Uri__mayContainDotSegments: function(path) { |
| if (C.JSString_methods.startsWith$1(path, ".")) |
| return true; |
| return C.JSString_methods.indexOf$1(path, "/.") !== -1; |
| }, Uri__removeDotSegments: function(path) { |
| var output, t1, t2, appendSlash, _i, segment, t3; |
| if (!P.Uri__mayContainDotSegments(path)) |
| return path; |
| output = []; |
| for (t1 = path.split("/"), t2 = t1.length, appendSlash = false, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| segment = t1[_i]; |
| if (J.$eq$(segment, "..")) { |
| t3 = output.length; |
| if (t3 !== 0) { |
| if (0 >= t3) |
| return H.ioore(output, -1); |
| output.pop(); |
| if (output.length === 0) |
| output.push(""); |
| } |
| appendSlash = true; |
| } else if ("." === segment) |
| appendSlash = true; |
| else { |
| output.push(segment); |
| appendSlash = false; |
| } |
| } |
| if (appendSlash) |
| output.push(""); |
| return C.JSArray_methods.join$1(output, "/"); |
| }, Uri__normalizeRelativePath: function(path) { |
| var output, t1, t2, appendSlash, _i, segment; |
| if (!P.Uri__mayContainDotSegments(path)) |
| return path; |
| output = []; |
| for (t1 = path.split("/"), t2 = t1.length, appendSlash = false, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| segment = t1[_i]; |
| if (".." === segment) |
| if (output.length !== 0 && !J.$eq$(C.JSArray_methods.get$last(output), "..")) { |
| if (0 >= output.length) |
| return H.ioore(output, -1); |
| output.pop(); |
| appendSlash = true; |
| } else { |
| output.push(".."); |
| appendSlash = false; |
| } |
| else if ("." === segment) |
| appendSlash = true; |
| else { |
| output.push(segment); |
| appendSlash = false; |
| } |
| } |
| t1 = output.length; |
| if (t1 !== 0) |
| if (t1 === 1) { |
| if (0 >= t1) |
| return H.ioore(output, 0); |
| t1 = J.get$isEmpty$asx(output[0]) === true; |
| } else |
| t1 = false; |
| else |
| t1 = true; |
| if (t1) |
| return "./"; |
| if (appendSlash || J.$eq$(C.JSArray_methods.get$last(output), "..")) |
| output.push(""); |
| return C.JSArray_methods.join$1(output, "/"); |
| }, Uri_decodeComponent: [function(encodedComponent) { |
| return P.Uri__uriDecode(encodedComponent, C.Utf8Codec_false, false); |
| }, "call$1", "core_Uri_decodeComponent$closure", 2, 0, 9], Uri_parseIPv4Address: function(host) { |
| var t1, bytes; |
| t1 = new P.Uri_parseIPv4Address_error(); |
| bytes = host.split("."); |
| if (bytes.length !== 4) |
| t1.call$1("IPv4 address should contain exactly 4 parts"); |
| return H.setRuntimeTypeInfo(new H.MappedListIterable(bytes, new P.Uri_parseIPv4Address_closure(t1)), [null, null]).toList$0(0); |
| }, Uri_parseIPv6Address: function(host, start, end) { |
| var error, parseHex, parts, partStart, last, i, wildcardSeen, t1, atEnd, isLastWildcard, exception, t2, bytes, index, value, wildCardLength, j; |
| if (end == null) |
| end = J.get$length$asx(host); |
| error = new P.Uri_parseIPv6Address_error(host); |
| parseHex = new P.Uri_parseIPv6Address_parseHex(host, error); |
| if (J.get$length$asx(host) < 2) |
| error.call$1("address is too short"); |
| parts = []; |
| partStart = start; |
| i = start; |
| wildcardSeen = false; |
| while (true) { |
| t1 = end; |
| if (typeof i !== "number") |
| return i.$lt(); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| if (!(i < t1)) |
| break; |
| if (J.codeUnitAt$1$s(host, i) === 58) { |
| if (i === start) { |
| ++i; |
| if (J.codeUnitAt$1$s(host, i) !== 58) |
| error.call$2("invalid start colon.", i); |
| partStart = i; |
| } |
| if (i === partStart) { |
| if (wildcardSeen) |
| error.call$2("only one wildcard `::` is allowed", i); |
| J.add$1$ax(parts, -1); |
| wildcardSeen = true; |
| } else |
| J.add$1$ax(parts, parseHex.call$2(partStart, i)); |
| partStart = i + 1; |
| } |
| ++i; |
| } |
| if (J.get$length$asx(parts) === 0) |
| error.call$1("too few parts"); |
| atEnd = J.$eq$(partStart, end); |
| isLastWildcard = J.$eq$(J.get$last$ax(parts), -1); |
| if (atEnd && !isLastWildcard) |
| error.call$2("expected a part after last `:`", end); |
| if (!atEnd) |
| try { |
| J.add$1$ax(parts, parseHex.call$2(partStart, end)); |
| } catch (exception) { |
| H.unwrapException(exception); |
| try { |
| last = P.Uri_parseIPv4Address(J.substring$2$s(host, partStart, end)); |
| t1 = J.$index$asx(last, 0); |
| if (typeof t1 !== "number") |
| return t1.$shl(); |
| t2 = J.$index$asx(last, 1); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| J.add$1$ax(parts, (t1 << 8 | t2) >>> 0); |
| t2 = J.$index$asx(last, 2); |
| if (typeof t2 !== "number") |
| return t2.$shl(); |
| t1 = J.$index$asx(last, 3); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| J.add$1$ax(parts, (t2 << 8 | t1) >>> 0); |
| } catch (exception) { |
| H.unwrapException(exception); |
| error.call$2("invalid end of IPv6 address.", partStart); |
| } |
| } |
| if (wildcardSeen) { |
| if (J.get$length$asx(parts) > 7) |
| error.call$1("an address with a wildcard must have less than 7 parts"); |
| } else if (J.get$length$asx(parts) !== 8) |
| error.call$1("an address without a wildcard must contain exactly 8 parts"); |
| bytes = new Array(16); |
| bytes.$builtinTypeInfo = [P.$int]; |
| i = 0; |
| index = 0; |
| while (true) { |
| t1 = J.get$length$asx(parts); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| if (!(i < t1)) |
| break; |
| value = J.$index$asx(parts, i); |
| if (J.getInterceptor(value).$eq(value, -1)) { |
| wildCardLength = 9 - J.get$length$asx(parts); |
| for (j = 0; j < wildCardLength; ++j) { |
| if (index < 0 || index >= 16) |
| return H.ioore(bytes, index); |
| bytes[index] = 0; |
| t1 = index + 1; |
| if (t1 >= 16) |
| return H.ioore(bytes, t1); |
| bytes[t1] = 0; |
| index += 2; |
| } |
| } else { |
| if (typeof value !== "number") |
| return value.$shr(); |
| t1 = C.JSNumber_methods._shrOtherPositive$1(value, 8); |
| if (index < 0 || index >= 16) |
| return H.ioore(bytes, index); |
| bytes[index] = t1; |
| t1 = index + 1; |
| if (t1 >= 16) |
| return H.ioore(bytes, t1); |
| bytes[t1] = value & 255; |
| index += 2; |
| } |
| ++i; |
| } |
| return bytes; |
| }, Uri__uriEncode: function(canonicalTable, text, encoding, spaceToPlus) { |
| var t1, result, bytes, t2, i, $byte, t3; |
| t1 = new P.Uri__uriEncode_byteToHex(); |
| result = new P.StringBuffer(""); |
| bytes = encoding.get$encoder().convert$1(text); |
| for (t2 = bytes.length, i = 0; i < t2; ++i) { |
| $byte = bytes[i]; |
| if ($byte < 128) { |
| t3 = $byte >>> 4; |
| if (t3 >= 8) |
| return H.ioore(canonicalTable, t3); |
| t3 = (canonicalTable[t3] & C.JSInt_methods._shlPositive$1(1, $byte & 15)) !== 0; |
| } else |
| t3 = false; |
| if (t3) |
| result._contents += H.Primitives_stringFromCharCode($byte); |
| else if (spaceToPlus && $byte === 32) |
| result._contents += H.Primitives_stringFromCharCode(43); |
| else { |
| result._contents += H.Primitives_stringFromCharCode(37); |
| t1.call$2($byte, result); |
| } |
| } |
| t1 = result._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, Uri__hexCharPairToByte: function(s, pos) { |
| var $byte, i, charCode; |
| for ($byte = 0, i = 0; i < 2; ++i) { |
| charCode = C.JSString_methods.codeUnitAt$1(s, pos + i); |
| if (48 <= charCode && charCode <= 57) |
| $byte = $byte * 16 + charCode - 48; |
| else { |
| charCode |= 32; |
| if (97 <= charCode && charCode <= 102) |
| $byte = $byte * 16 + charCode - 87; |
| else |
| throw H.wrapException(P.ArgumentError$("Invalid URL encoding")); |
| } |
| } |
| return $byte; |
| }, Uri__uriDecode: function(text, encoding, plusToSpace) { |
| var t1, simple, i, t2, codeUnit, bytes; |
| t1 = J.getInterceptor$asx(text); |
| simple = true; |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(text); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2 && simple)) |
| break; |
| codeUnit = t1.codeUnitAt$1(text, i); |
| simple = codeUnit !== 37 && codeUnit !== 43; |
| ++i; |
| } |
| if (simple) |
| if (encoding === C.Utf8Codec_false || false) |
| return text; |
| else |
| bytes = t1.get$codeUnits(text); |
| else { |
| bytes = []; |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(text); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| codeUnit = t1.codeUnitAt$1(text, i); |
| if (codeUnit > 127) |
| throw H.wrapException(P.ArgumentError$("Illegal percent encoding in URI")); |
| if (codeUnit === 37) { |
| if (i + 3 > text.length) |
| throw H.wrapException(P.ArgumentError$("Truncated URI")); |
| bytes.push(P.Uri__hexCharPairToByte(text, i + 1)); |
| i += 2; |
| } else if (plusToSpace && codeUnit === 43) |
| bytes.push(32); |
| else |
| bytes.push(codeUnit); |
| ++i; |
| } |
| } |
| return new P.Utf8Decoder(encoding._allowMalformed).convert$1(bytes); |
| }} |
| }, |
| Uri_parse_parseAuth: { |
| "^": "Closure:2;_core$_box_0,_captured_uri_1,_captured_EOI_2", |
| call$0: function() { |
| var t1, hostStart, t2, $char, lastColon, lastAt, t3, t4, char0, endBracket, hostEnd, i, portNumber, digit; |
| t1 = this._core$_box_0; |
| hostStart = t1._captured_index_5; |
| t2 = t1._captured_end_0; |
| if (hostStart == null ? t2 == null : hostStart === t2) { |
| t1._captured_char_6 = this._captured_EOI_2; |
| return; |
| } |
| t2 = this._captured_uri_1; |
| t1._captured_char_6 = C.JSString_methods.codeUnitAt$1(t2, hostStart); |
| $char = this._captured_EOI_2; |
| lastColon = -1; |
| lastAt = -1; |
| while (true) { |
| t3 = t1._captured_index_5; |
| t4 = t1._captured_end_0; |
| if (typeof t3 !== "number") |
| return t3.$lt(); |
| if (typeof t4 !== "number") |
| return H.iae(t4); |
| if (!(t3 < t4)) |
| break; |
| char0 = C.JSString_methods.codeUnitAt$1(t2, t3); |
| t1._captured_char_6 = char0; |
| if (char0 === 47 || char0 === 63 || char0 === 35) |
| break; |
| if (char0 === 64) { |
| lastAt = t1._captured_index_5; |
| lastColon = -1; |
| } else if (char0 === 58) |
| lastColon = t1._captured_index_5; |
| else if (char0 === 91) { |
| t3 = t1._captured_index_5; |
| if (typeof t3 !== "number") |
| return t3.$add(); |
| endBracket = C.JSString_methods.indexOf$2(t2, "]", t3 + 1); |
| if (endBracket === -1) { |
| t1._captured_index_5 = t1._captured_end_0; |
| t1._captured_char_6 = $char; |
| lastColon = -1; |
| break; |
| } else |
| t1._captured_index_5 = endBracket; |
| lastColon = -1; |
| } |
| t3 = t1._captured_index_5; |
| if (typeof t3 !== "number") |
| return t3.$add(); |
| t1._captured_index_5 = t3 + 1; |
| t1._captured_char_6 = $char; |
| } |
| hostEnd = t1._captured_index_5; |
| if (typeof lastAt !== "number") |
| return lastAt.$ge(); |
| if (lastAt >= 0) { |
| t1._captured_userinfo_2 = P.Uri__makeUserInfo(t2, hostStart, lastAt); |
| hostStart = lastAt + 1; |
| } |
| if (typeof lastColon !== "number") |
| return lastColon.$ge(); |
| if (lastColon >= 0) { |
| i = lastColon + 1; |
| t3 = t1._captured_index_5; |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| if (i < t3) { |
| portNumber = 0; |
| while (true) { |
| t3 = t1._captured_index_5; |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| if (!(i < t3)) |
| break; |
| digit = C.JSString_methods.codeUnitAt$1(t2, i); |
| if (48 > digit || 57 < digit) |
| P.Uri__fail(t2, i, "Invalid port number"); |
| portNumber = portNumber * 10 + (digit - 48); |
| ++i; |
| } |
| } else |
| portNumber = null; |
| t1._captured_port_4 = P.Uri__makePort(portNumber, t1._captured_scheme_1); |
| hostEnd = lastColon; |
| } |
| t1._captured_host_3 = P.Uri__makeHost(t2, hostStart, hostEnd, true); |
| t3 = t1._captured_index_5; |
| t4 = t1._captured_end_0; |
| if (typeof t3 !== "number") |
| return t3.$lt(); |
| if (typeof t4 !== "number") |
| return H.iae(t4); |
| if (t3 < t4) |
| t1._captured_char_6 = C.JSString_methods.codeUnitAt$1(t2, t3); |
| } |
| }, |
| Uri__checkNonWindowsPathReservedCharacters_closure: { |
| "^": "Closure:0;_captured_argumentError_0", |
| call$1: function(segment) { |
| if (J.contains$1$asx(segment, "/") === true) |
| if (this._captured_argumentError_0) |
| throw H.wrapException(P.ArgumentError$("Illegal path character " + H.S(segment))); |
| else |
| throw H.wrapException(new P.UnsupportedError("Illegal path character " + H.S(segment))); |
| } |
| }, |
| Uri__makeQuery_closure: { |
| "^": "Closure:3;_core$_box_0,_core$_captured_result_1", |
| call$2: function(key, value) { |
| var t1 = this._core$_box_0; |
| if (!t1._captured_first_0) |
| this._core$_captured_result_1._contents += "&"; |
| t1._captured_first_0 = false; |
| t1 = this._core$_captured_result_1; |
| t1._contents += P.Uri__uriEncode(C.List_nxB, key, C.Utf8Codec_false, true); |
| if (!value.get$isEmpty(value)) { |
| t1._contents += "="; |
| t1._contents += P.Uri__uriEncode(C.List_nxB, value, C.Utf8Codec_false, true); |
| } |
| } |
| }, |
| Uri_hashCode_combine: { |
| "^": "Closure:22;", |
| call$2: function(part, current) { |
| return current * 31 + J.get$hashCode$(part) & 1073741823; |
| } |
| }, |
| Uri_parseIPv4Address_error: { |
| "^": "Closure:23;", |
| call$1: function(msg) { |
| throw H.wrapException(new P.FormatException("Illegal IPv4 address, " + msg, null, null)); |
| } |
| }, |
| Uri_parseIPv4Address_closure: { |
| "^": "Closure:0;_core$_captured_error_0", |
| call$1: function(byteString) { |
| var $byte, t1; |
| $byte = H.Primitives_parseInt(byteString, null, null); |
| t1 = J.getInterceptor$n($byte); |
| if (t1.$lt($byte, 0) || t1.$gt($byte, 255)) |
| this._core$_captured_error_0.call$1("each part must be in the range of `0..255`"); |
| return $byte; |
| } |
| }, |
| Uri_parseIPv6Address_error: { |
| "^": "Closure:24;_captured_host_0", |
| call$2: function(msg, position) { |
| throw H.wrapException(new P.FormatException("Illegal IPv6 address, " + msg, this._captured_host_0, position)); |
| }, |
| call$1: function(msg) { |
| return this.call$2(msg, null); |
| } |
| }, |
| Uri_parseIPv6Address_parseHex: { |
| "^": "Closure:25;_captured_host_1,_captured_error_2", |
| call$2: function(start, end) { |
| var value, t1; |
| if (typeof start !== "number") |
| return H.iae(start); |
| if (end - start > 4) |
| this._captured_error_2.call$2("an IPv6 part can only contain a maximum of 4 hex digits", start); |
| value = H.Primitives_parseInt(C.JSString_methods.substring$2(this._captured_host_1, start, end), 16, null); |
| t1 = J.getInterceptor$n(value); |
| if (t1.$lt(value, 0) || t1.$gt(value, 65535)) |
| this._captured_error_2.call$2("each part must be in the range of `0x0..0xFFFF`", start); |
| return value; |
| } |
| }, |
| Uri__uriEncode_byteToHex: { |
| "^": "Closure:3;", |
| call$2: function($byte, buffer) { |
| buffer._contents += H.Primitives_stringFromCharCode(C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $byte >>> 4)); |
| buffer._contents += H.Primitives_stringFromCharCode(C.JSString_methods.codeUnitAt$1("0123456789ABCDEF", $byte & 15)); |
| } |
| } |
| }], ["dart.dom.html", "dart:html",, W, { |
| "^": "", |
| AnchorElement_AnchorElement: function(href) { |
| var e = document.createElement("a", null); |
| return e; |
| }, |
| Element_Element$html: function(html, treeSanitizer, validator) { |
| var t1, fragment; |
| t1 = document.body; |
| fragment = (t1 && C.BodyElement_methods).createFragment$3$treeSanitizer$validator(t1, html, treeSanitizer, validator); |
| fragment.toString; |
| t1 = new W._ChildNodeListLazy(fragment); |
| t1 = t1.where$1(t1, new W.Element_Element$html_closure()); |
| return t1.get$single(t1); |
| }, |
| HttpRequest_getString: function(url, onProgress, withCredentials) { |
| return W.HttpRequest_request(url, null, null, onProgress, null, null, null, withCredentials).then$1(new W.HttpRequest_getString_closure()); |
| }, |
| HttpRequest_request: function(url, method, mimeType, onProgress, requestHeaders, responseType, sendData, withCredentials) { |
| var completer, xhr, t1; |
| completer = H.setRuntimeTypeInfo(new P._AsyncCompleter(H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [W.HttpRequest])), [W.HttpRequest]); |
| xhr = new XMLHttpRequest(); |
| C.HttpRequest_methods.open$3$async(xhr, "GET", url, true); |
| t1 = H.setRuntimeTypeInfo(new W._EventStream(xhr, "load", false), [null]); |
| H.setRuntimeTypeInfo(new W._EventStreamSubscription(0, t1._target, t1._eventType, W._wrapZone(new W.HttpRequest_request_closure(completer, xhr)), t1._useCapture), [H.getTypeArgumentByIndex(t1, 0)])._tryResume$0(); |
| t1 = H.setRuntimeTypeInfo(new W._EventStream(xhr, "error", false), [null]); |
| H.setRuntimeTypeInfo(new W._EventStreamSubscription(0, t1._target, t1._eventType, W._wrapZone(completer.get$completeError()), t1._useCapture), [H.getTypeArgumentByIndex(t1, 0)])._tryResume$0(); |
| xhr.send(); |
| return completer.future; |
| }, |
| _JenkinsSmiHash_combine: function(hash, value) { |
| hash = 536870911 & hash + value; |
| hash = 536870911 & hash + ((524287 & hash) << 10 >>> 0); |
| return hash ^ hash >>> 6; |
| }, |
| _JenkinsSmiHash_finish: function(hash) { |
| hash = 536870911 & hash + ((67108863 & hash) << 3 >>> 0); |
| hash ^= hash >>> 11; |
| return 536870911 & hash + ((16383 & hash) << 15 >>> 0); |
| }, |
| _convertNativeToDart_EventTarget: function(e) { |
| var $window; |
| if (e == null) |
| return; |
| if ("postMessage" in e) { |
| $window = W._DOMWindowCrossFrame__createSafe(e); |
| if (!!J.getInterceptor($window).$isEventTarget) |
| return $window; |
| return; |
| } else |
| return e; |
| }, |
| _wrapZone: function(callback) { |
| var t1 = $.Zone__current; |
| if (t1 === C.C__RootZone) |
| return callback; |
| return t1.bindUnaryCallback$2$runGuarded(callback, true); |
| }, |
| HtmlElement: { |
| "^": "Element;", |
| $isHtmlElement: 1, |
| $isElement: 1, |
| $isNode: 1, |
| $isObject: 1, |
| "%": "HTMLAppletElement|HTMLBRElement|HTMLCanvasElement|HTMLContentElement|HTMLDListElement|HTMLDataListElement|HTMLDetailsElement|HTMLDialogElement|HTMLDirectoryElement|HTMLFontElement|HTMLFrameElement|HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLMarqueeElement|HTMLMenuElement|HTMLMenuItemElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLOptGroupElement|HTMLOptionElement|HTMLParagraphElement|HTMLPictureElement|HTMLPreElement|HTMLProgressElement|HTMLQuoteElement|HTMLScriptElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement|HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement|HTMLTableRowElement|HTMLTableSectionElement|HTMLTitleElement|HTMLTrackElement|HTMLUListElement|HTMLUnknownElement;HTMLElement" |
| }, |
| AnchorElement: { |
| "^": "HtmlElement;target=,hostname=,href},port=,protocol=", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| $isInterceptor: 1, |
| "%": "HTMLAnchorElement" |
| }, |
| ApplicationCacheErrorEvent: { |
| "^": "Event;message=", |
| "%": "ApplicationCacheErrorEvent" |
| }, |
| AreaElement: { |
| "^": "HtmlElement;target=,hostname=,href},port=,protocol=", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| $isInterceptor: 1, |
| "%": "HTMLAreaElement" |
| }, |
| BaseElement: { |
| "^": "HtmlElement;href},target=", |
| "%": "HTMLBaseElement" |
| }, |
| Blob: { |
| "^": "Interceptor;", |
| "%": ";Blob" |
| }, |
| BodyElement: { |
| "^": "HtmlElement;", |
| $isBodyElement: 1, |
| $isEventTarget: 1, |
| $isInterceptor: 1, |
| "%": "HTMLBodyElement" |
| }, |
| ButtonElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLButtonElement" |
| }, |
| CharacterData: { |
| "^": "Node;length=", |
| $isInterceptor: 1, |
| "%": "CDATASection|Comment|Text;CharacterData" |
| }, |
| CssStyleDeclaration: { |
| "^": "Interceptor_CssStyleDeclarationBase;length=", |
| "%": "CSS2Properties|CSSStyleDeclaration|MSStyleCSSProperties" |
| }, |
| Interceptor_CssStyleDeclarationBase: { |
| "^": "Interceptor+CssStyleDeclarationBase;" |
| }, |
| CssStyleDeclarationBase: { |
| "^": "Object;" |
| }, |
| DivElement: { |
| "^": "HtmlElement;", |
| "%": ";HTMLDivElement" |
| }, |
| Document: { |
| "^": "Node;", |
| querySelector$1: function(receiver, selectors) { |
| return receiver.querySelector(selectors); |
| }, |
| get$onClick: function(receiver) { |
| return H.setRuntimeTypeInfo(new W._EventStream(receiver, "click", false), [null]); |
| }, |
| "%": "Document|HTMLDocument|XMLDocument" |
| }, |
| DocumentFragment: { |
| "^": "Node;", |
| querySelector$1: function(receiver, selectors) { |
| return receiver.querySelector(selectors); |
| }, |
| $isInterceptor: 1, |
| "%": "DocumentFragment|ShadowRoot" |
| }, |
| DomError: { |
| "^": "Interceptor;message=,name=", |
| "%": "DOMError|FileError" |
| }, |
| DomException: { |
| "^": "Interceptor;message=", |
| get$name: function(receiver) { |
| var errorName = receiver.name; |
| if (P.Device_isWebKit() === true && errorName === "SECURITY_ERR") |
| return "SecurityError"; |
| if (P.Device_isWebKit() === true && errorName === "SYNTAX_ERR") |
| return "SyntaxError"; |
| return errorName; |
| }, |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| "%": "DOMException" |
| }, |
| DomRectReadOnly: { |
| "^": "Interceptor;bottom=,height=,left=,right=,top=,width=", |
| toString$0: function(receiver) { |
| return "Rectangle (" + H.S(receiver.left) + ", " + H.S(receiver.top) + ") " + H.S(this.get$width(receiver)) + " x " + H.S(this.get$height(receiver)); |
| }, |
| $eq: function(receiver, other) { |
| var t1, t2, t3; |
| if (other == null) |
| return false; |
| t1 = J.getInterceptor(other); |
| if (!t1.$isRectangle) |
| return false; |
| t2 = receiver.left; |
| t3 = t1.get$left(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = receiver.top; |
| t3 = t1.get$top(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = this.get$width(receiver); |
| t3 = t1.get$width(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = this.get$height(receiver); |
| t1 = t1.get$height(other); |
| t1 = t2 == null ? t1 == null : t2 === t1; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| return t1; |
| }, |
| get$hashCode: function(receiver) { |
| var t1, t2, t3, t4; |
| t1 = J.get$hashCode$(receiver.left); |
| t2 = J.get$hashCode$(receiver.top); |
| t3 = J.get$hashCode$(this.get$width(receiver)); |
| t4 = J.get$hashCode$(this.get$height(receiver)); |
| return W._JenkinsSmiHash_finish(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(0, t1), t2), t3), t4)); |
| }, |
| $isRectangle: 1, |
| $asRectangle: Isolate.functionThatReturnsNull, |
| "%": ";DOMRectReadOnly" |
| }, |
| DomTokenList: { |
| "^": "Interceptor;length=", |
| add$1: function(receiver, tokens) { |
| return receiver.add(tokens); |
| }, |
| contains$1: function(receiver, token) { |
| return receiver.contains(token); |
| }, |
| "%": "DOMSettableTokenList|DOMTokenList" |
| }, |
| Element: { |
| "^": "Node;tagName=", |
| get$attributes: function(receiver) { |
| return new W._ElementAttributeMap(receiver); |
| }, |
| get$classes: function(receiver) { |
| return new W._ElementCssClassSet(receiver); |
| }, |
| toString$0: function(receiver) { |
| return receiver.localName; |
| }, |
| createFragment$3$treeSanitizer$validator: function(receiver, html, treeSanitizer, validator) { |
| var t1, t2, base, contextElement, fragment; |
| if (treeSanitizer == null) { |
| if (validator == null) { |
| t1 = $.Element__defaultValidator; |
| if (t1 == null) { |
| t1 = H.setRuntimeTypeInfo([], [W.NodeValidator]); |
| t2 = new W.NodeValidatorBuilder(t1); |
| t1.push(W._Html5NodeValidator$(null)); |
| t1.push(W._TemplatingNodeValidator$()); |
| $.Element__defaultValidator = t2; |
| validator = t2; |
| } else |
| validator = t1; |
| } |
| t1 = $.Element__defaultSanitizer; |
| if (t1 == null) { |
| t1 = new W._ValidatingTreeSanitizer(validator); |
| $.Element__defaultSanitizer = t1; |
| treeSanitizer = t1; |
| } else { |
| t1.validator = validator; |
| treeSanitizer = t1; |
| } |
| } else if (validator != null) |
| throw H.wrapException(P.ArgumentError$("validator can only be passed if treeSanitizer is null")); |
| if ($.Element__parseDocument == null) { |
| t1 = document.implementation.createHTMLDocument(""); |
| $.Element__parseDocument = t1; |
| $.Element__parseRange = t1.createRange(); |
| base = $.Element__parseDocument.createElement("base", null); |
| J.set$href$x(base, document.baseURI); |
| $.Element__parseDocument.head.appendChild(base); |
| } |
| t1 = $.Element__parseDocument; |
| if (!!this.$isBodyElement) |
| contextElement = t1.body; |
| else { |
| contextElement = t1.createElement(receiver.tagName, null); |
| $.Element__parseDocument.body.appendChild(contextElement); |
| } |
| if ("createContextualFragment" in window.Range.prototype && !C.JSArray_methods.contains$1(C.List_ego, receiver.tagName)) { |
| $.Element__parseRange.selectNodeContents(contextElement); |
| fragment = $.Element__parseRange.createContextualFragment(html); |
| } else { |
| contextElement.innerHTML = html; |
| fragment = $.Element__parseDocument.createDocumentFragment(); |
| for (; t1 = contextElement.firstChild, t1 != null;) |
| fragment.appendChild(t1); |
| } |
| t1 = $.Element__parseDocument.body; |
| if (contextElement == null ? t1 != null : contextElement !== t1) |
| J.remove$0$ax(contextElement); |
| treeSanitizer.sanitizeTree$1(fragment); |
| document.adoptNode(fragment); |
| return fragment; |
| }, |
| querySelector$1: function(receiver, selectors) { |
| return receiver.querySelector(selectors); |
| }, |
| get$onClick: function(receiver) { |
| return H.setRuntimeTypeInfo(new W._ElementEventStreamImpl(receiver, "click", false), [null]); |
| }, |
| $isElement: 1, |
| $isNode: 1, |
| $isObject: 1, |
| $isInterceptor: 1, |
| $isEventTarget: 1, |
| "%": ";Element" |
| }, |
| Element_Element$html_closure: { |
| "^": "Closure:0;", |
| call$1: function(e) { |
| return !!J.getInterceptor(e).$isElement; |
| } |
| }, |
| EmbedElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLEmbedElement" |
| }, |
| ErrorEvent: { |
| "^": "Event;error=,message=", |
| "%": "ErrorEvent" |
| }, |
| Event: { |
| "^": "Interceptor;", |
| get$target: function(receiver) { |
| return W._convertNativeToDart_EventTarget(receiver.target); |
| }, |
| "%": "AnimationPlayerEvent|AudioProcessingEvent|AutocompleteErrorEvent|BeforeUnloadEvent|CloseEvent|CompositionEvent|CustomEvent|DeviceLightEvent|DeviceMotionEvent|DeviceOrientationEvent|DragEvent|ExtendableEvent|FetchEvent|FocusEvent|FontFaceSetLoadEvent|GamepadEvent|HashChangeEvent|IDBVersionChangeEvent|InstallEvent|KeyboardEvent|MIDIConnectionEvent|MIDIMessageEvent|MSPointerEvent|MediaKeyNeededEvent|MediaQueryListEvent|MediaStreamEvent|MediaStreamTrackEvent|MessageEvent|MouseEvent|MutationEvent|OfflineAudioCompletionEvent|OverflowEvent|PageTransitionEvent|PointerEvent|PopStateEvent|ProgressEvent|PushEvent|RTCDTMFToneChangeEvent|RTCDataChannelEvent|RTCIceCandidateEvent|RTCPeerConnectionIceEvent|RelatedEvent|ResourceProgressEvent|SVGZoomEvent|SecurityPolicyViolationEvent|SpeechRecognitionEvent|StorageEvent|TextEvent|TouchEvent|TrackEvent|TransitionEvent|UIEvent|WebGLContextEvent|WebKitAnimationEvent|WebKitTransitionEvent|WheelEvent|XMLHttpRequestProgressEvent;ClipboardEvent|Event|InputEvent" |
| }, |
| EventTarget: { |
| "^": "Interceptor;", |
| _addEventListener$3: function(receiver, type, listener, useCapture) { |
| return receiver.addEventListener(type, H.convertDartClosureToJS(listener, 1), useCapture); |
| }, |
| _removeEventListener$3: function(receiver, type, listener, useCapture) { |
| return receiver.removeEventListener(type, H.convertDartClosureToJS(listener, 1), useCapture); |
| }, |
| $isEventTarget: 1, |
| "%": "MediaStream;EventTarget" |
| }, |
| FieldSetElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLFieldSetElement" |
| }, |
| File: { |
| "^": "Blob;name=", |
| "%": "File" |
| }, |
| FormElement: { |
| "^": "HtmlElement;length=,name=,target=", |
| "%": "HTMLFormElement" |
| }, |
| HttpRequest: { |
| "^": "HttpRequestEventTarget;responseText=", |
| open$5$async$password$user: function(receiver, method, url, async, password, user) { |
| return receiver.open(method, url, async, user, password); |
| }, |
| open$3$async: function($receiver, method, url, async) { |
| return $receiver.open(method, url, async); |
| }, |
| send$1: function(receiver, data) { |
| return receiver.send(data); |
| }, |
| $isHttpRequest: 1, |
| $isObject: 1, |
| "%": "XMLHttpRequest" |
| }, |
| HttpRequest_getString_closure: { |
| "^": "Closure:26;", |
| call$1: function(xhr) { |
| return J.get$responseText$x(xhr); |
| } |
| }, |
| HttpRequest_request_closure: { |
| "^": "Closure:0;_captured_completer_1,_captured_xhr_2", |
| call$1: function(e) { |
| var t1, t2, accepted, unknownRedirect, t3; |
| t1 = this._captured_xhr_2; |
| t2 = t1.status; |
| if (typeof t2 !== "number") |
| return t2.$ge(); |
| accepted = t2 >= 200 && t2 < 300; |
| unknownRedirect = t2 > 307 && t2 < 400; |
| t2 = accepted || t2 === 0 || t2 === 304 || unknownRedirect; |
| t3 = this._captured_completer_1; |
| if (t2) |
| t3.complete$1(0, t1); |
| else |
| t3.completeError$1(e); |
| } |
| }, |
| HttpRequestEventTarget: { |
| "^": "EventTarget;", |
| "%": ";XMLHttpRequestEventTarget" |
| }, |
| IFrameElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLIFrameElement" |
| }, |
| ImageElement: { |
| "^": "HtmlElement;", |
| complete$1: function($receiver, arg0) { |
| return $receiver.complete.call$1(arg0); |
| }, |
| "%": "HTMLImageElement" |
| }, |
| InputElement: { |
| "^": "HtmlElement;name=", |
| accept$1: function($receiver, arg0) { |
| return $receiver.accept.call$1(arg0); |
| }, |
| $isElement: 1, |
| $isInterceptor: 1, |
| $isEventTarget: 1, |
| "%": "HTMLInputElement" |
| }, |
| KeygenElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLKeygenElement" |
| }, |
| LinkElement: { |
| "^": "HtmlElement;href}", |
| "%": "HTMLLinkElement" |
| }, |
| Location: { |
| "^": "Interceptor;", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| "%": "Location" |
| }, |
| MapElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLMapElement" |
| }, |
| MediaElement: { |
| "^": "HtmlElement;error=", |
| "%": "HTMLAudioElement|HTMLMediaElement|HTMLVideoElement" |
| }, |
| MediaKeyEvent: { |
| "^": "Event;message=", |
| "%": "MediaKeyEvent" |
| }, |
| MediaKeyMessageEvent: { |
| "^": "Event;message=", |
| "%": "MediaKeyMessageEvent" |
| }, |
| MetaElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLMetaElement" |
| }, |
| MidiOutput: { |
| "^": "MidiPort;", |
| send$2: function(receiver, data, timestamp) { |
| return receiver.send(data, timestamp); |
| }, |
| send$1: function($receiver, data) { |
| return $receiver.send(data); |
| }, |
| "%": "MIDIOutput" |
| }, |
| MidiPort: { |
| "^": "EventTarget;name=", |
| "%": "MIDIInput;MIDIPort" |
| }, |
| Navigator: { |
| "^": "Interceptor;", |
| $isInterceptor: 1, |
| "%": "Navigator" |
| }, |
| NavigatorUserMediaError: { |
| "^": "Interceptor;message=,name=", |
| "%": "NavigatorUserMediaError" |
| }, |
| _ChildNodeListLazy: { |
| "^": "ListBase;_this", |
| get$last: function(_) { |
| var result = this._this.lastChild; |
| if (result == null) |
| throw H.wrapException(new P.StateError("No elements")); |
| return result; |
| }, |
| add$1: function(_, value) { |
| this._this.appendChild(value); |
| }, |
| $indexSet: function(_, index, value) { |
| var t1, t2; |
| t1 = this._this; |
| t2 = t1.childNodes; |
| if (index < 0 || index >= t2.length) |
| return H.ioore(t2, index); |
| t1.replaceChild(value, t2[index]); |
| }, |
| get$iterator: function(_) { |
| return C.NodeList_methods.get$iterator(this._this.childNodes); |
| }, |
| get$length: function(_) { |
| return this._this.childNodes.length; |
| }, |
| set$length: function(_, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot set length on immutable List.")); |
| }, |
| $index: function(_, index) { |
| var t1 = this._this.childNodes; |
| if (index >>> 0 !== index || index >= t1.length) |
| return H.ioore(t1, index); |
| return t1[index]; |
| }, |
| $asListBase: function() { |
| return [W.Node]; |
| }, |
| $asObject_ListMixin: function() { |
| return [W.Node]; |
| }, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Node: { |
| "^": "EventTarget;", |
| remove$0: function(receiver) { |
| var t1 = receiver.parentNode; |
| if (t1 != null) |
| t1.removeChild(receiver); |
| }, |
| toString$0: function(receiver) { |
| var value = receiver.nodeValue; |
| return value == null ? this.super$Interceptor$toString(receiver) : value; |
| }, |
| contains$1: function(receiver, other) { |
| return receiver.contains(other); |
| }, |
| $isNode: 1, |
| $isObject: 1, |
| "%": ";Node" |
| }, |
| NodeList: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| throw H.wrapException(P.IndexError$(index, receiver, null, null, null)); |
| return receiver[index]; |
| }, |
| $indexSet: function(receiver, index, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot assign element of immutable List.")); |
| }, |
| set$length: function(receiver, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot resize immutable List.")); |
| }, |
| get$last: function(receiver) { |
| var len = receiver.length; |
| if (len > 0) |
| return receiver[len - 1]; |
| throw H.wrapException(new P.StateError("No elements")); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index < 0 || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1, |
| $isJavaScriptIndexingBehavior: 1, |
| $isJSIndexable: 1, |
| "%": "NodeList|RadioNodeList" |
| }, |
| Interceptor_ListMixin: { |
| "^": "Interceptor+ListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| Interceptor_ListMixin_ImmutableListMixin: { |
| "^": "Interceptor_ListMixin+ImmutableListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| ObjectElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLObjectElement" |
| }, |
| OutputElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLOutputElement" |
| }, |
| ParamElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLParamElement" |
| }, |
| PluginPlaceholderElement: { |
| "^": "DivElement;message=", |
| "%": "PluginPlaceholderElement" |
| }, |
| PositionError: { |
| "^": "Interceptor;message=", |
| "%": "PositionError" |
| }, |
| ProcessingInstruction: { |
| "^": "CharacterData;target=", |
| "%": "ProcessingInstruction" |
| }, |
| SelectElement: { |
| "^": "HtmlElement;length=,name=", |
| "%": "HTMLSelectElement" |
| }, |
| SpeechRecognitionError: { |
| "^": "Event;error=,message=", |
| "%": "SpeechRecognitionError" |
| }, |
| SpeechSynthesisEvent: { |
| "^": "Event;name=", |
| "%": "SpeechSynthesisEvent" |
| }, |
| TableColElement: { |
| "^": "HtmlElement;span=", |
| "%": "HTMLTableColElement" |
| }, |
| TemplateElement: { |
| "^": "HtmlElement;", |
| $isTemplateElement: 1, |
| "%": "HTMLTemplateElement" |
| }, |
| TextAreaElement: { |
| "^": "HtmlElement;name=", |
| "%": "HTMLTextAreaElement" |
| }, |
| Window: { |
| "^": "EventTarget;name=", |
| get$animationFrame: function(receiver) { |
| var completer = H.setRuntimeTypeInfo(new P._SyncCompleter(H.setRuntimeTypeInfo(new P._Future(0, $.Zone__current, null), [P.num])), [P.num]); |
| this._ensureRequestAnimationFrame$0(receiver); |
| this._requestAnimationFrame$1(receiver, W._wrapZone(new W.Window_animationFrame_closure(completer))); |
| return completer.future; |
| }, |
| _requestAnimationFrame$1: function(receiver, callback) { |
| return receiver.requestAnimationFrame(H.convertDartClosureToJS(callback, 1)); |
| }, |
| _ensureRequestAnimationFrame$0: function(receiver) { |
| if (!!(receiver.requestAnimationFrame && receiver.cancelAnimationFrame)) |
| return; |
| (function($this) { |
| var vendors = ['ms', 'moz', 'webkit', 'o']; |
| for (var i = 0; i < vendors.length && !$this.requestAnimationFrame; ++i) { |
| $this.requestAnimationFrame = $this[vendors[i] + 'RequestAnimationFrame']; |
| $this.cancelAnimationFrame = $this[vendors[i] + 'CancelAnimationFrame'] || $this[vendors[i] + 'CancelRequestAnimationFrame']; |
| } |
| if ($this.requestAnimationFrame && $this.cancelAnimationFrame) |
| return; |
| $this.requestAnimationFrame = function(callback) { |
| return window.setTimeout(function() { |
| callback(Date.now()); |
| }, 16); |
| }; |
| $this.cancelAnimationFrame = function(id) { |
| clearTimeout(id); |
| }; |
| })(receiver); |
| }, |
| get$onClick: function(receiver) { |
| return H.setRuntimeTypeInfo(new W._EventStream(receiver, "click", false), [null]); |
| }, |
| $isInterceptor: 1, |
| $isEventTarget: 1, |
| "%": "DOMWindow|Window" |
| }, |
| Window_animationFrame_closure: { |
| "^": "Closure:0;_captured_completer_0", |
| call$1: function(time) { |
| this._captured_completer_0.complete$1(0, time); |
| } |
| }, |
| _Attr: { |
| "^": "Node;name=", |
| "%": "Attr" |
| }, |
| _ClientRect: { |
| "^": "Interceptor;bottom=,height=,left=,right=,top=,width=", |
| toString$0: function(receiver) { |
| return "Rectangle (" + H.S(receiver.left) + ", " + H.S(receiver.top) + ") " + H.S(receiver.width) + " x " + H.S(receiver.height); |
| }, |
| $eq: function(receiver, other) { |
| var t1, t2, t3; |
| if (other == null) |
| return false; |
| t1 = J.getInterceptor(other); |
| if (!t1.$isRectangle) |
| return false; |
| t2 = receiver.left; |
| t3 = t1.get$left(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = receiver.top; |
| t3 = t1.get$top(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = receiver.width; |
| t3 = t1.get$width(other); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = receiver.height; |
| t1 = t1.get$height(other); |
| t1 = t2 == null ? t1 == null : t2 === t1; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| } else |
| t1 = false; |
| return t1; |
| }, |
| get$hashCode: function(receiver) { |
| var t1, t2, t3, t4; |
| t1 = J.get$hashCode$(receiver.left); |
| t2 = J.get$hashCode$(receiver.top); |
| t3 = J.get$hashCode$(receiver.width); |
| t4 = J.get$hashCode$(receiver.height); |
| return W._JenkinsSmiHash_finish(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(0, t1), t2), t3), t4)); |
| }, |
| $isRectangle: 1, |
| $asRectangle: Isolate.functionThatReturnsNull, |
| "%": "ClientRect" |
| }, |
| _DocumentType: { |
| "^": "Node;", |
| $isInterceptor: 1, |
| "%": "DocumentType" |
| }, |
| _DomRect: { |
| "^": "DomRectReadOnly;", |
| get$height: function(receiver) { |
| return receiver.height; |
| }, |
| get$width: function(receiver) { |
| return receiver.width; |
| }, |
| "%": "DOMRect" |
| }, |
| _HTMLFrameSetElement: { |
| "^": "HtmlElement;", |
| $isEventTarget: 1, |
| $isInterceptor: 1, |
| "%": "HTMLFrameSetElement" |
| }, |
| _NamedNodeMap: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin0;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| throw H.wrapException(P.IndexError$(index, receiver, null, null, null)); |
| return receiver[index]; |
| }, |
| $indexSet: function(receiver, index, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot assign element of immutable List.")); |
| }, |
| set$length: function(receiver, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot resize immutable List.")); |
| }, |
| get$last: function(receiver) { |
| var len = receiver.length; |
| if (len > 0) |
| return receiver[len - 1]; |
| throw H.wrapException(new P.StateError("No elements")); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index < 0 || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1, |
| $isJavaScriptIndexingBehavior: 1, |
| $isJSIndexable: 1, |
| "%": "MozNamedAttrMap|NamedNodeMap" |
| }, |
| Interceptor_ListMixin0: { |
| "^": "Interceptor+ListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| Interceptor_ListMixin_ImmutableListMixin0: { |
| "^": "Interceptor_ListMixin0+ImmutableListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| _AttributeMap: { |
| "^": "Object;_element<", |
| forEach$1: function(_, f) { |
| var t1, t2, _i, key; |
| for (t1 = this.get$keys(), t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| key = t1[_i]; |
| f.call$2(key, this.$index(0, key)); |
| } |
| }, |
| get$keys: function() { |
| var attributes, keys, len, i; |
| attributes = this._element.attributes; |
| keys = H.setRuntimeTypeInfo([], [P.String]); |
| for (len = attributes.length, i = 0; i < len; ++i) { |
| if (i >= attributes.length) |
| return H.ioore(attributes, i); |
| if (this._matches$1(attributes[i])) { |
| if (i >= attributes.length) |
| return H.ioore(attributes, i); |
| keys.push(J.get$name$x(attributes[i])); |
| } |
| } |
| return keys; |
| }, |
| get$isEmpty: function(_) { |
| return this.get$length(this) === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this.get$length(this) !== 0; |
| } |
| }, |
| _ElementAttributeMap: { |
| "^": "_AttributeMap;_element", |
| $index: function(_, key) { |
| return this._element.getAttribute(key); |
| }, |
| $indexSet: function(_, key, value) { |
| this._element.setAttribute(key, value); |
| }, |
| get$length: function(_) { |
| return this.get$keys().length; |
| }, |
| _matches$1: function(node) { |
| return node.namespaceURI == null; |
| } |
| }, |
| _ElementCssClassSet: { |
| "^": "CssClassSetImpl;_element<", |
| readClasses$0: function() { |
| var s, t1, t2, _i, trimmed; |
| s = P.LinkedHashSet_LinkedHashSet(null, null, null, P.String); |
| for (t1 = this._element.className.split(" "), t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| trimmed = J.trim$0$s(t1[_i]); |
| if (trimmed.length !== 0) |
| s.add$1(0, trimmed); |
| } |
| return s; |
| }, |
| writeClasses$1: function(s) { |
| this._element.className = s.join$1(0, " "); |
| }, |
| get$length: function(_) { |
| return this._element.classList.length; |
| }, |
| get$isEmpty: function(_) { |
| return this._element.classList.length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._element.classList.length !== 0; |
| }, |
| contains$1: function(_, value) { |
| return typeof value === "string" && this._element.classList.contains(value); |
| }, |
| add$1: function(_, value) { |
| var list, t1; |
| list = this._element.classList; |
| t1 = list.contains(value); |
| list.add(value); |
| return !t1; |
| }, |
| remove$1: function(_, value) { |
| var list, removed, t1; |
| list = this._element.classList; |
| removed = list.contains(value); |
| list.remove(value); |
| t1 = removed; |
| return t1; |
| }, |
| toggle$2: function(_, value, shouldAdd) { |
| return this._element.classList.toggle(value); |
| }, |
| toggle$1: function($receiver, value) { |
| return this.toggle$2($receiver, value, null); |
| } |
| }, |
| _EventStream: { |
| "^": "Stream;_target,_eventType,_useCapture", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| var t1 = new W._EventStreamSubscription(0, this._target, this._eventType, W._wrapZone(onData), this._useCapture); |
| t1.$builtinTypeInfo = this.$builtinTypeInfo; |
| t1._tryResume$0(); |
| return t1; |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| } |
| }, |
| _ElementEventStreamImpl: { |
| "^": "_EventStream;_target,_eventType,_useCapture" |
| }, |
| _EventStreamSubscription: { |
| "^": "StreamSubscription;_pauseCount,_target,_eventType,_onData,_useCapture", |
| cancel$0: function() { |
| if (this._target == null) |
| return; |
| this._unlisten$0(); |
| this._target = null; |
| this._onData = null; |
| return; |
| }, |
| pause$1: function(_, resumeSignal) { |
| if (this._target == null) |
| return; |
| ++this._pauseCount; |
| this._unlisten$0(); |
| }, |
| pause$0: function($receiver) { |
| return this.pause$1($receiver, null); |
| }, |
| resume$0: function() { |
| if (this._target == null || this._pauseCount <= 0) |
| return; |
| --this._pauseCount; |
| this._tryResume$0(); |
| }, |
| _tryResume$0: function() { |
| var t1, t2, t3; |
| t1 = this._onData; |
| t2 = t1 != null; |
| if (t2 && this._pauseCount <= 0) { |
| t3 = this._target; |
| t3.toString; |
| if (t2) |
| J._addEventListener$3$x(t3, this._eventType, t1, this._useCapture); |
| } |
| }, |
| _unlisten$0: function() { |
| var t1, t2, t3; |
| t1 = this._onData; |
| t2 = t1 != null; |
| if (t2) { |
| t3 = this._target; |
| t3.toString; |
| if (t2) |
| J._removeEventListener$3$x(t3, this._eventType, t1, this._useCapture); |
| } |
| } |
| }, |
| _Html5NodeValidator: { |
| "^": "Object;uriPolicy<", |
| allowsElement$1: function(element) { |
| return $.$get$_Html5NodeValidator__allowedElements().contains$1(0, J.get$tagName$x(element)); |
| }, |
| allowsAttribute$3: function(element, attributeName, value) { |
| var tagName, t1, validator; |
| tagName = J.get$tagName$x(element); |
| t1 = $.$get$_Html5NodeValidator__attributeValidators(); |
| validator = t1.$index(0, H.S(tagName) + "::" + attributeName); |
| if (validator == null) |
| validator = t1.$index(0, "*::" + attributeName); |
| if (validator == null) |
| return false; |
| return validator.call$4(element, attributeName, value, this); |
| }, |
| _Html5NodeValidator$1$uriPolicy: function(uriPolicy) { |
| var t1, _i; |
| t1 = $.$get$_Html5NodeValidator__attributeValidators(); |
| if (t1.get$isEmpty(t1)) { |
| for (_i = 0; _i < 261; ++_i) |
| t1.$indexSet(0, C.List_1GN[_i], W.html__Html5NodeValidator__standardAttributeValidator$closure()); |
| for (_i = 0; _i < 12; ++_i) |
| t1.$indexSet(0, C.List_yrN[_i], W.html__Html5NodeValidator__uriAttributeValidator$closure()); |
| } |
| }, |
| $isNodeValidator: 1, |
| static: {_Html5NodeValidator$: function(uriPolicy) { |
| var t1 = new W._Html5NodeValidator(new W._SameOriginUriPolicy(W.AnchorElement_AnchorElement(null), window.location)); |
| t1._Html5NodeValidator$1$uriPolicy(uriPolicy); |
| return t1; |
| }, _Html5NodeValidator__standardAttributeValidator: [function(element, attributeName, value, context) { |
| return true; |
| }, "call$4", "html__Html5NodeValidator__standardAttributeValidator$closure", 8, 0, 10], _Html5NodeValidator__uriAttributeValidator: [function(element, attributeName, value, context) { |
| return context.get$uriPolicy().allowsUri$1(value); |
| }, "call$4", "html__Html5NodeValidator__uriAttributeValidator$closure", 8, 0, 10]} |
| }, |
| ImmutableListMixin: { |
| "^": "Object;", |
| get$iterator: function(receiver) { |
| return H.setRuntimeTypeInfo(new W.FixedSizeListIterator(receiver, this.get$length(receiver), -1, null), [H.getRuntimeTypeArgument(receiver, "ImmutableListMixin", 0)]); |
| }, |
| add$1: function(receiver, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot add to immutable List.")); |
| }, |
| $isList: 1, |
| $asList: null, |
| $isEfficientLength: 1 |
| }, |
| NodeValidatorBuilder: { |
| "^": "Object;_validators", |
| add$1: function(_, validator) { |
| this._validators.push(validator); |
| }, |
| allowsElement$1: function(element) { |
| return C.JSArray_methods.any$1(this._validators, new W.NodeValidatorBuilder_allowsElement_closure(element)); |
| }, |
| allowsAttribute$3: function(element, attributeName, value) { |
| return C.JSArray_methods.any$1(this._validators, new W.NodeValidatorBuilder_allowsAttribute_closure(element, attributeName, value)); |
| } |
| }, |
| NodeValidatorBuilder_allowsElement_closure: { |
| "^": "Closure:0;_captured_element_0", |
| call$1: function(v) { |
| return v.allowsElement$1(this._captured_element_0); |
| } |
| }, |
| NodeValidatorBuilder_allowsAttribute_closure: { |
| "^": "Closure:0;_captured_element_0,_captured_attributeName_1,_captured_value_2", |
| call$1: function(v) { |
| return v.allowsAttribute$3(this._captured_element_0, this._captured_attributeName_1, this._captured_value_2); |
| } |
| }, |
| _SimpleNodeValidator: { |
| "^": "Object;allowedElements,allowedAttributes,allowedUriAttributes,uriPolicy<", |
| allowsElement$1: function(element) { |
| return this.allowedElements.contains$1(0, J.get$tagName$x(element)); |
| }, |
| allowsAttribute$3: ["super$_SimpleNodeValidator$allowsAttribute", function(element, attributeName, value) { |
| var tagName, t1; |
| tagName = J.get$tagName$x(element); |
| t1 = this.allowedUriAttributes; |
| if (t1.contains$1(0, H.S(tagName) + "::" + attributeName)) |
| return this.uriPolicy.allowsUri$1(value); |
| else if (t1.contains$1(0, "*::" + attributeName)) |
| return this.uriPolicy.allowsUri$1(value); |
| else { |
| t1 = this.allowedAttributes; |
| if (t1.contains$1(0, H.S(tagName) + "::" + attributeName)) |
| return true; |
| else if (t1.contains$1(0, "*::" + attributeName)) |
| return true; |
| else if (t1.contains$1(0, H.S(tagName) + "::*")) |
| return true; |
| else if (t1.contains$1(0, "*::*")) |
| return true; |
| } |
| return false; |
| }], |
| _SimpleNodeValidator$4$allowedAttributes$allowedElements$allowedUriAttributes: function(uriPolicy, allowedAttributes, allowedElements, allowedUriAttributes) { |
| var t1, legalAttributes, extraUriAttributes; |
| this.allowedElements.addAll$1(0, allowedElements); |
| if (allowedUriAttributes == null) |
| allowedUriAttributes = C.List_empty; |
| t1 = J.getInterceptor$ax(allowedAttributes); |
| legalAttributes = t1.where$1(allowedAttributes, new W._SimpleNodeValidator_closure()); |
| extraUriAttributes = t1.where$1(allowedAttributes, new W._SimpleNodeValidator_closure0()); |
| this.allowedAttributes.addAll$1(0, legalAttributes); |
| t1 = this.allowedUriAttributes; |
| t1.addAll$1(0, allowedUriAttributes); |
| t1.addAll$1(0, extraUriAttributes); |
| }, |
| static: {_SimpleNodeValidator$: function(uriPolicy, allowedAttributes, allowedElements, allowedUriAttributes) { |
| var t1 = new W._SimpleNodeValidator(P.LinkedHashSet_LinkedHashSet(null, null, null, P.String), P.LinkedHashSet_LinkedHashSet(null, null, null, P.String), P.LinkedHashSet_LinkedHashSet(null, null, null, P.String), uriPolicy); |
| t1._SimpleNodeValidator$4$allowedAttributes$allowedElements$allowedUriAttributes(uriPolicy, allowedAttributes, allowedElements, allowedUriAttributes); |
| return t1; |
| }} |
| }, |
| _SimpleNodeValidator_closure: { |
| "^": "Closure:0;", |
| call$1: function(x) { |
| return !C.JSArray_methods.contains$1(C.List_yrN, x); |
| } |
| }, |
| _SimpleNodeValidator_closure0: { |
| "^": "Closure:0;", |
| call$1: function(x) { |
| return C.JSArray_methods.contains$1(C.List_yrN, x); |
| } |
| }, |
| _TemplatingNodeValidator: { |
| "^": "_SimpleNodeValidator;_templateAttrs,allowedElements,allowedAttributes,allowedUriAttributes,uriPolicy", |
| allowsAttribute$3: function(element, attributeName, value) { |
| if (this.super$_SimpleNodeValidator$allowsAttribute(element, attributeName, value)) |
| return true; |
| if (attributeName === "template" && value === "") |
| return true; |
| if (J.get$attributes$x(element)._element.getAttribute("template") === "") |
| return this._templateAttrs.contains$1(0, attributeName); |
| return false; |
| }, |
| static: {_TemplatingNodeValidator$: function() { |
| var t1, t2, t3, t4; |
| t1 = H.setRuntimeTypeInfo(new H.MappedListIterable(C.List_wSV, new W._TemplatingNodeValidator_closure()), [null, null]); |
| t2 = P.LinkedHashSet_LinkedHashSet(null, null, null, P.String); |
| t3 = P.LinkedHashSet_LinkedHashSet(null, null, null, P.String); |
| t4 = P.LinkedHashSet_LinkedHashSet(null, null, null, P.String); |
| t4 = new W._TemplatingNodeValidator(P.LinkedHashSet_LinkedHashSet$from(C.List_wSV, P.String), t2, t3, t4, null); |
| t4._SimpleNodeValidator$4$allowedAttributes$allowedElements$allowedUriAttributes(null, t1, ["TEMPLATE"], null); |
| return t4; |
| }} |
| }, |
| _TemplatingNodeValidator_closure: { |
| "^": "Closure:0;", |
| call$1: function(attr) { |
| return "TEMPLATE::" + H.S(attr); |
| } |
| }, |
| FixedSizeListIterator: { |
| "^": "Object;_array,_length,_position,_current", |
| moveNext$0: function() { |
| var nextPosition, t1; |
| nextPosition = this._position + 1; |
| t1 = this._length; |
| if (nextPosition < t1) { |
| this._current = J.$index$asx(this._array, nextPosition); |
| this._position = nextPosition; |
| return true; |
| } |
| this._current = null; |
| this._position = t1; |
| return false; |
| }, |
| get$current: function() { |
| return this._current; |
| } |
| }, |
| _DOMWindowCrossFrame: { |
| "^": "Object;_window", |
| $isEventTarget: 1, |
| $isInterceptor: 1, |
| static: {_DOMWindowCrossFrame__createSafe: function(w) { |
| if (w === window) |
| return w; |
| else |
| return new W._DOMWindowCrossFrame(w); |
| }} |
| }, |
| NodeValidator: { |
| "^": "Object;" |
| }, |
| _SameOriginUriPolicy: { |
| "^": "Object;_hiddenAnchor,_loc", |
| allowsUri$1: function(uri) { |
| var t1, t2, t3, t4, t5; |
| t1 = this._hiddenAnchor; |
| t2 = J.getInterceptor$x(t1); |
| t2.set$href(t1, uri); |
| t3 = t2.get$hostname(t1); |
| t4 = this._loc; |
| t5 = t4.hostname; |
| if (t3 == null ? t5 == null : t3 === t5) { |
| t3 = t2.get$port(t1); |
| t5 = t4.port; |
| if (t3 == null ? t5 == null : t3 === t5) { |
| t3 = t2.get$protocol(t1); |
| t4 = t4.protocol; |
| t4 = t3 == null ? t4 == null : t3 === t4; |
| t3 = t4; |
| } else |
| t3 = false; |
| } else |
| t3 = false; |
| if (!t3) |
| if (t2.get$hostname(t1) === "") |
| if (t2.get$port(t1) === "") |
| t1 = t2.get$protocol(t1) === ":" || t2.get$protocol(t1) === ""; |
| else |
| t1 = false; |
| else |
| t1 = false; |
| else |
| t1 = true; |
| return t1; |
| } |
| }, |
| _ValidatingTreeSanitizer: { |
| "^": "Object;validator", |
| sanitizeTree$1: function(node) { |
| new W._ValidatingTreeSanitizer_sanitizeTree_walk(this).call$2(node, null); |
| }, |
| _removeNode$2: function(node, $parent) { |
| if ($parent == null) |
| J.remove$0$ax(node); |
| else |
| $parent.removeChild(node); |
| }, |
| _sanitizeUntrustedElement$2: function(element, $parent) { |
| var corrupted, attrs, isAttr, elementText, elementTagName, exception; |
| corrupted = true; |
| attrs = null; |
| isAttr = null; |
| try { |
| attrs = J.get$attributes$x(element); |
| isAttr = attrs.get$_element().getAttribute("is"); |
| corrupted = function(element) { |
| if (!(element.attributes instanceof NamedNodeMap)) |
| return true; |
| var childNodes = element.childNodes; |
| if (element.lastChild && element.lastChild !== childNodes[childNodes.length - 1]) |
| return true; |
| if (element.children) |
| if (!(element.children instanceof HTMLCollection || element.children instanceof NodeList)) |
| return true; |
| return false; |
| }(element); |
| } catch (exception) { |
| H.unwrapException(exception); |
| } |
| elementText = "element unprintable"; |
| try { |
| elementText = J.toString$0$(element); |
| } catch (exception) { |
| H.unwrapException(exception); |
| } |
| elementTagName = "element tag unavailable"; |
| try { |
| elementTagName = J.get$tagName$x(element); |
| } catch (exception) { |
| H.unwrapException(exception); |
| } |
| this._sanitizeElement$7(element, $parent, corrupted, elementText, elementTagName, attrs, isAttr); |
| }, |
| _sanitizeElement$7: function(element, $parent, corrupted, text, tag, attrs, isAttr) { |
| var t1, keys, i, $name, t2; |
| if (corrupted) { |
| window; |
| t1 = "Removing element due to corrupted attributes on <" + text + ">"; |
| if (typeof console != "undefined") |
| console.warn(t1); |
| this._removeNode$2(element, $parent); |
| return; |
| } |
| if (!this.validator.allowsElement$1(element)) { |
| window; |
| t1 = "Removing disallowed element <" + H.S(tag) + ">"; |
| if (typeof console != "undefined") |
| console.warn(t1); |
| this._removeNode$2(element, $parent); |
| return; |
| } |
| if (isAttr != null) |
| if (!this.validator.allowsAttribute$3(element, "is", isAttr)) { |
| window; |
| t1 = "Removing disallowed type extension <" + H.S(tag) + " is=\"" + isAttr + "\">"; |
| if (typeof console != "undefined") |
| console.warn(t1); |
| this._removeNode$2(element, $parent); |
| return; |
| } |
| t1 = attrs.get$keys(); |
| keys = H.setRuntimeTypeInfo(t1.slice(), [H.getTypeArgumentByIndex(t1, 0)]); |
| for (i = attrs.get$keys().length - 1, t1 = attrs._element; i >= 0; --i) { |
| if (i >= keys.length) |
| return H.ioore(keys, i); |
| $name = keys[i]; |
| if (!this.validator.allowsAttribute$3(element, J.toLowerCase$0$s($name), t1.getAttribute($name))) { |
| window; |
| t2 = "Removing disallowed attribute <" + H.S(tag) + " " + $name + "=\"" + H.S(t1.getAttribute($name)) + "\">"; |
| if (typeof console != "undefined") |
| console.warn(t2); |
| t1.getAttribute($name); |
| t1.removeAttribute($name); |
| } |
| } |
| if (!!J.getInterceptor(element).$isTemplateElement) |
| this.sanitizeTree$1(element.content); |
| } |
| }, |
| _ValidatingTreeSanitizer_sanitizeTree_walk: { |
| "^": "Closure:27;_html$_captured_this_0", |
| call$2: function(node, $parent) { |
| var t1, child, nextChild; |
| t1 = this._html$_captured_this_0; |
| switch (node.nodeType) { |
| case 1: |
| t1._sanitizeUntrustedElement$2(node, $parent); |
| break; |
| case 8: |
| case 11: |
| case 3: |
| case 4: |
| break; |
| default: |
| t1._removeNode$2(node, $parent); |
| } |
| child = node.lastChild; |
| for (; child != null; child = nextChild) { |
| nextChild = child.previousSibling; |
| this.call$2(child, node); |
| } |
| } |
| } |
| }], ["dart.dom.indexed_db", "dart:indexed_db",, P, { |
| "^": "" |
| }], ["dart.dom.svg", "dart:svg",, P, { |
| "^": "", |
| AElement: { |
| "^": "GraphicsElement;target=", |
| $isInterceptor: 1, |
| "%": "SVGAElement" |
| }, |
| AltGlyphElement: { |
| "^": "TextPositioningElement;", |
| $isInterceptor: 1, |
| "%": "SVGAltGlyphElement" |
| }, |
| AnimationElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGAnimateElement|SVGAnimateMotionElement|SVGAnimateTransformElement|SVGAnimationElement|SVGSetElement" |
| }, |
| FEBlendElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEBlendElement" |
| }, |
| FEColorMatrixElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEColorMatrixElement" |
| }, |
| FEComponentTransferElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEComponentTransferElement" |
| }, |
| FECompositeElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFECompositeElement" |
| }, |
| FEConvolveMatrixElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEConvolveMatrixElement" |
| }, |
| FEDiffuseLightingElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEDiffuseLightingElement" |
| }, |
| FEDisplacementMapElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEDisplacementMapElement" |
| }, |
| FEFloodElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEFloodElement" |
| }, |
| FEGaussianBlurElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEGaussianBlurElement" |
| }, |
| FEImageElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEImageElement" |
| }, |
| FEMergeElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEMergeElement" |
| }, |
| FEMorphologyElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEMorphologyElement" |
| }, |
| FEOffsetElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEOffsetElement" |
| }, |
| FESpecularLightingElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFESpecularLightingElement" |
| }, |
| FETileElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFETileElement" |
| }, |
| FETurbulenceElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFETurbulenceElement" |
| }, |
| FilterElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFilterElement" |
| }, |
| GraphicsElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGCircleElement|SVGClipPathElement|SVGDefsElement|SVGEllipseElement|SVGForeignObjectElement|SVGGElement|SVGGeometryElement|SVGLineElement|SVGPathElement|SVGPolygonElement|SVGPolylineElement|SVGRectElement|SVGSwitchElement;SVGGraphicsElement" |
| }, |
| ImageElement0: { |
| "^": "GraphicsElement;", |
| $isInterceptor: 1, |
| "%": "SVGImageElement" |
| }, |
| MarkerElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMarkerElement" |
| }, |
| MaskElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMaskElement" |
| }, |
| PatternElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGPatternElement" |
| }, |
| ScriptElement0: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGScriptElement" |
| }, |
| _AttributeClassSet: { |
| "^": "CssClassSetImpl;_svg$_element", |
| readClasses$0: function() { |
| var classname, s, t1, t2, _i, trimmed; |
| classname = this._svg$_element.getAttribute("class"); |
| s = P.LinkedHashSet_LinkedHashSet(null, null, null, P.String); |
| if (classname == null) |
| return s; |
| for (t1 = classname.split(" "), t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| trimmed = J.trim$0$s(t1[_i]); |
| if (trimmed.length !== 0) |
| s.add$1(0, trimmed); |
| } |
| return s; |
| }, |
| writeClasses$1: function(s) { |
| this._svg$_element.setAttribute("class", s.join$1(0, " ")); |
| } |
| }, |
| SvgElement: { |
| "^": "Element;", |
| get$classes: function(receiver) { |
| return new P._AttributeClassSet(receiver); |
| }, |
| get$onClick: function(receiver) { |
| return H.setRuntimeTypeInfo(new W._ElementEventStreamImpl(receiver, "click", false), [null]); |
| }, |
| $isEventTarget: 1, |
| $isInterceptor: 1, |
| "%": "SVGAltGlyphDefElement|SVGAltGlyphItemElement|SVGComponentTransferFunctionElement|SVGDescElement|SVGDiscardElement|SVGFEDistantLightElement|SVGFEFuncAElement|SVGFEFuncBElement|SVGFEFuncGElement|SVGFEFuncRElement|SVGFEMergeNodeElement|SVGFEPointLightElement|SVGFESpotLightElement|SVGFontElement|SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement|SVGGlyphElement|SVGHKernElement|SVGMetadataElement|SVGMissingGlyphElement|SVGStopElement|SVGStyleElement|SVGTitleElement|SVGVKernElement;SVGElement" |
| }, |
| SvgSvgElement: { |
| "^": "GraphicsElement;", |
| $isInterceptor: 1, |
| "%": "SVGSVGElement" |
| }, |
| SymbolElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGSymbolElement" |
| }, |
| TextContentElement: { |
| "^": "GraphicsElement;", |
| "%": ";SVGTextContentElement" |
| }, |
| TextPathElement: { |
| "^": "TextContentElement;", |
| $isInterceptor: 1, |
| "%": "SVGTextPathElement" |
| }, |
| TextPositioningElement: { |
| "^": "TextContentElement;", |
| "%": "SVGTSpanElement|SVGTextElement;SVGTextPositioningElement" |
| }, |
| UseElement: { |
| "^": "GraphicsElement;", |
| $isInterceptor: 1, |
| "%": "SVGUseElement" |
| }, |
| ViewElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGViewElement" |
| }, |
| _GradientElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGGradientElement|SVGLinearGradientElement|SVGRadialGradientElement" |
| }, |
| _SVGCursorElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGCursorElement" |
| }, |
| _SVGFEDropShadowElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGFEDropShadowElement" |
| }, |
| _SVGGlyphRefElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGGlyphRefElement" |
| }, |
| _SVGMPathElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMPathElement" |
| } |
| }], ["dart.dom.web_audio", "dart:web_audio",, P, { |
| "^": "" |
| }], ["dart.dom.web_gl", "dart:web_gl",, P, { |
| "^": "" |
| }], ["dart.dom.web_sql", "dart:web_sql",, P, { |
| "^": "", |
| SqlError: { |
| "^": "Interceptor;message=", |
| "%": "SQLError" |
| } |
| }], ["dart.isolate", "dart:isolate",, P, { |
| "^": "", |
| Capability: { |
| "^": "Object;" |
| } |
| }], ["dart.math", "dart:math",, P, { |
| "^": "", |
| _JenkinsSmiHash_combine0: function(hash, value) { |
| hash = 536870911 & hash + value; |
| hash = 536870911 & hash + ((524287 & hash) << 10 >>> 0); |
| return hash ^ hash >>> 6; |
| }, |
| _JenkinsSmiHash_finish0: function(hash) { |
| hash = 536870911 & hash + ((67108863 & hash) << 3 >>> 0); |
| hash ^= hash >>> 11; |
| return 536870911 & hash + ((16383 & hash) << 15 >>> 0); |
| }, |
| min: function(a, b) { |
| if (typeof a !== "number") |
| throw H.wrapException(P.ArgumentError$(a)); |
| if (typeof b !== "number") |
| throw H.wrapException(P.ArgumentError$(b)); |
| if (a > b) |
| return b; |
| if (a < b) |
| return a; |
| if (typeof b === "number") { |
| if (typeof a === "number") |
| if (a === 0) |
| return (a + b) * a * b; |
| if (a === 0 && C.JSDouble_methods.get$isNegative(b) || C.JSDouble_methods.get$isNaN(b)) |
| return b; |
| return a; |
| } |
| return a; |
| }, |
| max: function(a, b) { |
| if (a > b) |
| return a; |
| if (a < b) |
| return b; |
| if (typeof b === "number") { |
| if (typeof a === "number") |
| if (a === 0) |
| return a + b; |
| if (isNaN(b)) |
| return b; |
| return a; |
| } |
| if (b === 0 && C.JSNumber_methods.get$isNegative(a)) |
| return b; |
| return a; |
| } |
| }], ["dart.typed_data.implementation", "dart:_native_typed_data",, H, { |
| "^": "", |
| _checkValidRange: function(start, end, $length) { |
| var t1; |
| if (!(start >>> 0 !== start)) |
| t1 = end >>> 0 !== end || start > end || end > $length; |
| else |
| t1 = true; |
| if (t1) |
| throw H.wrapException(H.diagnoseRangeError(start, end, $length)); |
| return end; |
| }, |
| NativeByteBuffer: { |
| "^": "Interceptor;", |
| $isNativeByteBuffer: 1, |
| "%": "ArrayBuffer" |
| }, |
| NativeTypedData: { |
| "^": "Interceptor;", |
| $isNativeTypedData: 1, |
| "%": "DataView;ArrayBufferView;NativeTypedArray|NativeTypedArray_ListMixin|NativeTypedArray_ListMixin_FixedLengthListMixin|NativeTypedArrayOfDouble|NativeTypedArray_ListMixin0|NativeTypedArray_ListMixin_FixedLengthListMixin0|NativeTypedArrayOfInt" |
| }, |
| NativeTypedArray: { |
| "^": "NativeTypedData;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| $isJavaScriptIndexingBehavior: 1, |
| $isJSIndexable: 1 |
| }, |
| NativeTypedArrayOfDouble: { |
| "^": "NativeTypedArray_ListMixin_FixedLengthListMixin;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $indexSet: function(receiver, index, value) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| receiver[index] = value; |
| } |
| }, |
| NativeTypedArray_ListMixin: { |
| "^": "NativeTypedArray+ListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [P.$double]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| NativeTypedArray_ListMixin_FixedLengthListMixin: { |
| "^": "NativeTypedArray_ListMixin+FixedLengthListMixin;" |
| }, |
| NativeTypedArrayOfInt: { |
| "^": "NativeTypedArray_ListMixin_FixedLengthListMixin0;", |
| $indexSet: function(receiver, index, value) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| receiver[index] = value; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| NativeTypedArray_ListMixin0: { |
| "^": "NativeTypedArray+ListMixin;", |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1 |
| }, |
| NativeTypedArray_ListMixin_FixedLengthListMixin0: { |
| "^": "NativeTypedArray_ListMixin0+FixedLengthListMixin;" |
| }, |
| NativeFloat32List: { |
| "^": "NativeTypedArrayOfDouble;", |
| $isList: 1, |
| $asList: function() { |
| return [P.$double]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Float32Array" |
| }, |
| NativeFloat64List: { |
| "^": "NativeTypedArrayOfDouble;", |
| $isList: 1, |
| $asList: function() { |
| return [P.$double]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Float64Array" |
| }, |
| NativeInt16List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Int16Array" |
| }, |
| NativeInt32List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Int32Array" |
| }, |
| NativeInt8List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Int8Array" |
| }, |
| NativeUint16List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Uint16Array" |
| }, |
| NativeUint32List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "Uint32Array" |
| }, |
| NativeUint8ClampedList: { |
| "^": "NativeTypedArrayOfInt;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": "CanvasPixelArray|Uint8ClampedArray" |
| }, |
| NativeUint8List: { |
| "^": "NativeTypedArrayOfInt;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.$int]; |
| }, |
| $isEfficientLength: 1, |
| "%": ";Uint8Array" |
| } |
| }], ["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); |
| } |
| }], ["dev_compiler.messages", "messages_widget.dart",, K, { |
| "^": "", |
| main: [function() { |
| var $async$goto = 0, $async$completer = new P.Completer_Completer$sync(), $async$handler = 1, $async$currentError, $async$temp1, $async$temp2; |
| var $async$main = P._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { |
| if ($async$errorCode === 1) { |
| $async$currentError = $async$result; |
| $async$goto = $async$handler; |
| } |
| while (true) |
| switch ($async$goto) { |
| case 0: |
| // Function start |
| $async$temp1 = C; |
| $async$temp1 = $async$temp1.Window_methods; |
| $async$goto = 2; |
| return P._asyncHelper($async$temp1.get$animationFrame(window), $async$main, $async$completer); |
| case 2: |
| // returning from await. |
| $async$temp1 = K; |
| $async$temp1 = $async$temp1; |
| $async$temp2 = W; |
| $async$goto = 3; |
| return P._asyncHelper($async$temp2.HttpRequest_getString("messages.json", null, null), $async$main, $async$completer); |
| case 3: |
| // returning from await. |
| $async$temp1.displayMessages($async$result); |
| // implicit return |
| return P._asyncHelper(null, 0, $async$completer, null); |
| case 1: |
| // rethrow |
| return P._asyncHelper($async$currentError, 1, $async$completer); |
| } |
| }); |
| return P._asyncHelper(null, $async$main, $async$completer, null); |
| }, "call$0", "messages__main$closure", 0, 0, 1], |
| displayMessages: function(data) { |
| var summary, t1, menuWrapper, contentWrapper, wrapperDiv; |
| summary = X.GlobalSummary_parse(C.JsonCodec_null_null.decode$1(data)); |
| t1 = P.LinkedHashMap__makeEmpty(); |
| new K._Visitor(t1).visitGlobal$1(summary); |
| if (t1.get$isEmpty(t1)) |
| return; |
| menuWrapper = document.createElement("div", null); |
| J.get$classes$x(menuWrapper).add$1(0, "menu"); |
| contentWrapper = document.createElement("div", null); |
| J.get$classes$x(contentWrapper).add$1(0, "content"); |
| wrapperDiv = document.createElement("div", null); |
| J.get$classes$x(wrapperDiv).add$1(0, "dev-compiler-messages"); |
| wrapperDiv.appendChild(menuWrapper); |
| wrapperDiv.appendChild(contentWrapper); |
| t1.forEach$1(0, new K.displayMessages_closure(menuWrapper, contentWrapper, new K._Selection(null), new K._Selection(null))); |
| document.body.appendChild(wrapperDiv); |
| }, |
| _hyperlinkUrls: function(text) { |
| return J.replaceAllMapped$2$s(text, $.$get$_urlRegex(), new K._hyperlinkUrls_closure()); |
| }, |
| displayMessages_closure: { |
| "^": "Closure:3;_captured_menuWrapper_0,_captured_contentWrapper_1,_captured_selectedMenu_2,_captured_selectedContent_3", |
| call$2: function(level, messages) { |
| var contentItem, t1, menuItem, t2, m, t3, t4, val, message, span, t5, source, t6, t7, logElement, messageElement; |
| contentItem = document.createElement("div", null); |
| J.get$classes$x(contentItem).add$1(0, level); |
| t1 = J.getInterceptor$asx(messages); |
| menuItem = W.Element_Element$html("<div class=\"" + H.S(level) + "\">" + H.S(level) + " <span class=\"num\">(" + H.S(t1.get$length(messages)) + ")</span></div>", null, null); |
| this._captured_menuWrapper_0.appendChild(menuItem); |
| this._captured_contentWrapper_1.appendChild(contentItem); |
| t2 = J.get$onClick$x(menuItem); |
| H.setRuntimeTypeInfo(new W._EventStreamSubscription(0, t2._target, t2._eventType, W._wrapZone(new K.displayMessages__closure(this._captured_selectedMenu_2, this._captured_selectedContent_3, contentItem, menuItem)), t2._useCapture), [H.getTypeArgumentByIndex(t2, 0)])._tryResume$0(); |
| for (t1 = t1.get$iterator(messages); t1.moveNext$0();) { |
| m = t1.get$current(); |
| t2 = J.getInterceptor$x(m); |
| t3 = t2.get$message(m); |
| t4 = $.$get$_escaper(); |
| t4.toString; |
| val = t4._convert$3(t3, 0, J.get$length$asx(t3)); |
| message = K._hyperlinkUrls(val == null ? t3 : val); |
| span = t2.get$span(m); |
| t2 = "<div class=\"message\"><div class=\"text " + H.S(level) + "\">" + message + "</div>"; |
| if (span != null) { |
| t3 = J.getInterceptor$x(span); |
| t5 = t3.get$start(span); |
| source = t5.sourceUrl; |
| t2 += "<div class=\"location\"> <span class=\"location\">" + (H.S(source == null ? "unknown source" : source) + ":" + H.S(J.$add$ns(t5.line, 1)) + ":" + H.S(J.$add$ns(t5.column, 1))) + "</span></div> <span class=\"text\">"; |
| if (!!t3.$isSourceSpanWithContext) { |
| t3 = span.context; |
| t5 = span.start.column; |
| t6 = J.getInterceptor$s(t3).substring$2(t3, 0, t5); |
| val = t4._convert$3(t6, 0, t6.length); |
| t2 = t2 + H.S(val == null ? t6 : val) + ("<span class=\"" + H.S(level) + "\">"); |
| t6 = span.text; |
| t7 = J.getInterceptor$asx(t6); |
| val = t4._convert$3(t6, 0, t7.get$length(t6)); |
| t2 = t2 + H.S(val == null ? t6 : val) + "</span>"; |
| t6 = C.JSString_methods.substring$1(t3, J.$add$ns(t5, t7.get$length(t6))); |
| val = t4._convert$3(t6, 0, t6.length); |
| t2 += H.S(val == null ? t6 : val); |
| } else { |
| t3 = span.text; |
| val = t4._convert$3(t3, 0, J.get$length$asx(t3)); |
| t2 += H.S(val == null ? t3 : val); |
| } |
| t2 += "</span></div></div>"; |
| } |
| t2 += "</div>"; |
| t2 = t2.charCodeAt(0) == 0 ? t2 : t2; |
| t3 = []; |
| t3.$builtinTypeInfo = [W.NodeValidator]; |
| t3.push(W._Html5NodeValidator$(null)); |
| t3.push(W._TemplatingNodeValidator$()); |
| t3.push(W._SimpleNodeValidator$(new K._OpenUriPolicy(), C.List_h4r, C.List_A_FORM, C.List_BSc)); |
| logElement = W.Element_Element$html(t2, null, new W.NodeValidatorBuilder(t3)); |
| contentItem.appendChild(logElement); |
| messageElement = J.querySelector$1$x(logElement, "div.text"); |
| t2 = J.get$onClick$x(messageElement); |
| t3 = t2._eventType; |
| t4 = t2._useCapture; |
| t5 = new W._EventStreamSubscription(0, t2._target, t3, W._wrapZone(new K.displayMessages__closure0(messageElement)), t4); |
| t5.$builtinTypeInfo = [H.getTypeArgumentByIndex(t2, 0)]; |
| t2 = t5._onData; |
| t6 = t2 != null; |
| if (t6 && t5._pauseCount <= 0) { |
| t5 = t5._target; |
| t5.toString; |
| if (t6) |
| J._addEventListener$3$x(t5, t3, t2, t4); |
| } |
| } |
| } |
| }, |
| displayMessages__closure: { |
| "^": "Closure:0;_captured_selectedMenu_4,_captured_selectedContent_5,_captured_contentItem_6,_captured_menuItem_7", |
| call$1: function(_) { |
| this._captured_selectedMenu_4.select$1(0, this._captured_menuItem_7); |
| this._captured_selectedContent_5.select$1(0, this._captured_contentItem_6); |
| } |
| }, |
| displayMessages__closure0: { |
| "^": "Closure:0;_captured_messageElement_8", |
| call$1: function(e) { |
| var t1 = this._captured_messageElement_8; |
| if (J.$eq$(J.get$target$x(e), t1)) |
| J.get$classes$x(t1).toggle$1(0, "expanded"); |
| } |
| }, |
| _Selection: { |
| "^": "Object;_selected", |
| select$1: function(_, newItem) { |
| var t1 = this._selected; |
| if (t1 == null ? newItem == null : t1 === newItem) |
| this._selected = null; |
| else { |
| if (t1 != null) |
| J.get$classes$x(t1).remove$1(0, "active"); |
| this._selected = newItem; |
| } |
| J.get$classes$x(newItem).toggle$1(0, "active"); |
| } |
| }, |
| _hyperlinkUrls_closure: { |
| "^": "Closure:0;", |
| call$1: function(m) { |
| return "<a href=\"" + H.S(m.group$1(0)) + "\" target=\"blank\">" + H.S(m.group$1(0)) + "</a>"; |
| } |
| }, |
| _OpenUriPolicy: { |
| "^": "Object;", |
| allowsUri$1: function(uri) { |
| return true; |
| } |
| }, |
| _Visitor: { |
| "^": "RecursiveSummaryVisitor;messagesByLevel", |
| visitMessage$1: function(message) { |
| var level, t1; |
| level = J.toLowerCase$0$s(message.level); |
| t1 = this.messagesByLevel; |
| t1.putIfAbsent$2(level, new K._Visitor_visitMessage_closure()); |
| J.add$1$ax(t1.$index(0, level), message); |
| } |
| }, |
| _Visitor_visitMessage_closure: { |
| "^": "Closure:1;", |
| call$0: function() { |
| return []; |
| } |
| } |
| }, 1], ["dev_compiler.src.summary", "package:dev_compiler/src/summary.dart",, X, { |
| "^": "", |
| Summary: { |
| "^": "Object;" |
| }, |
| GlobalSummary: { |
| "^": "Object;system,packages,loose", |
| accept$1: function(_, visitor) { |
| return visitor.visitGlobal$1(this); |
| }, |
| static: {GlobalSummary_parse: function(json) { |
| var res, t1; |
| res = new X.GlobalSummary(P.LinkedHashMap_LinkedHashMap$_empty(P.String, X.LibrarySummary), P.LinkedHashMap_LinkedHashMap$_empty(P.String, X.PackageSummary), P.LinkedHashMap_LinkedHashMap$_empty(P.String, X.IndividualSummary)); |
| t1 = J.getInterceptor$asx(json); |
| J.map$1$ax(t1.$index(json, "system"), X.summary_LibrarySummary_parse$closure()).forEach$1(0, new X.GlobalSummary_parse_closure(res)); |
| J.map$1$ax(t1.$index(json, "packages"), X.summary_PackageSummary_parse$closure()).forEach$1(0, new X.GlobalSummary_parse_closure0(res)); |
| J.forEach$1$ax(t1.$index(json, "loose"), new X.GlobalSummary_parse_closure1(res)); |
| return res; |
| }} |
| }, |
| GlobalSummary_parse_closure: { |
| "^": "Closure:0;_captured_res_0", |
| call$1: function(l) { |
| this._captured_res_0.system.$indexSet(0, J.get$name$x(l), l); |
| } |
| }, |
| GlobalSummary_parse_closure0: { |
| "^": "Closure:0;_captured_res_1", |
| call$1: function(p) { |
| this._captured_res_1.packages.$indexSet(0, J.get$name$x(p), p); |
| } |
| }, |
| GlobalSummary_parse_closure1: { |
| "^": "Closure:0;_captured_res_2", |
| call$1: function(e) { |
| var t1, summary, t2, t3; |
| t1 = J.getInterceptor$asx(e); |
| if (J.$eq$(t1.$index(e, 0), "LibrarySummary")) |
| summary = X.LibrarySummary_parse(t1.$index(e, 1)); |
| else { |
| t1 = t1.$index(e, 1); |
| t2 = J.getInterceptor$asx(t1); |
| t3 = t2.$index(t1, "name"); |
| t1 = P.List_List$from(J.map$1$ax(t2.$index(t1, "messages"), X.summary_MessageSummary_parse$closure()), true, X.MessageSummary); |
| summary = new X.HtmlSummary(t3, t1); |
| } |
| this._captured_res_2.loose.$indexSet(0, summary.get$name(summary), summary); |
| } |
| }, |
| PackageSummary: { |
| "^": "Object;name>,libraries", |
| accept$1: function(_, visitor) { |
| return visitor.visitPackage$1(this); |
| }, |
| static: {PackageSummary_parse: [function(json) { |
| var t1, res; |
| t1 = J.getInterceptor$asx(json); |
| res = new X.PackageSummary(t1.$index(json, "package_name"), P.LinkedHashMap_LinkedHashMap$_empty(P.String, X.LibrarySummary)); |
| J.map$1$ax(t1.$index(json, "libraries"), X.summary_LibrarySummary_parse$closure()).forEach$1(0, new X.PackageSummary_parse_closure(res)); |
| return res; |
| }, "call$1", "summary_PackageSummary_parse$closure", 2, 0, 29]} |
| }, |
| PackageSummary_parse_closure: { |
| "^": "Closure:0;_captured_res_0", |
| call$1: function(l) { |
| this._captured_res_0.libraries.$indexSet(0, J.get$name$x(l), l); |
| } |
| }, |
| IndividualSummary: { |
| "^": "Summary;" |
| }, |
| LibrarySummary: { |
| "^": "Object;name>,messages,_uris,_lines", |
| accept$1: function(_, visitor) { |
| return visitor.visitLibrary$1(this); |
| }, |
| static: {LibrarySummary_parse: [function(json) { |
| var t1, t2, t3, t4; |
| t1 = J.getInterceptor$asx(json); |
| t2 = t1.$index(json, "library_name"); |
| t3 = P.List_List$from(J.map$1$ax(t1.$index(json, "messages"), X.summary_MessageSummary_parse$closure()), true, X.MessageSummary); |
| t1 = t1.$index(json, "lines"); |
| t4 = P.HashSet_HashSet(null, null, null, P.Uri); |
| return new X.LibrarySummary(t2, t3, t4, t1 != null ? t1 : 0); |
| }, "call$1", "summary_LibrarySummary_parse$closure", 2, 0, 30]} |
| }, |
| HtmlSummary: { |
| "^": "Object;name>,messages", |
| accept$1: function(_, visitor) { |
| return visitor.visitHtml$1(this); |
| } |
| }, |
| MessageSummary: { |
| "^": "Object;kind,level,span>,message>", |
| accept$1: function(_, visitor) { |
| return visitor.visitMessage$1(this); |
| }, |
| static: {MessageSummary_parse: [function(json) { |
| var t1, t2, t3, t4, start, end, context, span; |
| t1 = J.getInterceptor$asx(json); |
| t2 = J.$index$asx(t1.$index(json, "start"), 0); |
| t3 = t1.$index(json, "url"); |
| t4 = J.$index$asx(t1.$index(json, "start"), 1); |
| start = O.SourceLocation$(t2, J.$index$asx(t1.$index(json, "start"), 2), t4, t3); |
| t3 = J.$index$asx(t1.$index(json, "end"), 0); |
| t4 = t1.$index(json, "url"); |
| t2 = J.$index$asx(t1.$index(json, "end"), 1); |
| end = O.SourceLocation$(t3, J.$index$asx(t1.$index(json, "end"), 2), t2, t4); |
| context = t1.$index(json, "context"); |
| if (context != null) { |
| t2 = t1.$index(json, "text"); |
| span = new E.SourceSpanWithContext(context, start, end, t2); |
| span.SourceSpanBase$3(start, end, t2); |
| if (J.contains$1$asx(context, t2) !== true) |
| H.throwExpression(P.ArgumentError$("The context line \"" + H.S(context) + "\" must contain \"" + H.S(t2) + "\".")); |
| t3 = start.column; |
| if (D.findLineStart(context, t2, t3) == null) |
| H.throwExpression(P.ArgumentError$("The span text \"" + H.S(t2) + "\" must start at column " + H.S(J.$add$ns(t3, 1)) + " in a line within \"" + H.S(context) + "\".")); |
| } else |
| span = T.SourceSpanBase$(start, end, t1.$index(json, "text")); |
| return new X.MessageSummary(t1.$index(json, "kind"), t1.$index(json, "level"), span, t1.$index(json, "message")); |
| }, "call$1", "summary_MessageSummary_parse$closure", 2, 0, 31]} |
| }, |
| RecursiveSummaryVisitor: { |
| "^": "Object;", |
| visitGlobal$1: function(global) { |
| var t1; |
| for (t1 = global.system, t1 = t1.get$values(t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) |
| J.accept$1$x(t1.get$current(), this); |
| for (t1 = global.packages, t1 = t1.get$values(t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) |
| J.accept$1$x(t1.get$current(), this); |
| for (t1 = global.loose, t1 = t1.get$values(t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) |
| J.accept$1$x(t1.get$current(), this); |
| }, |
| visitPackage$1: function($package) { |
| var t1; |
| for (t1 = $package.libraries, t1 = t1.get$values(t1), t1 = t1.get$iterator(t1); t1.moveNext$0();) |
| J.accept$1$x(t1.get$current(), this); |
| }, |
| visitLibrary$1: function(lib) { |
| var t1, t2, _i; |
| for (t1 = lib.messages, t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) |
| J.accept$1$x(t1[_i], this); |
| }, |
| visitHtml$1: function(html) { |
| var t1, t2, _i; |
| for (t1 = html.messages, t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) |
| J.accept$1$x(t1[_i], this); |
| }, |
| visitMessage$1: function(message) { |
| } |
| } |
| }], ["html_common", "dart:html_common",, P, { |
| "^": "", |
| Device_isOpera: function() { |
| var t1 = $.Device__isOpera; |
| if (t1 == null) { |
| t1 = J.contains$2$asx(window.navigator.userAgent, "Opera", 0); |
| $.Device__isOpera = t1; |
| } |
| return t1; |
| }, |
| Device_isWebKit: function() { |
| var t1 = $.Device__isWebKit; |
| if (t1 == null) { |
| t1 = P.Device_isOpera() !== true && J.contains$2$asx(window.navigator.userAgent, "WebKit", 0); |
| $.Device__isWebKit = t1; |
| } |
| return t1; |
| }, |
| CssClassSetImpl: { |
| "^": "Object;", |
| _validateToken$1: function(value) { |
| if ($.$get$CssClassSetImpl__validTokenRE()._nativeRegExp.test(H.checkString(value))) |
| return value; |
| throw H.wrapException(P.ArgumentError$value(value, "value", "Not a valid class token")); |
| }, |
| toString$0: function(_) { |
| return this.readClasses$0().join$1(0, " "); |
| }, |
| toggle$2: function(_, value, shouldAdd) { |
| var s, result; |
| this._validateToken$1(value); |
| s = this.readClasses$0(); |
| if (!s.contains$1(0, value)) { |
| s.add$1(0, value); |
| result = true; |
| } else { |
| s.remove$1(0, value); |
| result = false; |
| } |
| this.writeClasses$1(s); |
| return result; |
| }, |
| toggle$1: function($receiver, value) { |
| return this.toggle$2($receiver, value, null); |
| }, |
| get$iterator: function(_) { |
| var t1 = this.readClasses$0(); |
| t1 = H.setRuntimeTypeInfo(new P.LinkedHashSetIterator(t1, t1._collection$_modifications, null, null), [null]); |
| t1._cell = t1._set._collection$_first; |
| return t1; |
| }, |
| forEach$1: function(_, f) { |
| this.readClasses$0().forEach$1(0, f); |
| }, |
| map$1: function(_, f) { |
| var t1 = this.readClasses$0(); |
| return H.setRuntimeTypeInfo(new H.EfficientLengthMappedIterable(t1, f), [H.getTypeArgumentByIndex(t1, 0), null]); |
| }, |
| get$isEmpty: function(_) { |
| return this.readClasses$0()._collection$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this.readClasses$0()._collection$_length !== 0; |
| }, |
| get$length: function(_) { |
| return this.readClasses$0()._collection$_length; |
| }, |
| contains$1: function(_, value) { |
| if (typeof value !== "string") |
| return false; |
| this._validateToken$1(value); |
| return this.readClasses$0().contains$1(0, value); |
| }, |
| lookup$1: function(value) { |
| return this.contains$1(0, value) ? value : null; |
| }, |
| add$1: function(_, value) { |
| this._validateToken$1(value); |
| return this.modify$1(new P.CssClassSetImpl_add_closure(value)); |
| }, |
| remove$1: function(_, value) { |
| var s, result; |
| this._validateToken$1(value); |
| s = this.readClasses$0(); |
| result = s.remove$1(0, value); |
| this.writeClasses$1(s); |
| return result; |
| }, |
| get$last: function(_) { |
| var t1 = this.readClasses$0(); |
| return t1.get$last(t1); |
| }, |
| modify$1: function(f) { |
| var s, ret; |
| s = this.readClasses$0(); |
| ret = f.call$1(s); |
| this.writeClasses$1(s); |
| return ret; |
| }, |
| $isEfficientLength: 1 |
| }, |
| CssClassSetImpl_add_closure: { |
| "^": "Closure:0;_captured_value_0", |
| call$1: function(s) { |
| return s.add$1(0, this._captured_value_0); |
| } |
| } |
| }], ["path", "package:path/path.dart",, B, { |
| "^": "", |
| current: function() { |
| var uri, t1, t2, targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, mergedPath, fragment, path; |
| uri = P.Uri_base(); |
| t1 = $.$get$Style_platform(); |
| t2 = $.$get$Style_url(); |
| if (t1 == null ? t2 == null : t1 === t2) { |
| t1 = P.Uri_parse(".", 0, null); |
| targetScheme = t1.scheme; |
| if (targetScheme.length !== 0) { |
| if (t1._host != null) { |
| targetUserInfo = t1._userInfo; |
| targetHost = t1.get$host(t1); |
| targetPort = t1._port != null ? t1.get$port(t1) : null; |
| } else { |
| targetUserInfo = ""; |
| targetHost = null; |
| targetPort = null; |
| } |
| targetPath = P.Uri__removeDotSegments(t1._path); |
| targetQuery = t1._query; |
| if (targetQuery != null) |
| ; |
| else |
| targetQuery = null; |
| } else { |
| targetScheme = uri.scheme; |
| if (t1._host != null) { |
| targetUserInfo = t1._userInfo; |
| targetHost = t1.get$host(t1); |
| targetPort = P.Uri__makePort(t1._port != null ? t1.get$port(t1) : null, targetScheme); |
| targetPath = P.Uri__removeDotSegments(t1._path); |
| targetQuery = t1._query; |
| if (targetQuery != null) |
| ; |
| else |
| targetQuery = null; |
| } else { |
| targetUserInfo = uri._userInfo; |
| targetHost = uri._host; |
| targetPort = uri._port; |
| targetPath = t1._path; |
| if (targetPath === "") { |
| targetPath = uri._path; |
| targetQuery = t1._query; |
| if (targetQuery != null) |
| ; |
| else |
| targetQuery = uri._query; |
| } else { |
| if (C.JSString_methods.startsWith$1(targetPath, "/")) |
| targetPath = P.Uri__removeDotSegments(targetPath); |
| else { |
| t2 = uri._path; |
| if (t2.length === 0) |
| targetPath = targetScheme.length === 0 && targetHost == null ? targetPath : P.Uri__removeDotSegments("/" + targetPath); |
| else { |
| mergedPath = uri._mergePaths$2(t2, targetPath); |
| targetPath = targetScheme.length !== 0 || targetHost != null || C.JSString_methods.startsWith$1(t2, "/") ? P.Uri__removeDotSegments(mergedPath) : P.Uri__normalizeRelativePath(mergedPath); |
| } |
| } |
| targetQuery = t1._query; |
| if (targetQuery != null) |
| ; |
| else |
| targetQuery = null; |
| } |
| } |
| } |
| fragment = t1._fragment; |
| if (fragment != null) |
| ; |
| else |
| fragment = null; |
| return new P.Uri(targetHost, targetPort, targetPath, targetScheme, targetUserInfo, targetQuery, fragment, null, null).toString$0(0); |
| } else { |
| path = uri.toFilePath$0(); |
| return C.JSString_methods.substring$2(path, 0, path.length - 1); |
| } |
| } |
| }], ["path.context", "package:path/src/context.dart",, F, { |
| "^": "", |
| _validateArgList: function(method, args) { |
| var i, numArgs, numArgs0, message, t1, t2; |
| for (i = 1; i < 8; ++i) { |
| if (args[i] == null || args[i - 1] != null) |
| continue; |
| for (numArgs = 8; numArgs >= 1; numArgs = numArgs0) { |
| numArgs0 = numArgs - 1; |
| if (args[numArgs0] != null) |
| break; |
| } |
| message = new P.StringBuffer(""); |
| t1 = method + "("; |
| message._contents = t1; |
| t2 = new H.SubListIterable(args, 0, numArgs); |
| t2.$builtinTypeInfo = [H.getTypeArgumentByIndex(args, 0)]; |
| if (numArgs < 0) |
| H.throwExpression(P.RangeError$range(numArgs, 0, null, "end", null)); |
| if (0 > numArgs) |
| H.throwExpression(P.RangeError$range(0, 0, numArgs, "start", null)); |
| t2 = new H.MappedListIterable(t2, new F._validateArgList_closure()); |
| t2.$builtinTypeInfo = [null, null]; |
| t1 += t2.join$1(0, ", "); |
| message._contents = t1; |
| message._contents = t1 + ("): part " + (i - 1) + " was null, but part " + i + " was not."); |
| throw H.wrapException(P.ArgumentError$(message.toString$0(0))); |
| } |
| }, |
| Context: { |
| "^": "Object;style,_context$_current", |
| join$8: function(_, part1, part2, part3, part4, part5, part6, part7, part8) { |
| var parts = H.setRuntimeTypeInfo([part1, part2, part3, part4, part5, part6, part7, part8], [P.String]); |
| F._validateArgList("join", parts); |
| return this.joinAll$1(H.setRuntimeTypeInfo(new H.WhereIterable(parts, new F.Context_join_closure()), [H.getTypeArgumentByIndex(parts, 0)])); |
| }, |
| joinAll$1: function(parts) { |
| var buffer, t1, t2, t3, needsSeparator, isAbsoluteAndNotRootRelative, part, parsed, t4, t5; |
| buffer = new P.StringBuffer(""); |
| for (t1 = H.setRuntimeTypeInfo(new H.WhereIterable(parts, new F.Context_joinAll_closure()), [H.getRuntimeTypeArgument(parts, "Iterable", 0)]), t1 = H.setRuntimeTypeInfo(new H.WhereIterator(J.get$iterator$ax(t1._iterable), t1._f), [H.getTypeArgumentByIndex(t1, 0)]), t2 = this.style, t3 = t1._iterator, needsSeparator = false, isAbsoluteAndNotRootRelative = false; t1.moveNext$0();) { |
| part = t3.get$current(); |
| if (t2.isRootRelative$1(part) && isAbsoluteAndNotRootRelative) { |
| parsed = Q.ParsedPath_ParsedPath$parse(part, t2); |
| t4 = buffer._contents; |
| t4 = t4.charCodeAt(0) == 0 ? t4 : t4; |
| t4 = C.JSString_methods.substring$2(t4, 0, t2.rootLength$1(t4)); |
| parsed.root = t4; |
| if (t2.needsSeparator$1(t4)) { |
| t4 = parsed.separators; |
| t5 = t2.get$separator(); |
| if (0 >= t4.length) |
| return H.ioore(t4, 0); |
| t4[0] = t5; |
| } |
| buffer._contents = ""; |
| buffer._contents += parsed.toString$0(0); |
| } else if (t2.rootLength$1(part) > 0) { |
| isAbsoluteAndNotRootRelative = !t2.isRootRelative$1(part); |
| buffer._contents = ""; |
| buffer._contents += H.S(part); |
| } else { |
| t4 = J.getInterceptor$asx(part); |
| if (J.$gt$n(t4.get$length(part), 0) && t2.containsSeparator$1(t4.$index(part, 0)) === true) |
| ; |
| else if (needsSeparator) |
| buffer._contents += t2.get$separator(); |
| buffer._contents += H.S(part); |
| } |
| needsSeparator = t2.needsSeparator$1(part); |
| } |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| split$1: function(_, path) { |
| var parsed, t1, t2; |
| parsed = Q.ParsedPath_ParsedPath$parse(path, this.style); |
| t1 = parsed.parts; |
| t1 = H.setRuntimeTypeInfo(new H.WhereIterable(t1, new F.Context_split_closure()), [H.getTypeArgumentByIndex(t1, 0)]); |
| t1 = P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "Iterable", 0)); |
| parsed.parts = t1; |
| t2 = parsed.root; |
| if (t2 != null) |
| C.JSArray_methods.insert$2(t1, 0, t2); |
| return parsed.parts; |
| }, |
| normalize$1: function(path) { |
| var parsed = Q.ParsedPath_ParsedPath$parse(path, this.style); |
| parsed.normalize$0(); |
| return parsed.toString$0(0); |
| }, |
| relative$2$from: function(path, from) { |
| var t1, t2, fromParsed, pathParsed, t3; |
| from = this._context$_current; |
| from = from != null ? from : B.current(); |
| t1 = this.style; |
| if (t1.rootLength$1(from) <= 0 && t1.rootLength$1(path) > 0) |
| return this.normalize$1(path); |
| if (t1.rootLength$1(path) <= 0 || t1.isRootRelative$1(path)) { |
| t2 = this._context$_current; |
| path = this.join$8(0, t2 != null ? t2 : B.current(), path, null, null, null, null, null, null); |
| } |
| if (t1.rootLength$1(path) <= 0 && t1.rootLength$1(from) > 0) |
| throw H.wrapException(new E.PathException("Unable to find a path to \"" + path + "\" from \"" + H.S(from) + "\".")); |
| fromParsed = Q.ParsedPath_ParsedPath$parse(from, t1); |
| fromParsed.normalize$0(); |
| pathParsed = Q.ParsedPath_ParsedPath$parse(path, t1); |
| pathParsed.normalize$0(); |
| t2 = fromParsed.parts; |
| if (t2.length > 0 && J.$eq$(t2[0], ".")) |
| return pathParsed.toString$0(0); |
| if (!J.$eq$(fromParsed.root, pathParsed.root)) { |
| t2 = fromParsed.root; |
| if (!(t2 == null || pathParsed.root == null)) { |
| t2 = J.toLowerCase$0$s(t2); |
| H.checkString("\\"); |
| t2 = H.stringReplaceAllUnchecked(t2, "/", "\\"); |
| t3 = J.toLowerCase$0$s(pathParsed.root); |
| H.checkString("\\"); |
| t3 = t2 !== H.stringReplaceAllUnchecked(t3, "/", "\\"); |
| t2 = t3; |
| } else |
| t2 = true; |
| } else |
| t2 = false; |
| if (t2) |
| return pathParsed.toString$0(0); |
| while (true) { |
| t2 = fromParsed.parts; |
| if (t2.length > 0) { |
| t3 = pathParsed.parts; |
| t2 = t3.length > 0 && J.$eq$(t2[0], t3[0]); |
| } else |
| t2 = false; |
| if (!t2) |
| break; |
| C.JSArray_methods.removeAt$1(fromParsed.parts, 0); |
| C.JSArray_methods.removeAt$1(fromParsed.separators, 1); |
| C.JSArray_methods.removeAt$1(pathParsed.parts, 0); |
| C.JSArray_methods.removeAt$1(pathParsed.separators, 1); |
| } |
| t2 = fromParsed.parts; |
| if (t2.length > 0 && J.$eq$(t2[0], "..")) |
| throw H.wrapException(new E.PathException("Unable to find a path to \"" + path + "\" from \"" + H.S(from) + "\".")); |
| C.JSArray_methods.insertAll$2(pathParsed.parts, 0, P.List_List$filled(fromParsed.parts.length, "..", null)); |
| t2 = pathParsed.separators; |
| if (0 >= t2.length) |
| return H.ioore(t2, 0); |
| t2[0] = ""; |
| C.JSArray_methods.insertAll$2(t2, 1, P.List_List$filled(fromParsed.parts.length, t1.get$separator(), null)); |
| t1 = pathParsed.parts; |
| t2 = t1.length; |
| if (t2 === 0) |
| return "."; |
| if (t2 > 1 && J.$eq$(C.JSArray_methods.get$last(t1), ".")) { |
| C.JSArray_methods.removeLast$0(pathParsed.parts); |
| t1 = pathParsed.separators; |
| C.JSArray_methods.removeLast$0(t1); |
| C.JSArray_methods.removeLast$0(t1); |
| C.JSArray_methods.add$1(t1, ""); |
| } |
| pathParsed.root = ""; |
| pathParsed.removeTrailingSeparators$0(); |
| return pathParsed.toString$0(0); |
| }, |
| relative$1: function(path) { |
| return this.relative$2$from(path, null); |
| }, |
| prettyUri$1: function(uri) { |
| var t1, t2, path, rel; |
| if (typeof uri === "string") |
| uri = P.Uri_parse(uri, 0, null); |
| if (uri.get$scheme() === "file") { |
| t1 = this.style; |
| t2 = $.$get$Style_url(); |
| t2 = t1 == null ? t2 == null : t1 === t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| if (t1) |
| return uri.toString$0(0); |
| t1 = uri.scheme; |
| if (t1 !== "file") |
| if (t1 !== "") { |
| t1 = this.style; |
| t2 = $.$get$Style_url(); |
| t2 = t1 == null ? t2 != null : t1 !== t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| else |
| t1 = false; |
| if (t1) |
| return uri.toString$0(0); |
| path = this.normalize$1(this.style.pathFromUri$1(uri)); |
| rel = this.relative$1(path); |
| return this.split$1(0, rel).length > this.split$1(0, path).length ? path : rel; |
| } |
| }, |
| Context_join_closure: { |
| "^": "Closure:0;", |
| call$1: function(part) { |
| return part != null; |
| } |
| }, |
| Context_joinAll_closure: { |
| "^": "Closure:0;", |
| call$1: function(part) { |
| return !J.$eq$(part, ""); |
| } |
| }, |
| Context_split_closure: { |
| "^": "Closure:0;", |
| call$1: function(part) { |
| return J.get$isEmpty$asx(part) !== true; |
| } |
| }, |
| _validateArgList_closure: { |
| "^": "Closure:0;", |
| call$1: function(arg) { |
| return arg == null ? "null" : "\"" + H.S(arg) + "\""; |
| } |
| } |
| }], ["path.internal_style", "package:path/src/internal_style.dart",, E, { |
| "^": "", |
| InternalStyle: { |
| "^": "Style;", |
| getRoot$1: function(path) { |
| var $length = this.rootLength$1(path); |
| if ($length > 0) |
| return J.substring$2$s(path, 0, $length); |
| return this.isRootRelative$1(path) ? J.$index$asx(path, 0) : null; |
| } |
| } |
| }], ["path.parsed_path", "package:path/src/parsed_path.dart",, Q, { |
| "^": "", |
| ParsedPath: { |
| "^": "Object;style,root,isRootRelative,parts,separators", |
| removeTrailingSeparators$0: function() { |
| var t1, t2; |
| while (true) { |
| t1 = this.parts; |
| if (!(t1.length !== 0 && J.$eq$(C.JSArray_methods.get$last(t1), ""))) |
| break; |
| C.JSArray_methods.removeLast$0(this.parts); |
| C.JSArray_methods.removeLast$0(this.separators); |
| } |
| t1 = this.separators; |
| t2 = t1.length; |
| if (t2 > 0) |
| t1[t2 - 1] = ""; |
| }, |
| normalize$0: function() { |
| var newParts, t1, t2, leadingDoubles, _i, part, t3, newSeparators; |
| newParts = H.setRuntimeTypeInfo([], [P.String]); |
| for (t1 = this.parts, t2 = t1.length, leadingDoubles = 0, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| part = t1[_i]; |
| t3 = J.getInterceptor(part); |
| if (t3.$eq(part, ".") || t3.$eq(part, "")) |
| ; |
| else if (t3.$eq(part, "..")) |
| if (newParts.length > 0) |
| newParts.pop(); |
| else |
| ++leadingDoubles; |
| else |
| newParts.push(part); |
| } |
| if (this.root == null) |
| C.JSArray_methods.insertAll$2(newParts, 0, P.List_List$filled(leadingDoubles, "..", null)); |
| if (newParts.length === 0 && this.root == null) |
| newParts.push("."); |
| newSeparators = P.List_List$generate(newParts.length, new Q.ParsedPath_normalize_closure(this), true, P.String); |
| t1 = this.root; |
| C.JSArray_methods.insert$2(newSeparators, 0, t1 != null && newParts.length > 0 && this.style.needsSeparator$1(t1) ? this.style.get$separator() : ""); |
| this.parts = newParts; |
| this.separators = newSeparators; |
| t1 = this.root; |
| if (t1 != null && this.style === $.$get$Style_windows()) |
| this.root = J.replaceAll$2$s(t1, "/", "\\"); |
| this.removeTrailingSeparators$0(); |
| }, |
| toString$0: function(_) { |
| var builder, t1, i; |
| builder = new P.StringBuffer(""); |
| t1 = this.root; |
| if (t1 != null) |
| builder._contents = H.S(t1); |
| for (i = 0; i < this.parts.length; ++i) { |
| t1 = this.separators; |
| if (i >= t1.length) |
| return H.ioore(t1, i); |
| builder._contents += H.S(t1[i]); |
| t1 = this.parts; |
| if (i >= t1.length) |
| return H.ioore(t1, i); |
| builder._contents += H.S(t1[i]); |
| } |
| t1 = builder._contents += H.S(C.JSArray_methods.get$last(this.separators)); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| static: {ParsedPath_ParsedPath$parse: function(path, style) { |
| var root, isRootRelative, parts, separators, t1, start, i, t2; |
| root = style.getRoot$1(path); |
| isRootRelative = style.isRootRelative$1(path); |
| if (root != null) |
| path = J.substring$1$s(path, J.get$length$asx(root)); |
| parts = H.setRuntimeTypeInfo([], [P.String]); |
| separators = H.setRuntimeTypeInfo([], [P.String]); |
| t1 = J.getInterceptor$asx(path); |
| if (t1.get$isNotEmpty(path) && style.isSeparator$1(t1.codeUnitAt$1(path, 0))) { |
| separators.push(t1.$index(path, 0)); |
| start = 1; |
| } else { |
| separators.push(""); |
| start = 0; |
| } |
| i = start; |
| while (true) { |
| t2 = t1.get$length(path); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| if (style.isSeparator$1(t1.codeUnitAt$1(path, i))) { |
| parts.push(C.JSString_methods.substring$2(path, start, i)); |
| if (i >= path.length) |
| return H.ioore(path, i); |
| separators.push(path[i]); |
| start = i + 1; |
| } |
| ++i; |
| } |
| t2 = t1.get$length(path); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (start < t2) { |
| parts.push(t1.substring$1(path, start)); |
| separators.push(""); |
| } |
| return new Q.ParsedPath(style, root, isRootRelative, parts, separators); |
| }} |
| }, |
| ParsedPath_normalize_closure: { |
| "^": "Closure:0;_parsed_path$_captured_this_0", |
| call$1: function(_) { |
| return this._parsed_path$_captured_this_0.style.get$separator(); |
| } |
| } |
| }], ["path.path_exception", "package:path/src/path_exception.dart",, E, { |
| "^": "", |
| PathException: { |
| "^": "Object;message>", |
| toString$0: function(_) { |
| return "PathException: " + this.message; |
| } |
| } |
| }], ["path.style", "package:path/src/style.dart",, S, { |
| "^": "", |
| Style__getPlatformStyle: function() { |
| var scheme, userInfo, host, query, fragment, port, isFile, t1, path; |
| if (P.Uri_base().scheme !== "file") |
| return $.$get$Style_url(); |
| if (!C.JSString_methods.endsWith$1(P.Uri_base()._path, "/")) |
| return $.$get$Style_url(); |
| scheme = P.Uri__makeScheme("", 0, 0); |
| userInfo = P.Uri__makeUserInfo("", 0, 0); |
| host = P.Uri__makeHost(null, 0, 0, false); |
| query = P.Uri__makeQuery(null, 0, 0, null); |
| fragment = P.Uri__makeFragment(null, 0, 0); |
| port = P.Uri__makePort(null, scheme); |
| isFile = scheme === "file"; |
| if (host == null) |
| t1 = userInfo.length !== 0 || port != null || isFile; |
| else |
| t1 = false; |
| if (t1) |
| host = ""; |
| t1 = host == null; |
| path = P.Uri__makePath("a/b", 0, 3, null, scheme, !t1); |
| if (new P.Uri(host, port, scheme.length === 0 && t1 && !C.JSString_methods.startsWith$1(path, "/") ? P.Uri__normalizeRelativePath(path) : P.Uri__removeDotSegments(path), scheme, userInfo, query, fragment, null, null).toFilePath$0() === "a\\b") |
| return $.$get$Style_windows(); |
| return $.$get$Style_posix(); |
| }, |
| Style: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return this.get$name(this); |
| } |
| } |
| }], ["path.style.posix", "package:path/src/style/posix.dart",, Z, { |
| "^": "", |
| PosixStyle: { |
| "^": "InternalStyle;name>,separator<,separators,separatorPattern,needsSeparatorPattern,rootPattern,relativeRootPattern", |
| containsSeparator$1: function(path) { |
| return J.contains$1$asx(path, "/"); |
| }, |
| isSeparator$1: function(codeUnit) { |
| return codeUnit === 47; |
| }, |
| needsSeparator$1: function(path) { |
| var t1 = J.getInterceptor$asx(path); |
| return t1.get$isNotEmpty(path) && t1.codeUnitAt$1(path, J.$sub$n(t1.get$length(path), 1)) !== 47; |
| }, |
| rootLength$1: function(path) { |
| var t1 = J.getInterceptor$asx(path); |
| if (t1.get$isNotEmpty(path) && t1.codeUnitAt$1(path, 0) === 47) |
| return 1; |
| return 0; |
| }, |
| isRootRelative$1: function(path) { |
| return false; |
| }, |
| pathFromUri$1: function(uri) { |
| var t1 = uri.scheme; |
| if (t1 === "" || t1 === "file") |
| return P.Uri__uriDecode(uri._path, C.Utf8Codec_false, false); |
| throw H.wrapException(P.ArgumentError$("Uri " + uri.toString$0(0) + " must have scheme 'file:'.")); |
| } |
| } |
| }], ["path.style.url", "package:path/src/style/url.dart",, E, { |
| "^": "", |
| UrlStyle: { |
| "^": "InternalStyle;name>,separator<,separators,separatorPattern,needsSeparatorPattern,rootPattern,relativeRootPattern", |
| containsSeparator$1: function(path) { |
| return J.contains$1$asx(path, "/"); |
| }, |
| isSeparator$1: function(codeUnit) { |
| return codeUnit === 47; |
| }, |
| needsSeparator$1: function(path) { |
| var t1 = J.getInterceptor$asx(path); |
| if (t1.get$isEmpty(path) === true) |
| return false; |
| if (t1.codeUnitAt$1(path, J.$sub$n(t1.get$length(path), 1)) !== 47) |
| return true; |
| return C.JSString_methods.endsWith$1(path, "://") && this.rootLength$1(path) === path.length; |
| }, |
| rootLength$1: function(path) { |
| var t1, index; |
| t1 = J.getInterceptor$asx(path); |
| if (t1.get$isEmpty(path) === true) |
| return 0; |
| if (t1.codeUnitAt$1(path, 0) === 47) |
| return 1; |
| index = C.JSString_methods.indexOf$1(path, "/"); |
| if (index > 0 && C.JSString_methods.startsWith$2(path, "://", index - 1)) { |
| index = C.JSString_methods.indexOf$2(path, "/", index + 2); |
| if (index > 0) |
| return index; |
| return path.length; |
| } |
| return 0; |
| }, |
| isRootRelative$1: function(path) { |
| var t1 = J.getInterceptor$asx(path); |
| return t1.get$isNotEmpty(path) && t1.codeUnitAt$1(path, 0) === 47; |
| }, |
| pathFromUri$1: function(uri) { |
| return uri.toString$0(0); |
| } |
| } |
| }], ["path.style.windows", "package:path/src/style/windows.dart",, T, { |
| "^": "", |
| WindowsStyle: { |
| "^": "InternalStyle;name>,separator<,separators,separatorPattern,needsSeparatorPattern,rootPattern,relativeRootPattern", |
| containsSeparator$1: function(path) { |
| return J.contains$1$asx(path, "/"); |
| }, |
| isSeparator$1: function(codeUnit) { |
| return codeUnit === 47 || codeUnit === 92; |
| }, |
| needsSeparator$1: function(path) { |
| var t1 = J.getInterceptor$asx(path); |
| if (t1.get$isEmpty(path) === true) |
| return false; |
| t1 = t1.codeUnitAt$1(path, J.$sub$n(t1.get$length(path), 1)); |
| return !(t1 === 47 || t1 === 92); |
| }, |
| rootLength$1: function(path) { |
| var t1, index; |
| t1 = J.getInterceptor$asx(path); |
| if (t1.get$isEmpty(path) === true) |
| return 0; |
| if (t1.codeUnitAt$1(path, 0) === 47) |
| return 1; |
| if (C.JSString_methods.codeUnitAt$1(path, 0) === 92) { |
| t1 = path.length; |
| if (t1 < 2 || C.JSString_methods.codeUnitAt$1(path, 1) !== 92) |
| return 1; |
| index = C.JSString_methods.indexOf$2(path, "\\", 2); |
| if (index > 0) { |
| index = C.JSString_methods.indexOf$2(path, "\\", index + 1); |
| if (index > 0) |
| return index; |
| } |
| return t1; |
| } |
| if (path.length < 3) |
| return 0; |
| t1 = C.JSString_methods.codeUnitAt$1(path, 0); |
| if (!(t1 >= 65 && t1 <= 90)) |
| t1 = t1 >= 97 && t1 <= 122; |
| else |
| t1 = true; |
| if (!t1) |
| return 0; |
| if (C.JSString_methods.codeUnitAt$1(path, 1) !== 58) |
| return 0; |
| t1 = C.JSString_methods.codeUnitAt$1(path, 2); |
| if (!(t1 === 47 || t1 === 92)) |
| return 0; |
| return 3; |
| }, |
| isRootRelative$1: function(path) { |
| return this.rootLength$1(path) === 1; |
| }, |
| pathFromUri$1: function(uri) { |
| var t1, path; |
| t1 = uri.scheme; |
| if (t1 !== "" && t1 !== "file") |
| throw H.wrapException(P.ArgumentError$("Uri " + uri.toString$0(0) + " must have scheme 'file:'.")); |
| path = uri._path; |
| if (uri.get$host(uri) === "") { |
| if (C.JSString_methods.startsWith$1(path, "/")) { |
| H.checkString(""); |
| H.checkInt(0); |
| P.RangeError_checkValueInInterval(0, 0, path.length, "startIndex", null); |
| path = H.stringReplaceFirstUnchecked(path, "/", "", 0); |
| } |
| } else |
| path = "\\\\" + H.S(uri.get$host(uri)) + path; |
| H.checkString("\\"); |
| return P.Uri__uriDecode(H.stringReplaceAllUnchecked(path, "/", "\\"), C.Utf8Codec_false, false); |
| } |
| } |
| }], ["source_span.location", "package:source_span/src/location.dart",, O, { |
| "^": "", |
| SourceLocation: { |
| "^": "Object;sourceUrl,offset,line,column", |
| get$toolString: function() { |
| var source = this.sourceUrl; |
| return H.S(source == null ? "unknown source" : source) + ":" + H.S(J.$add$ns(this.line, 1)) + ":" + H.S(J.$add$ns(this.column, 1)); |
| }, |
| distance$1: function(other) { |
| var t1, t2; |
| t1 = this.sourceUrl; |
| t2 = other.sourceUrl; |
| if (!J.$eq$(t1, t2)) |
| throw H.wrapException(P.ArgumentError$("Source URLs \"" + H.S(t1) + "\" and \"" + H.S(t2) + "\" don't match.")); |
| return J.abs$0$n(J.$sub$n(this.offset, other.offset)); |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| return other instanceof O.SourceLocation && J.$eq$(this.sourceUrl, other.sourceUrl) && J.$eq$(this.offset, other.offset); |
| }, |
| get$hashCode: function(_) { |
| return J.$add$ns(J.get$hashCode$(this.sourceUrl), this.offset); |
| }, |
| toString$0: function(_) { |
| return "<" + H.S(new H.TypeImpl(H.getRuntimeTypeString(this), null)) + ": " + H.S(this.offset) + " " + this.get$toolString() + ">"; |
| }, |
| SourceLocation$4$column$line$sourceUrl: function(offset, column, line, sourceUrl) { |
| if (J.$lt$n(offset, 0)) |
| throw H.wrapException(P.RangeError$("Offset may not be negative, was " + H.S(offset) + ".")); |
| else if (line != null && J.$lt$n(line, 0)) |
| throw H.wrapException(P.RangeError$("Line may not be negative, was " + H.S(line) + ".")); |
| else if (column != null && J.$lt$n(column, 0)) |
| throw H.wrapException(P.RangeError$("Column may not be negative, was " + H.S(column) + ".")); |
| }, |
| static: {SourceLocation$: function(offset, column, line, sourceUrl) { |
| var t1, t2; |
| t1 = typeof sourceUrl === "string" ? P.Uri_parse(sourceUrl, 0, null) : sourceUrl; |
| t2 = line == null ? 0 : line; |
| t1 = new O.SourceLocation(t1, offset, t2, column == null ? offset : column); |
| t1.SourceLocation$4$column$line$sourceUrl(offset, column, line, sourceUrl); |
| return t1; |
| }} |
| } |
| }], ["source_span.span", "package:source_span/src/span.dart",, T, { |
| "^": "", |
| SourceSpan: { |
| "^": "Object;" |
| }, |
| SourceSpanBase: { |
| "^": "SourceSpanMixin;start>,end<,text", |
| SourceSpanBase$3: function(start, end, text) { |
| var t1, t2, t3, t4; |
| t1 = this.end; |
| t2 = t1.sourceUrl; |
| t3 = this.start; |
| t4 = t3.sourceUrl; |
| if (!J.$eq$(t2, t4)) |
| throw H.wrapException(P.ArgumentError$("Source URLs \"" + H.S(t4) + "\" and \"" + H.S(t2) + "\" don't match.")); |
| else if (J.$lt$n(t1.offset, t3.offset)) |
| throw H.wrapException(P.ArgumentError$("End " + t1.toString$0(0) + " must come after start " + t3.toString$0(0) + ".")); |
| else { |
| t2 = this.text; |
| if (!J.$eq$(J.get$length$asx(t2), t3.distance$1(t1))) |
| throw H.wrapException(P.ArgumentError$("Text \"" + H.S(t2) + "\" must be " + H.S(t3.distance$1(t1)) + " characters long.")); |
| } |
| }, |
| static: {SourceSpanBase$: function(start, end, text) { |
| var t1 = new T.SourceSpanBase(start, end, text); |
| t1.SourceSpanBase$3(start, end, text); |
| return t1; |
| }} |
| } |
| }], ["source_span.span_mixin", "package:source_span/src/span_mixin.dart",, Y, { |
| "^": "", |
| SourceSpanMixin: { |
| "^": "Object;", |
| get$length: function(_) { |
| return J.$sub$n(this.get$end().offset, this.start.offset); |
| }, |
| message$2$color: [function(_, message, color) { |
| var t1, column, t2, t3, context, lineStart, t4, endIndex, textLine, toColumn; |
| t1 = this.start; |
| column = t1.column; |
| t2 = "line " + H.S(J.$add$ns(this.get$start(this).line, 1)) + ", column " + H.S(J.$add$ns(column, 1)); |
| t3 = t1.sourceUrl; |
| if (t3 != null) |
| t2 += " of " + $.$get$context().prettyUri$1(t3); |
| t2 += ": " + H.S(message); |
| t3 = this.end.offset; |
| t1 = t1.offset; |
| if (J.$eq$(J.$sub$n(t3, t1), 0) && !this.$isSourceSpanWithContext) |
| return t2.charCodeAt(0) == 0 ? t2 : t2; |
| t2 += "\n"; |
| if (!!this.$isSourceSpanWithContext) { |
| context = this.context; |
| lineStart = D.findLineStart(context, this.text, column); |
| if (lineStart != null && lineStart > 0) { |
| t2 += J.substring$2$s(context, 0, lineStart); |
| context = C.JSString_methods.substring$1(context, lineStart); |
| } |
| t4 = J.getInterceptor$asx(context); |
| endIndex = t4.indexOf$1(context, "\n"); |
| textLine = endIndex === -1 ? context : t4.substring$2(context, 0, endIndex + 1); |
| column = P.min(column, J.get$length$asx(textLine) - 1); |
| } else { |
| textLine = C.JSArray_methods.get$first(J.split$1$s(this.text, "\n")); |
| column = 0; |
| } |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| t4 = J.getInterceptor$asx(textLine); |
| toColumn = P.min(column + t3 - t1, t4.get$length(textLine)); |
| t1 = t2 + H.S(textLine); |
| if (!t4.endsWith$1(textLine, "\n")) |
| t1 += "\n"; |
| t1 += C.JSString_methods.$mul(" ", column); |
| t1 += C.JSString_methods.$mul("^", P.max(toColumn - column, 1)); |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, function($receiver, message) { |
| return this.message$2$color($receiver, message, null); |
| }, "message$1", "call$2$color", "call$1", "get$message", 2, 3, 28, 0], |
| $eq: function(_, other) { |
| var t1; |
| if (other == null) |
| return false; |
| t1 = J.getInterceptor(other); |
| return !!t1.$isSourceSpan && this.get$start(this).$eq(0, t1.get$start(other)) && this.end.$eq(0, other.get$end()); |
| }, |
| get$hashCode: function(_) { |
| var t1, t2; |
| t1 = this.get$start(this); |
| t1 = J.$add$ns(J.get$hashCode$(t1.sourceUrl), t1.offset); |
| t2 = this.end; |
| t2 = J.$add$ns(J.get$hashCode$(t2.sourceUrl), t2.offset); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| return J.$add$ns(t1, 31 * t2); |
| }, |
| toString$0: function(_) { |
| var t1, t2, t3; |
| t1 = "<" + H.S(new H.TypeImpl(H.getRuntimeTypeString(this), null)) + ": from "; |
| t2 = this.get$start(this); |
| t3 = this.end; |
| return t1 + ("<" + H.S(new H.TypeImpl(H.getRuntimeTypeString(t2), null)) + ": " + H.S(t2.offset) + " " + t2.get$toolString() + ">") + " to " + ("<" + H.S(new H.TypeImpl(H.getRuntimeTypeString(t3), null)) + ": " + H.S(t3.offset) + " " + t3.get$toolString() + ">") + " \"" + H.S(this.text) + "\">"; |
| }, |
| $isSourceSpan: 1 |
| } |
| }], ["source_span.span_with_context", "package:source_span/src/span_with_context.dart",, E, { |
| "^": "", |
| SourceSpanWithContext: { |
| "^": "SourceSpanBase;context,start,end,text" |
| } |
| }], ["source_span.utils", "package:source_span/src/utils.dart",, D, { |
| "^": "", |
| findLineStart: function(context, text, column) { |
| var isEmpty, t1, index, t2, lineStart, textColumn, t3; |
| isEmpty = J.$eq$(text, ""); |
| t1 = J.getInterceptor$asx(context); |
| index = t1.indexOf$1(context, text); |
| for (t2 = J.getInterceptor(column); index !== -1;) { |
| lineStart = t1.lastIndexOf$2(context, "\n", index) + 1; |
| textColumn = index - lineStart; |
| if (!t2.$eq(column, textColumn)) |
| t3 = isEmpty && t2.$eq(column, textColumn + 1); |
| else |
| t3 = true; |
| if (t3) |
| return lineStart; |
| index = t1.indexOf$2(context, text, index + 1); |
| } |
| return; |
| } |
| }]]; |
| 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 (typeof receiver != "object") |
| return receiver; |
| if (receiver instanceof P.Object) |
| return receiver; |
| return J.getNativeInterceptor(receiver); |
| }; |
| J.getInterceptor$asx = function(receiver) { |
| if (typeof receiver == "string") |
| return J.JSString.prototype; |
| if (receiver == null) |
| return receiver; |
| if (receiver.constructor == Array) |
| return J.JSArray.prototype; |
| if (typeof receiver != "object") |
| return receiver; |
| if (receiver instanceof P.Object) |
| return receiver; |
| return J.getNativeInterceptor(receiver); |
| }; |
| J.getInterceptor$ax = function(receiver) { |
| if (receiver == null) |
| return receiver; |
| if (receiver.constructor == Array) |
| return J.JSArray.prototype; |
| if (typeof receiver != "object") |
| return receiver; |
| if (receiver instanceof P.Object) |
| return receiver; |
| return J.getNativeInterceptor(receiver); |
| }; |
| J.getInterceptor$n = function(receiver) { |
| if (typeof receiver == "number") |
| return J.JSNumber.prototype; |
| if (receiver == null) |
| return receiver; |
| if (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return receiver; |
| }; |
| J.getInterceptor$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.getInterceptor$s = function(receiver) { |
| if (typeof receiver == "string") |
| return J.JSString.prototype; |
| if (receiver == null) |
| return receiver; |
| if (!(receiver instanceof P.Object)) |
| return J.UnknownJavaScriptObject.prototype; |
| return receiver; |
| }; |
| J.getInterceptor$x = function(receiver) { |
| if (receiver == null) |
| return receiver; |
| if (typeof receiver != "object") |
| return receiver; |
| if (receiver instanceof P.Object) |
| return receiver; |
| return J.getNativeInterceptor(receiver); |
| }; |
| J.set$href$x = function(receiver, value) { |
| return J.getInterceptor$x(receiver).set$href(receiver, value); |
| }; |
| J.get$attributes$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$attributes(receiver); |
| }; |
| J.get$classes$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$classes(receiver); |
| }; |
| J.get$error$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$error(receiver); |
| }; |
| J.get$isEmpty$asx = function(receiver) { |
| return J.getInterceptor$asx(receiver).get$isEmpty(receiver); |
| }; |
| J.get$iterator$ax = function(receiver) { |
| return J.getInterceptor$ax(receiver).get$iterator(receiver); |
| }; |
| J.get$last$ax = function(receiver) { |
| return J.getInterceptor$ax(receiver).get$last(receiver); |
| }; |
| J.get$length$asx = function(receiver) { |
| return J.getInterceptor$asx(receiver).get$length(receiver); |
| }; |
| J.get$name$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$name(receiver); |
| }; |
| J.get$onClick$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$onClick(receiver); |
| }; |
| J.get$responseText$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$responseText(receiver); |
| }; |
| J.get$tagName$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$tagName(receiver); |
| }; |
| J.get$target$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$target(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.$gt$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver > a0; |
| return J.getInterceptor$n(receiver).$gt(receiver, a0); |
| }; |
| J.$index$asx = function(receiver, a0) { |
| if (receiver.constructor == Array || typeof receiver == "string" || H.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) |
| if (a0 >>> 0 === a0 && a0 < receiver.length) |
| return receiver[a0]; |
| return J.getInterceptor$asx(receiver).$index(receiver, a0); |
| }; |
| J.$lt$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver < a0; |
| return J.getInterceptor$n(receiver).$lt(receiver, a0); |
| }; |
| J.$sub$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver - a0; |
| return J.getInterceptor$n(receiver).$sub(receiver, a0); |
| }; |
| J._addEventListener$3$x = function(receiver, a0, a1, a2) { |
| return J.getInterceptor$x(receiver)._addEventListener$3(receiver, a0, a1, a2); |
| }; |
| J._removeEventListener$3$x = function(receiver, a0, a1, a2) { |
| return J.getInterceptor$x(receiver)._removeEventListener$3(receiver, a0, a1, a2); |
| }; |
| J.abs$0$n = function(receiver) { |
| return J.getInterceptor$n(receiver).abs$0(receiver); |
| }; |
| J.accept$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).accept$1(receiver, a0); |
| }; |
| J.add$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).add$1(receiver, a0); |
| }; |
| J.codeUnitAt$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).codeUnitAt$1(receiver, a0); |
| }; |
| J.complete$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).complete$1(receiver, a0); |
| }; |
| J.contains$1$asx = function(receiver, a0) { |
| return J.getInterceptor$asx(receiver).contains$1(receiver, a0); |
| }; |
| J.contains$2$asx = function(receiver, a0, a1) { |
| return J.getInterceptor$asx(receiver).contains$2(receiver, a0, a1); |
| }; |
| J.elementAt$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); |
| }; |
| J.forEach$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); |
| }; |
| J.map$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).map$1(receiver, a0); |
| }; |
| J.querySelector$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).querySelector$1(receiver, a0); |
| }; |
| J.remove$0$ax = function(receiver) { |
| return J.getInterceptor$ax(receiver).remove$0(receiver); |
| }; |
| J.replaceAll$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).replaceAll$2(receiver, a0, a1); |
| }; |
| J.replaceAllMapped$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).replaceAllMapped$2(receiver, a0, a1); |
| }; |
| J.send$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).send$1(receiver, a0); |
| }; |
| J.split$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).split$1(receiver, a0); |
| }; |
| J.substring$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).substring$1(receiver, a0); |
| }; |
| J.substring$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).substring$2(receiver, a0, a1); |
| }; |
| J.toLowerCase$0$s = function(receiver) { |
| return J.getInterceptor$s(receiver).toLowerCase$0(receiver); |
| }; |
| J.toRadixString$1$n = function(receiver, a0) { |
| return J.getInterceptor$n(receiver).toRadixString$1(receiver, a0); |
| }; |
| J.trim$0$s = function(receiver) { |
| return J.getInterceptor$s(receiver).trim$0(receiver); |
| }; |
| J.get$hashCode$ = function(receiver) { |
| return J.getInterceptor(receiver).get$hashCode(receiver); |
| }; |
| 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.toString$0$ = function(receiver) { |
| return J.getInterceptor(receiver).toString$0(receiver); |
| }; |
| Isolate.makeConstantList = function(list) { |
| list.immutable$list = Array; |
| list.fixed$length = Array; |
| return list; |
| }; |
| var $ = Isolate.$isolateProperties; |
| C.BodyElement_methods = W.BodyElement.prototype; |
| C.HttpRequest_methods = W.HttpRequest.prototype; |
| C.JSArray_methods = J.JSArray.prototype; |
| C.JSDouble_methods = J.JSDouble.prototype; |
| C.JSInt_methods = J.JSInt.prototype; |
| C.JSNull_methods = J.JSNull.prototype; |
| C.JSNumber_methods = J.JSNumber.prototype; |
| C.JSString_methods = J.JSString.prototype; |
| C.NodeList_methods = W.NodeList.prototype; |
| C.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype; |
| C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; |
| C.Window_methods = W.Window.prototype; |
| C.C_DynamicRuntimeType = new H.DynamicRuntimeType(); |
| C.C_OutOfMemoryError = new P.OutOfMemoryError(); |
| C.C_Utf8Encoder = new P.Utf8Encoder(); |
| C.C__DelayedDone = new P._DelayedDone(); |
| C.C__RootZone = new P._RootZone(); |
| C.Duration_0 = new P.Duration(0); |
| C.HtmlEscapeMode_p2v = new P.HtmlEscapeMode("unknown", true, true, true, true); |
| C.JS_CONST_0 = function(hooks) { |
| if (typeof dartExperimentalFixupGetTag != "function") return hooks; |
| hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); |
| }; |
| C.JS_CONST_4hp = function(hooks) { |
| var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; |
| if (userAgent.indexOf("Firefox") == -1) return hooks; |
| var getTag = hooks.getTag; |
| var quickMap = { |
| "BeforeUnloadEvent": "Event", |
| "DataTransfer": "Clipboard", |
| "GeoGeolocation": "Geolocation", |
| "Location": "!Location", |
| "WorkerMessageEvent": "MessageEvent", |
| "XMLDocument": "!Document"}; |
| function getTagFirefox(o) { |
| var tag = getTag(o); |
| return quickMap[tag] || tag; |
| } |
| hooks.getTag = getTagFirefox; |
| }; |
| 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); |
| }; |
| C.JS_CONST_Fs4 = function(hooks) { return hooks; } |
| ; |
| C.JS_CONST_QJm = function(getTagFallback) { |
| return function(hooks) { |
| if (typeof navigator != "object") return hooks; |
| var ua = navigator.userAgent; |
| if (ua.indexOf("DumpRenderTree") >= 0) return hooks; |
| if (ua.indexOf("Chrome") >= 0) { |
| function confirm(p) { |
| return typeof window == "object" && window[p] && window[p].name == p; |
| } |
| if (confirm("Window") && confirm("HTMLElement")) return hooks; |
| } |
| hooks.getTag = getTagFallback; |
| }; |
| }; |
| C.JS_CONST_gkc = function() { |
| function typeNameInChrome(o) { |
| var constructor = o.constructor; |
| if (constructor) { |
| var name = constructor.name; |
| if (name) return name; |
| } |
| var s = Object.prototype.toString.call(o); |
| return s.substring(8, s.length - 1); |
| } |
| function getUnknownTag(object, tag) { |
| if (/^HTML[A-Z].*Element$/.test(tag)) { |
| var name = Object.prototype.toString.call(object); |
| if (name == "[object Object]") return null; |
| return "HTMLElement"; |
| } |
| } |
| function getUnknownTagGenericBrowser(object, tag) { |
| if (self.HTMLElement && object instanceof HTMLElement) return "HTMLElement"; |
| return getUnknownTag(object, tag); |
| } |
| function prototypeForTag(tag) { |
| if (typeof window == "undefined") return null; |
| if (typeof window[tag] == "undefined") return null; |
| var constructor = window[tag]; |
| if (typeof constructor != "function") return null; |
| return constructor.prototype; |
| } |
| function discriminator(tag) { return null; } |
| var isBrowser = typeof navigator == "object"; |
| return { |
| getTag: typeNameInChrome, |
| getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, |
| prototypeForTag: prototypeForTag, |
| discriminator: discriminator }; |
| }; |
| C.JS_CONST_gkc0 = function(hooks) { |
| var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; |
| if (userAgent.indexOf("Trident/") == -1) return hooks; |
| var getTag = hooks.getTag; |
| var quickMap = { |
| "BeforeUnloadEvent": "Event", |
| "DataTransfer": "Clipboard", |
| "HTMLDDElement": "HTMLElement", |
| "HTMLDTElement": "HTMLElement", |
| "HTMLPhraseElement": "HTMLElement", |
| "Position": "Geoposition" |
| }; |
| function getTagIE(o) { |
| var tag = getTag(o); |
| var newTag = quickMap[tag]; |
| if (newTag) return newTag; |
| if (tag == "Object") { |
| if (window.DataView && (o instanceof window.DataView)) return "DataView"; |
| } |
| return tag; |
| } |
| function prototypeForTagIE(tag) { |
| var constructor = window[tag]; |
| if (constructor == null) return null; |
| return constructor.prototype; |
| } |
| hooks.getTag = getTagIE; |
| hooks.prototypeForTag = prototypeForTagIE; |
| }; |
| C.JS_CONST_rr7 = function(hooks) { |
| var getTag = hooks.getTag; |
| var prototypeForTag = hooks.prototypeForTag; |
| function getTagFixed(o) { |
| var tag = getTag(o); |
| if (tag == "Document") { |
| if (!!o.xmlVersion) return "!Document"; |
| return "!HTMLDocument"; |
| } |
| return tag; |
| } |
| function prototypeForTagFixed(tag) { |
| if (tag == "Document") return null; |
| return prototypeForTag(tag); |
| } |
| hooks.getTag = getTagFixed; |
| hooks.prototypeForTag = prototypeForTagFixed; |
| }; |
| C.JsonCodec_null_null = new P.JsonCodec(null, null); |
| C.JsonDecoder_null = new P.JsonDecoder(null); |
| C.List_127_2047_65535_1114111 = H.setRuntimeTypeInfo(Isolate.makeConstantList([127, 2047, 65535, 1114111]), [P.$int]); |
| C.List_1GN = H.setRuntimeTypeInfo(Isolate.makeConstantList(["*::class", "*::dir", "*::draggable", "*::hidden", "*::id", "*::inert", "*::itemprop", "*::itemref", "*::itemscope", "*::lang", "*::spellcheck", "*::title", "*::translate", "A::accesskey", "A::coords", "A::hreflang", "A::name", "A::shape", "A::tabindex", "A::target", "A::type", "AREA::accesskey", "AREA::alt", "AREA::coords", "AREA::nohref", "AREA::shape", "AREA::tabindex", "AREA::target", "AUDIO::controls", "AUDIO::loop", "AUDIO::mediagroup", "AUDIO::muted", "AUDIO::preload", "BDO::dir", "BODY::alink", "BODY::bgcolor", "BODY::link", "BODY::text", "BODY::vlink", "BR::clear", "BUTTON::accesskey", "BUTTON::disabled", "BUTTON::name", "BUTTON::tabindex", "BUTTON::type", "BUTTON::value", "CANVAS::height", "CANVAS::width", "CAPTION::align", "COL::align", "COL::char", "COL::charoff", "COL::span", "COL::valign", "COL::width", "COLGROUP::align", "COLGROUP::char", "COLGROUP::charoff", "COLGROUP::span", "COLGROUP::valign", "COLGROUP::width", "COMMAND::checked", "COMMAND::command", "COMMAND::disabled", "COMMAND::label", "COMMAND::radiogroup", "COMMAND::type", "DATA::value", "DEL::datetime", "DETAILS::open", "DIR::compact", "DIV::align", "DL::compact", "FIELDSET::disabled", "FONT::color", "FONT::face", "FONT::size", "FORM::accept", "FORM::autocomplete", "FORM::enctype", "FORM::method", "FORM::name", "FORM::novalidate", "FORM::target", "FRAME::name", "H1::align", "H2::align", "H3::align", "H4::align", "H5::align", "H6::align", "HR::align", "HR::noshade", "HR::size", "HR::width", "HTML::version", "IFRAME::align", "IFRAME::frameborder", "IFRAME::height", "IFRAME::marginheight", "IFRAME::marginwidth", "IFRAME::width", "IMG::align", "IMG::alt", "IMG::border", "IMG::height", "IMG::hspace", "IMG::ismap", "IMG::name", "IMG::usemap", "IMG::vspace", "IMG::width", "INPUT::accept", "INPUT::accesskey", "INPUT::align", "INPUT::alt", "INPUT::autocomplete", "INPUT::checked", "INPUT::disabled", "INPUT::inputmode", "INPUT::ismap", "INPUT::list", "INPUT::max", "INPUT::maxlength", "INPUT::min", "INPUT::multiple", "INPUT::name", "INPUT::placeholder", "INPUT::readonly", "INPUT::required", "INPUT::size", "INPUT::step", "INPUT::tabindex", "INPUT::type", "INPUT::usemap", "INPUT::value", "INS::datetime", "KEYGEN::disabled", "KEYGEN::keytype", "KEYGEN::name", "LABEL::accesskey", "LABEL::for", "LEGEND::accesskey", "LEGEND::align", "LI::type", "LI::value", "LINK::sizes", "MAP::name", "MENU::compact", "MENU::label", "MENU::type", "METER::high", "METER::low", "METER::max", "METER::min", "METER::value", "OBJECT::typemustmatch", "OL::compact", "OL::reversed", "OL::start", "OL::type", "OPTGROUP::disabled", "OPTGROUP::label", "OPTION::disabled", "OPTION::label", "OPTION::selected", "OPTION::value", "OUTPUT::for", "OUTPUT::name", "P::align", "PRE::width", "PROGRESS::max", "PROGRESS::min", "PROGRESS::value", "SELECT::autocomplete", "SELECT::disabled", "SELECT::multiple", "SELECT::name", "SELECT::required", "SELECT::size", "SELECT::tabindex", "SOURCE::type", "TABLE::align", "TABLE::bgcolor", "TABLE::border", "TABLE::cellpadding", "TABLE::cellspacing", "TABLE::frame", "TABLE::rules", "TABLE::summary", "TABLE::width", "TBODY::align", "TBODY::char", "TBODY::charoff", "TBODY::valign", "TD::abbr", "TD::align", "TD::axis", "TD::bgcolor", "TD::char", "TD::charoff", "TD::colspan", "TD::headers", "TD::height", "TD::nowrap", "TD::rowspan", "TD::scope", "TD::valign", "TD::width", "TEXTAREA::accesskey", "TEXTAREA::autocomplete", "TEXTAREA::cols", "TEXTAREA::disabled", "TEXTAREA::inputmode", "TEXTAREA::name", "TEXTAREA::placeholder", "TEXTAREA::readonly", "TEXTAREA::required", "TEXTAREA::rows", "TEXTAREA::tabindex", "TEXTAREA::wrap", "TFOOT::align", "TFOOT::char", "TFOOT::charoff", "TFOOT::valign", "TH::abbr", "TH::align", "TH::axis", "TH::bgcolor", "TH::char", "TH::charoff", "TH::colspan", "TH::headers", "TH::height", "TH::nowrap", "TH::rowspan", "TH::scope", "TH::valign", "TH::width", "THEAD::align", "THEAD::char", "THEAD::charoff", "THEAD::valign", "TR::align", "TR::bgcolor", "TR::char", "TR::charoff", "TR::valign", "TRACK::default", "TRACK::kind", "TRACK::label", "TRACK::srclang", "UL::compact", "UL::type", "VIDEO::controls", "VIDEO::height", "VIDEO::loop", "VIDEO::mediagroup", "VIDEO::muted", "VIDEO::preload", "VIDEO::width"]), [P.String]); |
| C.List_2Vk = Isolate.makeConstantList([0, 0, 32776, 33792, 1, 10240, 0, 0]); |
| C.List_A_FORM = Isolate.makeConstantList(["A", "FORM"]); |
| C.List_BSc = Isolate.makeConstantList(["A::href", "FORM::action"]); |
| C.List_CVk = Isolate.makeConstantList([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]); |
| C.List_JYB = Isolate.makeConstantList([0, 0, 26624, 1023, 65534, 2047, 65534, 2047]); |
| C.List_WnV = Isolate.makeConstantList(["/", "\\"]); |
| C.List_cSk = Isolate.makeConstantList(["/"]); |
| C.List_ego = Isolate.makeConstantList(["HEAD", "AREA", "BASE", "BASEFONT", "BR", "COL", "COLGROUP", "EMBED", "FRAME", "FRAMESET", "HR", "IMAGE", "IMG", "INPUT", "ISINDEX", "LINK", "META", "PARAM", "SOURCE", "STYLE", "TITLE", "WBR"]); |
| C.List_empty0 = H.setRuntimeTypeInfo(Isolate.makeConstantList([]), [P.String]); |
| C.List_empty = Isolate.makeConstantList([]); |
| C.List_gRj = Isolate.makeConstantList([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]); |
| C.List_h4r = Isolate.makeConstantList(["A::accesskey", "A::coords", "A::hreflang", "A::name", "A::shape", "A::tabindex", "A::target", "A::type", "FORM::accept", "FORM::autocomplete", "FORM::enctype", "FORM::method", "FORM::name", "FORM::novalidate", "FORM::target"]); |
| C.List_nxB = Isolate.makeConstantList([0, 0, 24576, 1023, 65534, 34815, 65534, 18431]); |
| C.List_qNA = Isolate.makeConstantList([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]); |
| C.List_qg40 = Isolate.makeConstantList([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]); |
| C.List_qg4 = Isolate.makeConstantList([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]); |
| C.List_wSV = H.setRuntimeTypeInfo(Isolate.makeConstantList(["bind", "if", "ref", "repeat", "syntax"]), [P.String]); |
| C.List_yrN = H.setRuntimeTypeInfo(Isolate.makeConstantList(["A::href", "AREA::href", "BLOCKQUOTE::cite", "BODY::background", "COMMAND::icon", "DEL::cite", "FORM::action", "IMG::src", "INPUT::src", "INS::cite", "Q::cite", "VIDEO::poster"]), [P.String]); |
| C.Utf8Codec_false = new P.Utf8Codec(false); |
| $.Primitives_mirrorFunctionCacheName = "$cachedFunction"; |
| $.Primitives_mirrorInvokeCacheName = "$cachedInvocation"; |
| $.Closure_functionCounter = 0; |
| $.BoundClosure_selfFieldNameCache = null; |
| $.BoundClosure_receiverFieldNameCache = null; |
| $.getTagFunction = null; |
| $.alternateTagFunction = null; |
| $.prototypeForTagFunction = null; |
| $.dispatchRecordsForInstanceTags = null; |
| $.interceptorsForUncacheableTags = null; |
| $.initNativeDispatchFlag = null; |
| $._nextCallback = null; |
| $._lastCallback = null; |
| $._lastPriorityCallback = null; |
| $._isInCallbackLoop = false; |
| $.Zone__current = C.C__RootZone; |
| $.Expando__keyCount = 0; |
| $.Element__parseDocument = null; |
| $.Element__parseRange = null; |
| $.Element__defaultValidator = null; |
| $.Element__defaultSanitizer = null; |
| $.Device__isOpera = null; |
| $.Device__isWebKit = null; |
| $ = null; |
| 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]($globals$, $); |
| init.deferredInitialized[hunkHash] = true; |
| }; |
| init.deferredLibraryUris = {}; |
| init.deferredLibraryHashes = {}; |
| // Empty type-to-interceptor map. |
| (function(lazies) { |
| for (var i = 0; i < lazies.length;) { |
| var fieldName = lazies[i++]; |
| var getterName = lazies[i++]; |
| var staticName = lazies[i++]; |
| var lazyValue = lazies[i++]; |
| Isolate.$lazy(fieldName, getterName, lazyValue, staticName); |
| } |
| })(["IsolateNatives_thisScript", "$get$IsolateNatives_thisScript", "thisScript", function() { |
| return H.IsolateNatives_computeThisScript(); |
| }, "IsolateNatives_workerIds", "$get$IsolateNatives_workerIds", "workerIds", function() { |
| return H.setRuntimeTypeInfo(new P.Expando(null), [P.$int]); |
| }, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", "noSuchMethodPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({toString: function() { |
| return "$receiver$"; |
| }})); |
| }, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", "notClosurePattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({$method$: null, toString: function() { |
| return "$receiver$"; |
| }})); |
| }, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", "nullCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null)); |
| }, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", "nullLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| null.$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", "undefinedCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0)); |
| }, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", "undefinedLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| (void 0).$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", "nullPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null)); |
| }, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", "nullLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| null.$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", "undefinedPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0)); |
| }, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", "undefinedLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| (void 0).$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "_AsyncRun_scheduleImmediateClosure", "$get$_AsyncRun_scheduleImmediateClosure", "scheduleImmediateClosure", function() { |
| return P._AsyncRun__initializeScheduleImmediate(); |
| }, "_toStringVisiting", "$get$_toStringVisiting", "_toStringVisiting", function() { |
| return []; |
| }, "_Html5NodeValidator__allowedElements", "$get$_Html5NodeValidator__allowedElements", "_allowedElements", function() { |
| return P.LinkedHashSet_LinkedHashSet$from(["A", "ABBR", "ACRONYM", "ADDRESS", "AREA", "ARTICLE", "ASIDE", "AUDIO", "B", "BDI", "BDO", "BIG", "BLOCKQUOTE", "BR", "BUTTON", "CANVAS", "CAPTION", "CENTER", "CITE", "CODE", "COL", "COLGROUP", "COMMAND", "DATA", "DATALIST", "DD", "DEL", "DETAILS", "DFN", "DIR", "DIV", "DL", "DT", "EM", "FIELDSET", "FIGCAPTION", "FIGURE", "FONT", "FOOTER", "FORM", "H1", "H2", "H3", "H4", "H5", "H6", "HEADER", "HGROUP", "HR", "I", "IFRAME", "IMG", "INPUT", "INS", "KBD", "LABEL", "LEGEND", "LI", "MAP", "MARK", "MENU", "METER", "NAV", "NOBR", "OL", "OPTGROUP", "OPTION", "OUTPUT", "P", "PRE", "PROGRESS", "Q", "S", "SAMP", "SECTION", "SELECT", "SMALL", "SOURCE", "SPAN", "STRIKE", "STRONG", "SUB", "SUMMARY", "SUP", "TABLE", "TBODY", "TD", "TEXTAREA", "TFOOT", "TH", "THEAD", "TIME", "TR", "TRACK", "TT", "U", "UL", "VAR", "VIDEO", "WBR"], null); |
| }, "_Html5NodeValidator__attributeValidators", "$get$_Html5NodeValidator__attributeValidators", "_attributeValidators", function() { |
| return P.LinkedHashMap__makeEmpty(); |
| }, "_urlRegex", "$get$_urlRegex", "_urlRegex", function() { |
| return P.RegExp_RegExp("http://[^ ]*", true, false); |
| }, "_escaper", "$get$_escaper", "_escaper", function() { |
| return new P.HtmlEscape(C.HtmlEscapeMode_p2v); |
| }, "CssClassSetImpl__validTokenRE", "$get$CssClassSetImpl__validTokenRE", "_validTokenRE", function() { |
| return P.RegExp_RegExp("^\\S+$", true, false); |
| }, "context", "$get$context", "context", function() { |
| return new F.Context($.$get$Style_platform(), null); |
| }, "Style_posix", "$get$Style_posix", "posix", function() { |
| return new Z.PosixStyle("posix", "/", C.List_cSk, P.RegExp_RegExp("/", true, false), P.RegExp_RegExp("[^/]$", true, false), P.RegExp_RegExp("^/", true, false), null); |
| }, "Style_windows", "$get$Style_windows", "windows", function() { |
| return new T.WindowsStyle("windows", "\\", C.List_WnV, P.RegExp_RegExp("[/\\\\]", true, false), P.RegExp_RegExp("[^/\\\\]$", true, false), P.RegExp_RegExp("^(\\\\\\\\[^\\\\]+\\\\[^\\\\/]+|[a-zA-Z]:[/\\\\])", true, false), P.RegExp_RegExp("^[/\\\\](?![/\\\\])", true, false)); |
| }, "Style_url", "$get$Style_url", "url", function() { |
| return new E.UrlStyle("url", "/", C.List_cSk, P.RegExp_RegExp("/", true, false), P.RegExp_RegExp("(^[a-zA-Z][-+.a-zA-Z\\d]*://|[^/])$", true, false), P.RegExp_RegExp("[a-zA-Z][-+.a-zA-Z\\d]*://[^/]*", true, false), P.RegExp_RegExp("^/", true, false)); |
| }, "Style_platform", "$get$Style_platform", "platform", function() { |
| return S.Style__getPlatformStyle(); |
| }]); |
| Isolate = Isolate.$finishIsolateConstructor(Isolate); |
| $ = new Isolate(); |
| init.metadata = [null]; |
| init.types = [{func: 1, args: [,]}, {func: 1}, {func: 1, void: true}, {func: 1, args: [,,]}, {func: 1, void: true, args: [{func: 1, void: true}]}, {func: 1, args: [, P.StackTrace]}, {func: 1, void: true, args: [P.Object], opt: [P.StackTrace]}, {func: 1, args: [,], opt: [,]}, {func: 1, ret: P.String, args: [P.$int]}, {func: 1, ret: P.String, args: [P.String]}, {func: 1, ret: P.bool, args: [W.Element, P.String, P.String, W._Html5NodeValidator]}, {func: 1, args: [, P.String]}, {func: 1, args: [P.String]}, {func: 1, args: [{func: 1, void: true}]}, {func: 1, args: [P.$int,,]}, {func: 1, void: true, args: [,], opt: [P.StackTrace]}, {func: 1, ret: P.bool}, {func: 1, args: [P.bool]}, {func: 1, void: true, args: [, P.StackTrace]}, {func: 1, ret: P.$int, args: [, P.$int]}, {func: 1, void: true, args: [P.$int, P.$int]}, {func: 1, args: [P.Symbol,,]}, {func: 1, ret: P.$int, args: [,,]}, {func: 1, void: true, args: [P.String]}, {func: 1, void: true, args: [P.String], opt: [,]}, {func: 1, ret: P.$int, args: [P.$int, P.$int]}, {func: 1, args: [W.HttpRequest]}, {func: 1, void: true, args: [W.Node, W.Node]}, {func: 1, ret: P.String, args: [P.String], named: {color: null}}, {func: 1, ret: X.PackageSummary, args: [P.Map]}, {func: 1, ret: X.LibrarySummary, args: [P.Map]}, {func: 1, ret: X.MessageSummary, args: [P.Map]}]; |
| 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 = map(); |
| init.getTypeFromName = function(name) { |
| return init.allClasses[name]; |
| }; |
| init.interceptorsByTag = map(); |
| init.leafTags = map(); |
| init.finishedClasses = map(); |
| 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; |
| Isolate.makeConstantList = oldIsolate.makeConstantList; |
| Isolate.functionThatReturnsNull = oldIsolate.functionThatReturnsNull; |
| return Isolate; |
| }; |
| } |
| !function() { |
| var intern = function(s) { |
| var o = {}; |
| o[s] = 1; |
| return Object.keys(convertToFastObject(o))[0]; |
| }; |
| init.getIsolateTag = function(name) { |
| return intern("___dart_" + name + init.isolateTag); |
| }; |
| var tableProperty = "___dart_isolate_tags_"; |
| var usedProperties = Object[tableProperty] || (Object[tableProperty] = Object.create(null)); |
| var rootProperty = "_ZxYxX"; |
| for (var i = 0;; i++) { |
| var property = intern(rootProperty + "_" + i + "_"); |
| if (!(property in usedProperties)) { |
| usedProperties[property] = 1; |
| init.isolateTag = property; |
| break; |
| } |
| } |
| init.dispatchPropertyName = init.getIsolateTag("dispatch_record"); |
| }(); |
| // BEGIN invoke [main]. |
| (function(callback) { |
| if (typeof document === "undefined") { |
| callback(null); |
| return; |
| } |
| if (typeof document.currentScript != 'undefined') { |
| callback(document.currentScript); |
| return; |
| } |
| var scripts = document.scripts; |
| function onLoad(event) { |
| for (var i = 0; i < scripts.length; ++i) |
| scripts[i].removeEventListener("load", onLoad, false); |
| callback(event.target); |
| } |
| for (var i = 0; i < scripts.length; ++i) |
| scripts[i].addEventListener("load", onLoad, false); |
| })(function(currentScript) { |
| init.currentScript = currentScript; |
| if (typeof dartMainRunner === "function") |
| dartMainRunner(function(a) { |
| H.startRootIsolate(K.messages__main$closure(), a); |
| }, []); |
| else |
| (function(a) { |
| H.startRootIsolate(K.messages__main$closure(), a); |
| })([]); |
| }); |
| // END invoke [main]. |
| })(); |
| |
| //# sourceMappingURL=messages_widget.js.map |