| // Generated by dart2js, the Dart to JavaScript compiler version: 2.0.0-dev.20.0. |
| // 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 deferred library |
| // is loaded. It should load and eval the javascript of `uri`, and call |
| // successCallback. If it fails to do so, it should call errorCallback with |
| // an error. |
| // |
| // defaultPackagesBase: |
| // Override the location where `package:` uris are resolved from. By default |
| // they are resolved under "packages/" from the current window location. |
| (function() { |
| // /* ::norenaming:: */ |
| var supportsDirectProtoAccess = function() { |
| var cls = function() { |
| }; |
| cls.prototype = {p: {}}; |
| var object = new cls(); |
| if (!(object.__proto__ && object.__proto__.p === cls.prototype.p)) |
| return false; |
| try { |
| if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0) |
| return true; |
| if (typeof version == "function" && version.length == 0) { |
| var v = version(); |
| if (/^\d+\.\d+\.\d+\.\d+$/.test(v)) |
| return true; |
| } |
| } catch (_) { |
| } |
| return false; |
| }(); |
| function 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, metadataOffset, 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() { |
| if (!supportsDirectProtoAccess) |
| return; |
| 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 totalParameterCount = requiredParameterCount + optionalParameterCount; |
| var isIntercepted = totalParameterCount != funcs[0].length; |
| var functionTypeIndex = array[2]; |
| if (typeof functionTypeIndex == "number") |
| array[2] = functionTypeIndex + typesOffset; |
| if (metadataOffset > 0) { |
| var position = 3; |
| for (var i = 0; i < optionalParameterCount; i++) { |
| if (typeof array[position] == "number") |
| array[position] = array[position] + metadataOffset; |
| position++; |
| } |
| for (var i = 0; i < totalParameterCount; i++) { |
| array[position] = array[position] + metadataOffset; |
| position++; |
| if (false) { |
| var metaArray = array[position]; |
| for (var j = 0; j < metaArray.length; j++) |
| metaArray[j] = metaArray[j] + metadataOffset; |
| position++; |
| } |
| } |
| } |
| 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; |
| } |
| var isReflectable = array.length > unmangledNameIndex; |
| if (isReflectable) { |
| funcs[0].$reflectable = 1; |
| funcs[0].$reflectionInfo = array; |
| for (var i = 1; i < funcs.length; i++) { |
| funcs[i].$reflectable = 2; |
| funcs[i].$reflectionInfo = array; |
| } |
| var mangledNames = isStatic ? init.mangledGlobalNames : init.mangledNames; |
| var unmangledName = array[unmangledNameIndex]; |
| var reflectionName = unmangledName; |
| if (getterStubName) |
| mangledNames[getterStubName] = reflectionName; |
| if (isSetter) |
| reflectionName += "="; |
| else if (!isGetter) |
| reflectionName += ":" + (requiredParameterCount + optionalParameterCount); |
| mangledNames[name] = reflectionName; |
| funcs[0].$reflectionName = reflectionName; |
| for (var i = unmangledNameIndex + 1; i < array.length; i++) |
| array[i] = array[i] + metadataOffset; |
| funcs[0].$metadataIndex = unmangledNameIndex + 1; |
| if (optionalParameterCount) |
| prototype[unmangledName + "*"] = funcs[0]; |
| } |
| } |
| Function.prototype.call$1 = function(a) { |
| return this(a); |
| }; |
| Function.prototype.call$2 = function(a, b) { |
| return this(a, b); |
| }; |
| Function.prototype.call$0 = function() { |
| return this(); |
| }; |
| Function.prototype.call$3 = function(a, b, c) { |
| return this(a, b, c); |
| }; |
| Function.prototype.call$4 = function(a, b, c, d) { |
| return this(a, b, c, d); |
| }; |
| Function.prototype.call$5 = function(a, b, c, d, e) { |
| return this(a, b, c, d, e); |
| }; |
| Function.prototype.call$6 = function(a, b, c, d, e, f) { |
| return this(a, b, c, d, e, f); |
| }; |
| 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, $constructor, 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)))); |
| } |
| $constructor = object.constructor; |
| interceptor = $constructor == null ? null : $constructor[$.$get$JS_INTEROP_INTERCEPTOR_TAG()]; |
| if (interceptor != null) |
| return interceptor; |
| interceptor = H.lookupAndCacheInterceptor(object); |
| if (interceptor != null) |
| return interceptor; |
| if (typeof object == "function") |
| return C.JavaScriptFunction_methods; |
| proto = Object.getPrototypeOf(object); |
| if (proto == null) |
| return C.PlainJavaScriptObject_methods; |
| if (proto === Object.prototype) |
| return C.PlainJavaScriptObject_methods; |
| if (typeof $constructor == "function") { |
| Object.defineProperty($constructor, $.$get$JS_INTEROP_INTERCEPTOR_TAG(), {value: C.UnknownJavaScriptObject_methods, enumerable: false, writable: true, configurable: true}); |
| return C.UnknownJavaScriptObject_methods; |
| } |
| return C.UnknownJavaScriptObject_methods; |
| }, |
| 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); |
| }], |
| noSuchMethod$1: ["super$Interceptor$noSuchMethod", function(receiver, invocation) { |
| throw H.wrapException(P.NoSuchMethodError$(receiver, invocation.get$memberName(), invocation.get$positionalArguments(), invocation.get$namedArguments(), null)); |
| }], |
| "%": "MediaError|PushMessageData|SVGAnimatedLength|SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedString|SVGAnimatedTransformList" |
| }, |
| 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; |
| }, |
| noSuchMethod$1: function(receiver, invocation) { |
| return this.super$Interceptor$noSuchMethod(receiver, invocation); |
| } |
| }, |
| JavaScriptObject: { |
| "^": "Interceptor;", |
| get$hashCode: function(receiver) { |
| return 0; |
| }, |
| toString$0: ["super$JavaScriptObject$toString", function(receiver) { |
| return String(receiver); |
| }], |
| waitUntilDone$0: function(receiver) { |
| return receiver.waitUntilDone(); |
| }, |
| resume$0: function(receiver) { |
| return receiver.resume(); |
| }, |
| $isJSObject: 1 |
| }, |
| PlainJavaScriptObject: { |
| "^": "JavaScriptObject;" |
| }, |
| UnknownJavaScriptObject: { |
| "^": "JavaScriptObject;" |
| }, |
| JavaScriptFunction: { |
| "^": "JavaScriptObject;", |
| toString$0: function(receiver) { |
| var dartClosure = receiver[$.$get$DART_CLOSURE_PROPERTY_NAME()]; |
| return dartClosure == null ? this.super$JavaScriptObject$toString(receiver) : J.toString$0$(dartClosure); |
| }, |
| $signature: function() { |
| return {func: 1, opt: [,,,,,,,,,,,,,,,,]}; |
| } |
| }, |
| JSArray: { |
| "^": "Interceptor;$ti", |
| 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) { |
| var t1; |
| this.checkGrowable$1(receiver, "removeAt"); |
| t1 = receiver.length; |
| if (index >= t1) |
| throw H.wrapException(P.RangeError$value(index, null, null)); |
| return receiver.splice(index, 1)[0]; |
| }, |
| insert$2: function(receiver, index, value) { |
| var t1; |
| this.checkGrowable$1(receiver, "insert"); |
| t1 = receiver.length; |
| if (index > t1) |
| 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(); |
| }, |
| addAll$1: function(receiver, collection) { |
| var t1; |
| this.checkGrowable$1(receiver, "addAll"); |
| for (t1 = J.get$iterator$ax(collection); t1.moveNext$0();) |
| receiver.push(t1.get$current()); |
| }, |
| 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 new H.MappedListIterable(receiver, f, [H.getTypeArgumentByIndex(receiver, 0), 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); |
| }, |
| join$0: function($receiver) { |
| return this.join$1($receiver, ""); |
| }, |
| skip$1: function(receiver, n) { |
| return H.SubListIterable$(receiver, n, null, H.getTypeArgumentByIndex(receiver, 0)); |
| }, |
| fold$2: function(receiver, initialValue, combine) { |
| var $length, value, i; |
| $length = receiver.length; |
| for (value = initialValue, i = 0; i < $length; ++i) { |
| value = combine.call$2(value, receiver[i]); |
| if (receiver.length !== $length) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| return value; |
| }, |
| 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 (typeof start !== "number" || Math.floor(start) !== start) |
| throw H.wrapException(H.argumentErrorValue(start)); |
| if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, "start", null)); |
| if (end == null) |
| end = receiver.length; |
| else { |
| if (typeof end !== "number" || Math.floor(end) !== end) |
| throw H.wrapException(H.argumentErrorValue(end)); |
| 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()); |
| }, |
| get$single: function(receiver) { |
| var t1 = receiver.length; |
| if (t1 === 1) { |
| if (0 >= t1) |
| return H.ioore(receiver, 0); |
| return receiver[0]; |
| } |
| if (t1 === 0) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| throw H.wrapException(H.IterableElementError_tooMany()); |
| }, |
| setRange$4: function(receiver, start, end, iterable, skipCount) { |
| var $length, t1, i, t2; |
| this.checkMutable$1(receiver, "setRange"); |
| P.RangeError_checkValidRange(start, end, receiver.length, null, null, null); |
| if (typeof start !== "number") |
| return H.iae(start); |
| $length = end - start; |
| if ($length === 0) |
| return; |
| t1 = J.getInterceptor$n(skipCount); |
| if (t1.$lt(skipCount, 0)) |
| H.throwExpression(P.RangeError$range(skipCount, 0, null, "skipCount", null)); |
| if (t1.$add(skipCount, $length) > iterable.length) |
| throw H.wrapException(H.IterableElementError_tooFew()); |
| if (t1.$lt(skipCount, start)) |
| for (i = $length - 1; i >= 0; --i) { |
| t2 = t1.$add(skipCount, i); |
| if (t2 >>> 0 !== t2 || t2 >= iterable.length) |
| return H.ioore(iterable, t2); |
| receiver[start + i] = iterable[t2]; |
| } |
| else |
| for (i = 0; i < $length; ++i) { |
| t2 = t1.$add(skipCount, i); |
| if (t2 >>> 0 !== t2 || t2 >= iterable.length) |
| return H.ioore(iterable, t2); |
| receiver[start + i] = iterable[t2]; |
| } |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, |
| fillRange$3: function(receiver, start, end, fillValue) { |
| var i; |
| this.checkMutable$1(receiver, "fill range"); |
| P.RangeError_checkValidRange(start, end, receiver.length, null, null, null); |
| for (i = start; i < end; ++i) |
| receiver[i] = fillValue; |
| }, |
| replaceRange$3: function(receiver, start, end, replacement) { |
| var removeLength, insertLength, t1, delta, insertEnd, newLength; |
| this.checkGrowable$1(receiver, "replaceRange"); |
| P.RangeError_checkValidRange(start, end, receiver.length, null, null, null); |
| replacement = C.JSString_methods.toList$0(replacement); |
| removeLength = J.$sub$n(end, start); |
| insertLength = replacement.length; |
| t1 = J.getInterceptor$ns(start); |
| if (removeLength >= insertLength) { |
| delta = removeLength - insertLength; |
| insertEnd = t1.$add(start, insertLength); |
| newLength = receiver.length - delta; |
| this.setRange$3(receiver, start, insertEnd, replacement); |
| if (delta !== 0) { |
| this.setRange$4(receiver, insertEnd, newLength, receiver, end); |
| this.set$length(receiver, newLength); |
| } |
| } else { |
| newLength = receiver.length + (insertLength - removeLength); |
| insertEnd = t1.$add(start, insertLength); |
| this.set$length(receiver, newLength); |
| this.setRange$4(receiver, insertEnd, newLength, receiver, end); |
| this.setRange$3(receiver, start, insertEnd, replacement); |
| } |
| }, |
| indexOf$2: function(receiver, element, start) { |
| var i; |
| if (start >= receiver.length) |
| return -1; |
| if (start < 0) |
| start = 0; |
| for (i = start; i < receiver.length; ++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 == null) |
| startIndex = receiver.length - 1; |
| else { |
| if (startIndex < 0) |
| return -1; |
| t1 = receiver.length; |
| if (startIndex >= t1) |
| startIndex = t1 - 1; |
| } |
| for (i = startIndex; i >= 0; --i) { |
| if (i >>> 0 !== i || i >= receiver.length) |
| return H.ioore(receiver, i); |
| if (J.$eq$(receiver[i], element)) |
| return i; |
| } |
| return -1; |
| }, |
| lastIndexOf$1: function($receiver, element) { |
| return this.lastIndexOf$2($receiver, element, null); |
| }, |
| 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 new J.ArrayIterator(receiver, receiver.length, 0, null); |
| }, |
| get$hashCode: function(receiver) { |
| return H.Primitives_objectHashCode(receiver); |
| }, |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| set$length: function(receiver, newLength) { |
| this.checkGrowable$1(receiver, "set length"); |
| if (typeof newLength !== "number" || Math.floor(newLength) !== newLength) |
| throw H.wrapException(P.ArgumentError$value(newLength, "newLength", null)); |
| 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 (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)); |
| receiver[index] = value; |
| }, |
| $isJSIndexable: 1, |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null, |
| 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; |
| }, |
| JSArray_markUnmodifiableList: function(list) { |
| list.fixed$length = Array; |
| list.immutable$list = Array; |
| return list; |
| } |
| } |
| }, |
| JSUnmodifiableArray: { |
| "^": "JSArray;$ti" |
| }, |
| ArrayIterator: { |
| "^": "Object;__interceptors$_iterable,__interceptors$_length,_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(H.throwConcurrentModificationError(t1)); |
| t2 = this._index; |
| if (t2 >= $length) { |
| this.__interceptors$_current = null; |
| return false; |
| } |
| this.__interceptors$_current = t1[t2]; |
| this._index = t2 + 1; |
| return true; |
| } |
| }, |
| JSNumber: { |
| "^": "Interceptor;", |
| toRadixString$1: function(receiver, radix) { |
| var result, match, t1, exponent; |
| 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; |
| }, |
| $mul: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver * other; |
| }, |
| $mod: function(receiver, other) { |
| var result = receiver % other; |
| if (result === 0) |
| return 0; |
| if (result > 0) |
| return result; |
| if (other < 0) |
| return result - other; |
| else |
| return result + other; |
| }, |
| $tdiv: function(receiver, other) { |
| if ((receiver | 0) === receiver) |
| if (other >= 1 || false) |
| return receiver / other | 0; |
| return this._tdivSlow$1(receiver, other); |
| }, |
| _tdivFast$1: function(receiver, other) { |
| return (receiver | 0) === receiver ? receiver / other | 0 : this._tdivSlow$1(receiver, other); |
| }, |
| _tdivSlow$1: function(receiver, other) { |
| var quotient = receiver / other; |
| if (quotient >= -2147483648 && quotient <= 2147483647) |
| return quotient | 0; |
| if (quotient > 0) { |
| if (quotient !== 1 / 0) |
| return Math.floor(quotient); |
| } else if (quotient > -1 / 0) |
| return Math.ceil(quotient); |
| throw H.wrapException(new P.UnsupportedError("Result of truncating division is " + H.S(quotient) + ": " + H.S(receiver) + " ~/ " + other)); |
| }, |
| $shl: function(receiver, other) { |
| if (other < 0) |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return other > 31 ? 0 : receiver << other >>> 0; |
| }, |
| $shr: function(receiver, other) { |
| var t1; |
| if (other < 0) |
| throw H.wrapException(H.argumentErrorValue(other)); |
| if (receiver > 0) |
| t1 = other > 31 ? 0 : receiver >>> other; |
| else { |
| t1 = other > 31 ? 31 : other; |
| t1 = receiver >> t1 >>> 0; |
| } |
| return t1; |
| }, |
| _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; |
| }, |
| $and: function(receiver, other) { |
| return (receiver & other) >>> 0; |
| }, |
| $xor: 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; |
| }, |
| $le: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver <= other; |
| }, |
| $ge: function(receiver, other) { |
| if (typeof other !== "number") |
| throw H.wrapException(H.argumentErrorValue(other)); |
| return receiver >= other; |
| }, |
| $isnum: 1 |
| }, |
| JSInt: { |
| "^": "JSNumber;", |
| $isint: 1, |
| $isnum: 1 |
| }, |
| JSDouble: { |
| "^": "JSNumber;", |
| $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) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver.charCodeAt(index); |
| }, |
| _codeUnitAt$1: function(receiver, index) { |
| if (index >= receiver.length) |
| throw H.wrapException(H.diagnoseIndexError(receiver, index)); |
| return receiver.charCodeAt(index); |
| }, |
| allMatches$2: function(receiver, string, start) { |
| var t1; |
| H.checkString(string); |
| t1 = J.get$length$asx(string); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| t1 = start > t1; |
| if (t1) |
| throw H.wrapException(P.RangeError$range(start, 0, J.get$length$asx(string), 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, t2, i; |
| t1 = J.getInterceptor$n(start); |
| if (t1.$lt(start, 0) || t1.$gt(start, string.length)) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| t2 = receiver.length; |
| if (t1.$add(start, t2) > string.length) |
| return; |
| for (i = 0; i < t2; ++i) |
| if (this.codeUnitAt$1(string, t1.$add(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; |
| 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) { |
| return H.stringReplaceAllUnchecked(receiver, from, to); |
| }, |
| replaceFirst$3: function(receiver, from, to, startIndex) { |
| P.RangeError_checkValueInInterval(startIndex, 0, receiver.length, "startIndex", null); |
| return H.stringReplaceFirstUnchecked(receiver, from, to, startIndex); |
| }, |
| replaceFirst$2: function($receiver, from, to) { |
| return this.replaceFirst$3($receiver, from, to, 0); |
| }, |
| split$1: function(receiver, pattern) { |
| var t1 = H.setRuntimeTypeInfo(receiver.split(pattern), [P.String]); |
| return t1; |
| }, |
| replaceRange$3: function(receiver, start, end, 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 t1, endIndex; |
| H.checkInt(index); |
| t1 = J.getInterceptor$n(index); |
| if (t1.$lt(index, 0) || t1.$gt(index, receiver.length)) |
| throw H.wrapException(P.RangeError$range(index, 0, receiver.length, null, null)); |
| if (typeof pattern === "string") { |
| endIndex = t1.$add(index, pattern.length); |
| if (endIndex > receiver.length) |
| return false; |
| return pattern === receiver.substring(index, endIndex); |
| } |
| return J.matchAsPrefix$2$s(pattern, receiver, index) != null; |
| }, |
| startsWith$1: 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); |
| }, |
| 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 (typeof times !== "number") |
| return H.iae(times); |
| 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; |
| }, |
| padRight$2: function(receiver, width, padding) { |
| var delta = J.$sub$n(width, receiver.length); |
| if (J.$le$n(delta, 0)) |
| return receiver; |
| return receiver + this.$mul(padding, delta); |
| }, |
| padRight$1: function($receiver, width) { |
| return this.padRight$2($receiver, width, " "); |
| }, |
| get$codeUnits: function(receiver) { |
| return new H.CodeUnits(receiver); |
| }, |
| indexOf$2: function(receiver, pattern, start) { |
| var t1; |
| if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, null, null)); |
| t1 = receiver.indexOf(pattern, start); |
| return t1; |
| }, |
| 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 (typeof start !== "number" || Math.floor(start) !== start) |
| throw H.wrapException(H.argumentErrorValue(start)); |
| else if (start < 0 || start > receiver.length) |
| throw H.wrapException(P.RangeError$range(start, 0, receiver.length, null, null)); |
| t1 = pattern.length; |
| t2 = receiver.length; |
| if (start + t1 > t2) |
| start = t2 - t1; |
| return receiver.lastIndexOf(pattern, start); |
| }, |
| lastIndexOf$1: 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); |
| hash ^= hash >> 6; |
| } |
| hash = 536870911 & hash + ((67108863 & hash) << 3); |
| hash ^= hash >> 11; |
| return 536870911 & hash + ((16383 & hash) << 15); |
| }, |
| 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, |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $isString: 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 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; |
| } |
| } |
| } |
| }], ["dart._internal", "dart:_internal",, H, { |
| "^": "", |
| hexDigitValue: function(char) { |
| var digit, letter; |
| digit = char ^ 48; |
| if (digit <= 9) |
| return digit; |
| letter = char | 32; |
| if (97 <= letter && letter <= 102) |
| return letter - 87; |
| return -1; |
| }, |
| _checkCount: function(count) { |
| if (typeof count !== "number" || Math.floor(count) !== count) |
| throw H.wrapException(P.ArgumentError$value(count, "count", "is not an integer")); |
| if (count < 0) |
| H.throwExpression(P.RangeError$range(count, 0, null, "count", null)); |
| return count; |
| }, |
| 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"); |
| }, |
| 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); |
| }, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $asList: function() { |
| return [P.int]; |
| } |
| }, |
| EfficientLengthIterable: { |
| "^": "Iterable;", |
| $asEfficientLengthIterable: null |
| }, |
| ListIterable: { |
| "^": "EfficientLengthIterable;$ti", |
| get$iterator: function(_) { |
| return new H.ListIterator(this, this.get$length(this), 0, null); |
| }, |
| forEach$1: function(_, action) { |
| var $length, i; |
| $length = this.get$length(this); |
| for (i = 0; i < $length; ++i) { |
| action.call$1(this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| 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, t1, i; |
| $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)); |
| for (t1 = first, i = 1; i < $length; ++i) { |
| t1 = t1 + separator + H.S(this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| } else { |
| for (i = 0, t1 = ""; i < $length; ++i) { |
| t1 += H.S(this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| } |
| }, |
| join$0: function($receiver) { |
| return this.join$1($receiver, ""); |
| }, |
| map$1: function(_, f) { |
| return new H.MappedListIterable(this, f, [H.getRuntimeTypeArgument(this, "ListIterable", 0), null]); |
| }, |
| fold$2: function(_, initialValue, combine) { |
| var $length, value, i; |
| $length = this.get$length(this); |
| for (value = initialValue, i = 0; i < $length; ++i) { |
| value = combine.call$2(value, this.elementAt$1(0, i)); |
| if ($length !== this.get$length(this)) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| return value; |
| }, |
| skip$1: function(_, count) { |
| return H.SubListIterable$(this, count, null, H.getRuntimeTypeArgument(this, "ListIterable", 0)); |
| }, |
| toList$1$growable: function(_, growable) { |
| var result, i, t1; |
| result = H.setRuntimeTypeInfo([], [H.getRuntimeTypeArgument(this, "ListIterable", 0)]); |
| C.JSArray_methods.set$length(result, this.get$length(this)); |
| 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); |
| } |
| }, |
| SubListIterable: { |
| "^": "ListIterable;_iterable,__internal$_start,_endOrLength,$ti", |
| SubListIterable$3: function(_iterable, _start, _endOrLength, $E) { |
| var t1, t2, t3; |
| t1 = this.__internal$_start; |
| t2 = J.getInterceptor$n(t1); |
| if (t2.$lt(t1, 0)) |
| H.throwExpression(P.RangeError$range(t1, 0, null, "start", null)); |
| t3 = this._endOrLength; |
| if (t3 != null) { |
| if (t3 < 0) |
| H.throwExpression(P.RangeError$range(t3, 0, null, "end", null)); |
| if (t2.$gt(t1, t3)) |
| throw H.wrapException(P.RangeError$range(t1, 0, t3, "start", null)); |
| } |
| }, |
| get$_endIndex: function() { |
| var $length, t1; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this._endOrLength; |
| if (t1 == null || t1 > $length) |
| return $length; |
| return t1; |
| }, |
| get$_startIndex: function() { |
| var $length, t1; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this.__internal$_start; |
| if (J.$gt$n(t1, $length)) |
| return $length; |
| return t1; |
| }, |
| get$length: function(_) { |
| var $length, t1, t2; |
| $length = J.get$length$asx(this._iterable); |
| t1 = this.__internal$_start; |
| if (J.$ge$n(t1, $length)) |
| return 0; |
| t2 = this._endOrLength; |
| if (t2 == null || t2 >= $length) { |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| return $length - t1; |
| } |
| if (typeof t2 !== "number") |
| return t2.$sub(); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| return t2 - t1; |
| }, |
| elementAt$1: function(_, index) { |
| var realIndex, t1; |
| realIndex = J.$add$ns(this.get$_startIndex(), index); |
| if (!J.$lt$n(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); |
| }, |
| skip$1: function(_, count) { |
| var newStart, t1; |
| if (J.$lt$n(count, 0)) |
| H.throwExpression(P.RangeError$range(count, 0, null, "count", null)); |
| newStart = J.$add$ns(this.__internal$_start, count); |
| t1 = this._endOrLength; |
| if (t1 != null && newStart >= t1) |
| return new H.EmptyIterable(this.$ti); |
| return H.SubListIterable$(this._iterable, newStart, t1, H.getTypeArgumentByIndex(this, 0)); |
| }, |
| toList$1$growable: function(_, growable) { |
| var start, t1, t2, end, end0, $length, result, i, t3; |
| start = this.__internal$_start; |
| t1 = this._iterable; |
| t2 = J.getInterceptor$asx(t1); |
| end = t2.get$length(t1); |
| end0 = this._endOrLength; |
| if (end0 != null && end0 < end) |
| end = end0; |
| if (typeof end !== "number") |
| return end.$sub(); |
| if (typeof start !== "number") |
| return H.iae(start); |
| $length = end - start; |
| if ($length < 0) |
| $length = 0; |
| result = H.setRuntimeTypeInfo(new Array($length), this.$ti); |
| for (i = 0; i < $length; ++i) { |
| t3 = t2.elementAt$1(t1, start + i); |
| if (i >= result.length) |
| return H.ioore(result, i); |
| result[i] = t3; |
| if (t2.get$length(t1) < end) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| return result; |
| }, |
| static: { |
| SubListIterable$: function(_iterable, _start, _endOrLength, $E) { |
| var t1 = new H.SubListIterable(_iterable, _start, _endOrLength, [$E]); |
| t1.SubListIterable$3(_iterable, _start, _endOrLength, $E); |
| return t1; |
| } |
| } |
| }, |
| ListIterator: { |
| "^": "Object;_iterable,__internal$_length,__internal$_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.__internal$_index; |
| if (t3 >= $length) { |
| this.__internal$_current = null; |
| return false; |
| } |
| this.__internal$_current = t2.elementAt$1(t1, t3); |
| ++this.__internal$_index; |
| return true; |
| } |
| }, |
| MappedIterable: { |
| "^": "Iterable;_iterable,_f,$ti", |
| get$iterator: function(_) { |
| return new H.MappedIterator(null, J.get$iterator$ax(this._iterable), this._f); |
| }, |
| get$length: function(_) { |
| return J.get$length$asx(this._iterable); |
| }, |
| get$isEmpty: function(_) { |
| return J.get$isEmpty$asx(this._iterable); |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| }, |
| static: { |
| MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { |
| if (!!J.getInterceptor(iterable).$isEfficientLengthIterable) |
| return new H.EfficientLengthMappedIterable(iterable, $function, [$S, $T]); |
| return new H.MappedIterable(iterable, $function, [$S, $T]); |
| } |
| } |
| }, |
| EfficientLengthMappedIterable: { |
| "^": "MappedIterable;_iterable,_f,$ti", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| MappedIterator: { |
| "^": "Iterator;__internal$_current,_iterator,_f", |
| moveNext$0: function() { |
| var t1 = this._iterator; |
| if (t1.moveNext$0()) { |
| this.__internal$_current = this._f.call$1(t1.get$current()); |
| return true; |
| } |
| this.__internal$_current = null; |
| return false; |
| }, |
| get$current: function() { |
| return this.__internal$_current; |
| } |
| }, |
| MappedListIterable: { |
| "^": "ListIterable;_source,_f,$ti", |
| get$length: function(_) { |
| return J.get$length$asx(this._source); |
| }, |
| elementAt$1: function(_, index) { |
| return this._f.call$1(J.elementAt$1$ax(this._source, index)); |
| }, |
| $asEfficientLengthIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $asListIterable: function($S, $T) { |
| return [$T]; |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| WhereIterable: { |
| "^": "Iterable;_iterable,_f,$ti", |
| get$iterator: function(_) { |
| return new H.WhereIterator(J.get$iterator$ax(this._iterable), this._f); |
| }, |
| map$1: function(_, f) { |
| return new H.MappedIterable(this, f, [H.getTypeArgumentByIndex(this, 0), null]); |
| } |
| }, |
| WhereIterator: { |
| "^": "Iterator;_iterator,_f", |
| moveNext$0: function() { |
| var t1, t2; |
| for (t1 = this._iterator, t2 = this._f; t1.moveNext$0();) |
| if (t2.call$1(t1.get$current()) === true) |
| return true; |
| return false; |
| }, |
| get$current: function() { |
| return this._iterator.get$current(); |
| } |
| }, |
| ExpandIterable: { |
| "^": "Iterable;_iterable,_f,$ti", |
| get$iterator: function(_) { |
| return new H.ExpandIterator(J.get$iterator$ax(this._iterable), this._f, C.C_EmptyIterator, null); |
| }, |
| $asIterable: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| ExpandIterator: { |
| "^": "Object;_iterator,_f,_currentExpansion,__internal$_current", |
| get$current: function() { |
| return this.__internal$_current; |
| }, |
| moveNext$0: function() { |
| var t1, t2, t3; |
| t1 = this._currentExpansion; |
| if (t1 == null) |
| return false; |
| for (t2 = this._iterator, t3 = this._f; !t1.moveNext$0();) { |
| this.__internal$_current = null; |
| if (t2.moveNext$0()) { |
| this._currentExpansion = null; |
| t1 = J.get$iterator$ax(t3.call$1(t2.get$current())); |
| this._currentExpansion = t1; |
| } else |
| return false; |
| } |
| this.__internal$_current = this._currentExpansion.get$current(); |
| return true; |
| } |
| }, |
| SkipIterable: { |
| "^": "Iterable;_iterable,_skipCount,$ti", |
| skip$1: function(_, count) { |
| return new H.SkipIterable(this._iterable, this._skipCount + H._checkCount(count), this.$ti); |
| }, |
| get$iterator: function(_) { |
| return new H.SkipIterator(J.get$iterator$ax(this._iterable), this._skipCount); |
| }, |
| static: { |
| SkipIterable_SkipIterable: function(iterable, count, $E) { |
| if (!!J.getInterceptor(iterable).$isEfficientLengthIterable) |
| return new H.EfficientLengthSkipIterable(iterable, H._checkCount(count), [$E]); |
| return new H.SkipIterable(iterable, H._checkCount(count), [$E]); |
| } |
| } |
| }, |
| EfficientLengthSkipIterable: { |
| "^": "SkipIterable;_iterable,_skipCount,$ti", |
| get$length: function(_) { |
| var $length = J.get$length$asx(this._iterable) - this._skipCount; |
| if ($length >= 0) |
| return $length; |
| return 0; |
| }, |
| skip$1: function(_, count) { |
| return new H.EfficientLengthSkipIterable(this._iterable, this._skipCount + H._checkCount(count), this.$ti); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null |
| }, |
| SkipIterator: { |
| "^": "Iterator;_iterator,_skipCount", |
| moveNext$0: function() { |
| var t1, i; |
| for (t1 = this._iterator, i = 0; i < this._skipCount; ++i) |
| t1.moveNext$0(); |
| this._skipCount = 0; |
| return t1.moveNext$0(); |
| }, |
| get$current: function() { |
| return this._iterator.get$current(); |
| } |
| }, |
| SkipWhileIterable: { |
| "^": "Iterable;_iterable,_f,$ti", |
| get$iterator: function(_) { |
| return new H.SkipWhileIterator(J.get$iterator$ax(this._iterable), this._f, false); |
| } |
| }, |
| SkipWhileIterator: { |
| "^": "Iterator;_iterator,_f,_hasSkipped", |
| moveNext$0: function() { |
| var t1, t2; |
| if (!this._hasSkipped) { |
| this._hasSkipped = true; |
| for (t1 = this._iterator, t2 = this._f; t1.moveNext$0();) |
| if (t2.call$1(t1.get$current()) !== true) |
| return true; |
| } |
| return this._iterator.moveNext$0(); |
| }, |
| get$current: function() { |
| return this._iterator.get$current(); |
| } |
| }, |
| EmptyIterable: { |
| "^": "EfficientLengthIterable;$ti", |
| get$iterator: function(_) { |
| return C.C_EmptyIterator; |
| }, |
| forEach$1: function(_, action) { |
| }, |
| get$isEmpty: function(_) { |
| return true; |
| }, |
| get$length: function(_) { |
| return 0; |
| }, |
| contains$1: function(_, element) { |
| return false; |
| }, |
| map$1: function(_, f) { |
| return new H.EmptyIterable([null]); |
| }, |
| skip$1: function(_, count) { |
| if (J.$lt$n(count, 0)) |
| H.throwExpression(P.RangeError$range(count, 0, null, "count", null)); |
| return this; |
| }, |
| toList$1$growable: function(_, growable) { |
| var t1 = this.$ti; |
| return growable ? H.setRuntimeTypeInfo([], t1) : H.setRuntimeTypeInfo(new Array(0), t1); |
| }, |
| toList$0: function($receiver) { |
| return this.toList$1$growable($receiver, true); |
| } |
| }, |
| EmptyIterator: { |
| "^": "Object;", |
| moveNext$0: function() { |
| return false; |
| }, |
| get$current: function() { |
| return; |
| } |
| }, |
| FixedLengthListMixin: { |
| "^": "Object;$ti", |
| set$length: function(receiver, newLength) { |
| throw H.wrapException(new P.UnsupportedError("Cannot change the length of a fixed-length list")); |
| }, |
| replaceRange$3: function(receiver, start, end, iterable) { |
| throw H.wrapException(new P.UnsupportedError("Cannot remove from a fixed-length list")); |
| } |
| }, |
| UnmodifiableListMixin: { |
| "^": "Object;$ti", |
| $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")); |
| }, |
| setRange$4: function(_, start, end, iterable, skipCount) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify an unmodifiable list")); |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, |
| replaceRange$3: function(_, start, end, iterable) { |
| throw H.wrapException(new P.UnsupportedError("Cannot remove from an unmodifiable list")); |
| }, |
| fillRange$3: function(_, start, end, fillValue) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify an unmodifiable list")); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null |
| }, |
| UnmodifiableListBase: { |
| "^": "ListBase+UnmodifiableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null |
| }, |
| ReversedListIterable: { |
| "^": "ListIterable;_source,$ti", |
| get$length: function(_) { |
| return J.get$length$asx(this._source); |
| }, |
| elementAt$1: function(_, index) { |
| var t1, t2, t3; |
| t1 = this._source; |
| t2 = J.getInterceptor$asx(t1); |
| t3 = t2.get$length(t1); |
| if (typeof index !== "number") |
| return H.iae(index); |
| return t2.elementAt$1(t1, t3 - 1 - index); |
| } |
| }, |
| Symbol: { |
| "^": "Object;__internal$_name<", |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| return other instanceof H.Symbol && J.$eq$(this.__internal$_name, other.__internal$_name); |
| }, |
| get$hashCode: function(_) { |
| var hash, t1; |
| hash = this._hashCode; |
| if (hash != null) |
| return hash; |
| t1 = J.get$hashCode$(this.__internal$_name); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| hash = 536870911 & 664597 * t1; |
| this._hashCode = hash; |
| return hash; |
| }, |
| toString$0: function(_) { |
| return 'Symbol("' + H.S(this.__internal$_name) + '")'; |
| } |
| } |
| }], ["_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; |
| }, |
| startRootIsolate: function(entry, args) { |
| var t1, t2, t3, t4, t5, rootContext; |
| t1 = {}; |
| t1.args = args; |
| if (args == null) { |
| args = []; |
| t1.args = 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); |
| t3 = P.int; |
| t2.isolates = new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [t3, H._IsolateContext]); |
| t2.managers = new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [t3, null]); |
| if (t2.isWorker === true) { |
| t4 = new H._MainManagerStub(); |
| t2.mainManager = t4; |
| self.onmessage = function(f, a) { |
| return function(e) { |
| f(a, e); |
| }; |
| }(H.IsolateNatives__processWorkerMessage, t4); |
| 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++; |
| t4 = P.LinkedHashSet_LinkedHashSet(null, null, null, t3); |
| t5 = new H.RawReceivePortImpl(0, null, false); |
| rootContext = new H._IsolateContext(t2, new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [t3, H.RawReceivePortImpl]), 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.isolates.$indexSet(0, t2, rootContext); |
| init.globalState.currentContext = rootContext; |
| if (H.functionTypeTest(entry, {func: 1, args: [P.Null]})) |
| rootContext.eval$1(new H.startRootIsolate_closure(t1, entry)); |
| else if (H.functionTypeTest(entry, {func: 1, args: [P.Null, P.Null]})) |
| 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 "' + 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 = P.int; |
| t3 = P.LinkedHashSet_LinkedHashSet(null, null, null, t2); |
| t4 = new H.RawReceivePortImpl(0, null, false); |
| context = new H._IsolateContext(t1, new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [t2, H.RawReceivePortImpl]), 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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(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")); |
| } |
| }, null, null, 4, 0, null, 31, 19], |
| 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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(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); |
| t1 = P.Exception_Exception(trace); |
| throw H.wrapException(t1); |
| } |
| }, |
| 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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(null, P.int)).serialize$1(message)); |
| }, |
| startRootIsolate_closure: { |
| "^": "Closure:1;_box_0,entry", |
| call$0: function() { |
| this.entry.call$1(this._box_0.args); |
| } |
| }, |
| startRootIsolate_closure0: { |
| "^": "Closure:1;_box_0,entry", |
| call$0: function() { |
| this.entry.call$2(this._box_0.args, 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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(null, P.int)).serialize$1(t1); |
| }, null, null, 2, 0, null, 18] |
| } |
| }, |
| _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, t2; |
| t1 = this.errorPorts; |
| if (t1._collection$_length === 0) { |
| if (this.errorsAreFatal === true && this === init.globalState.rootContext) |
| return; |
| if (self.console && self.console.error) |
| self.console.error(error, stackTrace); |
| else { |
| P.print(error); |
| if (stackTrace != null) |
| P.print(stackTrace); |
| } |
| return; |
| } |
| message = new Array(2); |
| message.fixed$length = Array; |
| message[0] = J.toString$0$(error); |
| message[1] = stackTrace == null ? null : J.toString$0$(stackTrace); |
| for (t2 = new P._LinkedHashSetIterator(t1, t1._collection$_modifications, null, null), t2._collection$_cell = t1._collection$_first; t2.moveNext$0();) |
| J.send$1$x(t2._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) { |
| e = H.unwrapException(exception); |
| 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; |
| }, |
| handleControlMessage$1: function(message) { |
| var t1 = J.getInterceptor$asx(message); |
| switch (t1.$index(message, 0)) { |
| case "pause": |
| this.addPause$2(t1.$index(message, 1), t1.$index(message, 2)); |
| break; |
| case "resume": |
| this.removePause$1(t1.$index(message, 1)); |
| break; |
| case "add-ondone": |
| this.addDoneListener$2(t1.$index(message, 1), t1.$index(message, 2)); |
| break; |
| case "remove-ondone": |
| this.removeDoneListener$1(t1.$index(message, 1)); |
| break; |
| case "set-errors-fatal": |
| this.setErrorsFatal$2(t1.$index(message, 1), t1.$index(message, 2)); |
| break; |
| case "ping": |
| this.handlePing$3(t1.$index(message, 1), t1.$index(message, 2), t1.$index(message, 3)); |
| break; |
| case "kill": |
| this.handleKill$2(t1.$index(message, 1), t1.$index(message, 2)); |
| break; |
| case "getErrors": |
| this.errorPorts.add$1(0, t1.$index(message, 1)); |
| break; |
| case "stopErrors": |
| this.errorPorts.remove$1(0, t1.$index(message, 1)); |
| break; |
| } |
| }, |
| 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()._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;responsePort,response", |
| call$0: [function() { |
| J.send$1$x(this.responsePort, this.response); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _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, new P._LinkedIdentityHashMap(0, null, null, null, null, null, 0, [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) { |
| e = H.unwrapException(exception); |
| 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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(null, P.int)).serialize$1(t2); |
| t1.toString; |
| self.postMessage(t2); |
| } |
| } |
| }, |
| _EventLoop__runHelper_next: { |
| "^": "Closure:2;$this", |
| call$0: [function() { |
| if (!this.$this.runIteration$0()) |
| return; |
| P.Timer_Timer(C.Duration_0, this); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _IsolateEvent: { |
| "^": "Object;isolate,fn,message>", |
| process$0: function() { |
| var t1 = this.isolate; |
| if (t1.get$isPaused()) { |
| t1.get$delayedEvents().push(this); |
| return; |
| } |
| t1.eval$1(this.fn); |
| } |
| }, |
| _MainManagerStub: { |
| "^": "Object;" |
| }, |
| IsolateNatives__processWorkerMessage_closure: { |
| "^": "Closure:1;entryPoint,args,message,isSpawnUri,startPaused,replyTo", |
| call$0: function() { |
| H.IsolateNatives__startIsolate(this.entryPoint, this.args, this.message, this.isSpawnUri, this.startPaused, this.replyTo); |
| } |
| }, |
| IsolateNatives__startIsolate_runStartFunction: { |
| "^": "Closure:2;topLevel,args,message,isSpawnUri,context", |
| call$0: function() { |
| var t1, t2; |
| t1 = this.context; |
| t1.set$initialized(true); |
| if (this.isSpawnUri !== true) |
| this.topLevel.call$1(this.message); |
| else { |
| t2 = this.topLevel; |
| if (H.functionTypeTest(t2, {func: 1, args: [P.Null, P.Null]})) |
| t2.call$2(this.args, this.message); |
| else if (H.functionTypeTest(t2, {func: 1, args: [P.Null]})) |
| t2.call$1(this.args); |
| else |
| t2.call$0(); |
| } |
| t1._updateGlobalState$0(); |
| } |
| }, |
| _BaseSendPort: { |
| "^": "Object;" |
| }, |
| _NativeJsSendPort: { |
| "^": "_BaseSendPort;_receivePort,_isolateId", |
| send$1: function(_, message) { |
| var isolate, t1, msg; |
| 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) { |
| isolate.handleControlMessage$1(msg); |
| return; |
| } |
| init.globalState.topEventLoop.events._add$1(new H._IsolateEvent(isolate, new H._NativeJsSendPort_send_closure(this, msg), "receive")); |
| }, |
| $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;$this,msg", |
| call$0: function() { |
| var t1 = this.$this._receivePort; |
| if (!t1.get$_isClosed()) |
| t1.__isolate_helper$_add$1(this.msg); |
| } |
| }, |
| _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._LinkedIdentityHashMap__LinkedIdentityHashMap$es6(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 = J.$shl$n(this._workerId, 16); |
| t2 = J.$shl$n(this._isolateId, 8); |
| t3 = this._receivePortId; |
| if (typeof t3 !== "number") |
| return H.iae(t3); |
| return (t1 ^ t2 ^ t3) >>> 0; |
| } |
| }, |
| RawReceivePortImpl: { |
| "^": "Object;_id<,_handler,_isClosed<", |
| _close$0: function() { |
| this._isClosed = true; |
| this._handler = null; |
| }, |
| __isolate_helper$_add$1: function(dataEvent) { |
| if (this._isClosed) |
| return; |
| this._handler.call$1(dataEvent); |
| }, |
| $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.")); |
| }, |
| TimerImpl$periodic$2: function(milliseconds, callback) { |
| if (self.setTimeout != null) { |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| this._handle = self.setInterval(H.convertDartClosureToJS(new H.TimerImpl$periodic_closure(this, callback), 0), milliseconds); |
| } else |
| throw H.wrapException(new P.UnsupportedError("Periodic timer.")); |
| }, |
| cancel$0: function() { |
| if (self.setTimeout != null) { |
| if (this._inEventLoop) |
| throw H.wrapException(new P.UnsupportedError("Timer in event loop cannot be canceled.")); |
| var t1 = this._handle; |
| if (t1 == null) |
| return; |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| if (this._once) |
| self.clearTimeout(t1); |
| else |
| self.clearInterval(t1); |
| this._handle = null; |
| } else |
| throw H.wrapException(new P.UnsupportedError("Canceling a timer.")); |
| }, |
| static: { |
| TimerImpl$: function(milliseconds, callback) { |
| var t1 = new H.TimerImpl(true, false, null); |
| t1.TimerImpl$2(milliseconds, callback); |
| return t1; |
| }, |
| TimerImpl$periodic: function(milliseconds, callback) { |
| var t1 = new H.TimerImpl(false, false, null); |
| t1.TimerImpl$periodic$2(milliseconds, callback); |
| return t1; |
| } |
| } |
| }, |
| TimerImpl_internalCallback: { |
| "^": "Closure:2;$this,callback", |
| call$0: function() { |
| this.$this._handle = null; |
| this.callback.call$0(); |
| } |
| }, |
| TimerImpl_internalCallback0: { |
| "^": "Closure:2;$this,callback", |
| call$0: [function() { |
| this.$this._handle = null; |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| this.callback.call$0(); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| TimerImpl$periodic_closure: { |
| "^": "Closure:1;$this,callback", |
| call$0: [function() { |
| this.callback.call$1(this.$this); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| CapabilityImpl: { |
| "^": "Object;_id<", |
| get$hashCode: function(_) { |
| var hash, t1, t2; |
| hash = this._id; |
| t1 = J.getInterceptor$n(hash); |
| t2 = t1.$shr(hash, 0); |
| t1 = t1.$tdiv(hash, 4294967296); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| hash = t2 ^ t1; |
| 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, 20], |
| unsupported$2: function(x, message) { |
| throw H.wrapException(new P.UnsupportedError((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 = H.setRuntimeTypeInfo(this.deserializeArrayInPlace$1(result), [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); |
| return H.setRuntimeTypeInfo(this.deserializeArrayInPlace$1(result), [null]); |
| 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 = H.setRuntimeTypeInfo(this.deserializeArrayInPlace$1(result), [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, 20], |
| 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) |
| result.$indexSet(0, t1.$index(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, { |
| "^": "", |
| ConstantMap__throwUnmodifiable: function() { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify unmodifiable Map")); |
| }, |
| 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) { |
| if (handleError == null) |
| throw H.wrapException(new P.FormatException(source, null, null)); |
| return handleError.call$1(source); |
| }, |
| 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 interceptor, interceptorConstructor, interceptorConstructorName, $name, dispatchName, objectConstructor, match, decompiledName, t1; |
| interceptor = J.getInterceptor(object); |
| interceptorConstructor = interceptor.constructor; |
| if (typeof interceptorConstructor == "function") { |
| interceptorConstructorName = interceptorConstructor.name; |
| $name = typeof interceptorConstructorName === "string" ? interceptorConstructorName : null; |
| } else |
| $name = null; |
| if ($name == null || interceptor === C.Interceptor_methods || !!J.getInterceptor(object).$isUnknownJavaScriptObject) { |
| dispatchName = C.JS_CONST_u2C(object); |
| if (dispatchName === "Object") { |
| objectConstructor = object.constructor; |
| if (typeof objectConstructor == "function") { |
| match = String(objectConstructor).match(/^\s*function\s*([\w$]*)\s*\(/); |
| decompiledName = match == null ? null : match[1]; |
| if (typeof decompiledName === "string" && /^\w+$/.test(decompiledName)) |
| $name = decompiledName; |
| } |
| if ($name == null) |
| $name = dispatchName; |
| } else |
| $name = dispatchName; |
| } |
| $name = $name; |
| if ($name.length > 1 && C.JSString_methods._codeUnitAt$1($name, 0) === 36) |
| $name = C.JSString_methods.substring$1($name, 1); |
| t1 = H.joinArgumentsV1(H.getRuntimeTypeInfo(object), 0, null); |
| return function(str, names) { |
| return str.replace(/[^<,> ]+/g, function(m) { |
| return names[m] || m; |
| }); |
| }($name + t1, init.mangledGlobalNames); |
| }, |
| 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 = H.setRuntimeTypeInfo([], [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, i; |
| for (t1 = charCodes.length, _i = 0; _i < t1; ++_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_stringFromNativeUint8List: function(charCodes, start, end) { |
| var i, result, i0, chunkEnd; |
| if (J.$le$n(end, 500) && start === 0 && end === charCodes.length) |
| return String.fromCharCode.apply(null, charCodes); |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| result = ""; |
| for (; i < end; i = i0) { |
| i0 = i + 500; |
| if (i0 < end) |
| chunkEnd = i0; |
| else |
| chunkEnd = end; |
| result += String.fromCharCode.apply(null, charCodes.subarray(i, chunkEnd)); |
| } |
| return result; |
| }, |
| Primitives_stringFromCharCode: function(charCode) { |
| var bits; |
| if (typeof charCode !== "number") |
| return H.iae(charCode); |
| if (0 <= charCode) { |
| if (charCode <= 65535) |
| return String.fromCharCode(charCode); |
| if (charCode <= 1114111) { |
| bits = charCode - 65536; |
| return String.fromCharCode((55296 | C.JSNumber_methods._shrOtherPositive$1(bits, 10)) >>> 0, 56320 | bits & 1023); |
| } |
| } |
| throw H.wrapException(P.RangeError$range(charCode, 0, 1114111, null, null)); |
| }, |
| Primitives_lazyAsJsDate: function(receiver) { |
| if (receiver.date === void 0) |
| receiver.date = new Date(receiver._core$_value); |
| return receiver.date; |
| }, |
| Primitives_getYear: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCFullYear() + 0; |
| return t1; |
| }, |
| Primitives_getMonth: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCMonth() + 1; |
| return t1; |
| }, |
| Primitives_getDay: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCDate() + 0; |
| return t1; |
| }, |
| Primitives_getHours: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCHours() + 0; |
| return t1; |
| }, |
| Primitives_getMinutes: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCMinutes() + 0; |
| return t1; |
| }, |
| Primitives_getSeconds: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCSeconds() + 0; |
| return t1; |
| }, |
| Primitives_getMilliseconds: function(receiver) { |
| var t1 = H.Primitives_lazyAsJsDate(receiver).getUTCMilliseconds() + 0; |
| return t1; |
| }, |
| 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; |
| }, |
| Primitives_functionNoSuchMethod: function($function, positionalArguments, namedArguments) { |
| var t1, $arguments, namedArgumentList, t2; |
| t1 = {}; |
| t1.argumentCount = 0; |
| $arguments = []; |
| namedArgumentList = []; |
| if (positionalArguments != null) { |
| t2 = J.get$length$asx(positionalArguments); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| t1.argumentCount = 0 + t2; |
| C.JSArray_methods.addAll$1($arguments, positionalArguments); |
| } |
| t1.names = ""; |
| if (namedArguments != null && !namedArguments.get$isEmpty(namedArguments)) |
| namedArguments.forEach$1(0, new H.Primitives_functionNoSuchMethod_closure(t1, $arguments, namedArgumentList)); |
| return J.noSuchMethod$1$($function, new H.JSInvocationMirror(C.Symbol_call, "call" + "$" + H.S(t1.argumentCount) + t1.names, 0, null, $arguments, namedArgumentList, null)); |
| }, |
| Primitives_applyFunctionWithPositionalArguments: function($function, positionalArguments) { |
| var $arguments, t1; |
| if (positionalArguments != null) |
| $arguments = positionalArguments instanceof Array ? positionalArguments : P.List_List$from(positionalArguments, true, null); |
| else |
| $arguments = []; |
| t1 = $arguments.length; |
| if (t1 === 0) { |
| if (!!$function.call$0) |
| return $function.call$0(); |
| } else if (t1 === 1) { |
| if (!!$function.call$1) |
| return $function.call$1($arguments[0]); |
| } else if (t1 === 2) { |
| if (!!$function.call$2) |
| return $function.call$2($arguments[0], $arguments[1]); |
| } else if (t1 === 3) { |
| if (!!$function.call$3) |
| return $function.call$3($arguments[0], $arguments[1], $arguments[2]); |
| } else if (t1 === 4) { |
| if (!!$function.call$4) |
| return $function.call$4($arguments[0], $arguments[1], $arguments[2], $arguments[3]); |
| } else if (t1 === 5) |
| if (!!$function.call$5) |
| return $function.call$5($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4]); |
| return H.Primitives__genericApplyFunctionWithPositionalArguments($function, $arguments); |
| }, |
| Primitives__genericApplyFunctionWithPositionalArguments: function($function, $arguments) { |
| var argumentCount, jsFunction, info, requiredArgumentCount, maxArgumentCount, pos; |
| argumentCount = $arguments.length; |
| jsFunction = $function["call" + "$" + argumentCount]; |
| if (jsFunction == null) { |
| jsFunction = J.getInterceptor($function)["call*"]; |
| if (jsFunction == null) |
| return H.Primitives_functionNoSuchMethod($function, $arguments, null); |
| info = H.ReflectionInfo_ReflectionInfo(jsFunction); |
| requiredArgumentCount = info.requiredParameterCount; |
| maxArgumentCount = requiredArgumentCount + info.optionalParameterCount; |
| if (info.areOptionalParametersNamed || requiredArgumentCount > argumentCount || maxArgumentCount < argumentCount) |
| return H.Primitives_functionNoSuchMethod($function, $arguments, null); |
| $arguments = P.List_List$from($arguments, true, null); |
| for (pos = argumentCount; pos < maxArgumentCount; ++pos) |
| C.JSArray_methods.add$1($arguments, init.metadata[info.defaultValue$1(0, pos)]); |
| } |
| return jsFunction.apply($function, $arguments); |
| }, |
| 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 (typeof end !== "number" || Math.floor(end) !== end) |
| return new P.ArgumentError(true, end, "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); |
| }, |
| checkNum: function(value) { |
| if (typeof value !== "number") |
| throw H.wrapException(H.argumentErrorValue(value)); |
| return value; |
| }, |
| 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); |
| }, null, null, 0, 0, null], |
| 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) { |
| switch (numberOfArguments) { |
| case 0: |
| return H._callInIsolate(isolate, new H.invokeClosure_closure(closure)); |
| case 1: |
| return H._callInIsolate(isolate, new H.invokeClosure_closure0(closure, arg1)); |
| case 2: |
| return H._callInIsolate(isolate, new H.invokeClosure_closure1(closure, arg1, arg2)); |
| case 3: |
| return H._callInIsolate(isolate, new H.invokeClosure_closure2(closure, arg1, arg2, arg3)); |
| case 4: |
| return H._callInIsolate(isolate, new H.invokeClosure_closure3(closure, arg1, arg2, arg3, arg4)); |
| } |
| throw H.wrapException(P.Exception_Exception("Unsupported number of arguments for wrapped closure")); |
| }, null, null, 14, 0, null, 25, 33, 22, 16, 17, 23, 24], |
| 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); |
| $constructor = new Function("a,b,c,d" + t1, "this.$initialize(a,b,c,d" + t1 + ")"); |
| } |
| $prototype.constructor = $constructor; |
| $constructor.prototype = $prototype; |
| if (!isStatic) { |
| 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(getType, t) { |
| return function() { |
| return getType(t); |
| }; |
| }(H.getType, functionType); |
| else if (typeof functionType == "function") |
| if (isStatic) |
| signatureFunction = functionType; |
| else { |
| 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, selfName, $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 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t1, 1); |
| selfName = "self" + H.S(t1); |
| t1 = "return function(){var " + selfName + " = this."; |
| t2 = $.BoundClosure_selfFieldNameCache; |
| if (t2 == null) { |
| t2 = H.BoundClosure_computeFieldNamed("self"); |
| $.BoundClosure_selfFieldNameCache = t2; |
| } |
| return new Function(t1 + H.S(t2) + ";return " + selfName + "." + H.S(stubName) + "();}")(); |
| } |
| $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(","); |
| t1 = $.Closure_functionCounter; |
| $.Closure_functionCounter = J.$add$ns(t1, 1); |
| $arguments += H.S(t1); |
| t1 = "return function(" + $arguments + "){return this."; |
| t2 = $.BoundClosure_selfFieldNameCache; |
| if (t2 == null) { |
| t2 = H.BoundClosure_computeFieldNamed("self"); |
| $.BoundClosure_selfFieldNameCache = t2; |
| } |
| return new Function(t1 + H.S(t2) + "." + H.S(stubName) + "(" + $arguments + ");}")(); |
| }, |
| 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); |
| }, |
| intTypeCast: function(value) { |
| if (typeof value === "number" && Math.floor(value) === value || value == null) |
| return value; |
| throw H.wrapException(H.CastErrorImplementation$(value, "int")); |
| }, |
| extractFunctionTypeObjectFrom: function(o) { |
| var interceptor = J.getInterceptor(o); |
| return "$signature" in interceptor ? interceptor.$signature() : null; |
| }, |
| functionTypeTest: function(value, functionTypeRti) { |
| var functionTypeObject; |
| if (value == null) |
| return false; |
| functionTypeObject = H.extractFunctionTypeObjectFrom(value); |
| return functionTypeObject == null ? false : H.isFunctionSubtype(functionTypeObject, functionTypeRti); |
| }, |
| _typeDescription: function(value) { |
| var functionTypeObject; |
| if (value instanceof H.Closure) { |
| functionTypeObject = H.extractFunctionTypeObjectFrom(value); |
| if (functionTypeObject != null) |
| return H.runtimeTypeToString(functionTypeObject, null); |
| return "Closure"; |
| } |
| return H.Primitives_objectTypeName(value); |
| }, |
| throwCyclicInit: function(staticName) { |
| throw H.wrapException(new P.CyclicInitializationError(staticName)); |
| }, |
| random64: function() { |
| return (Math.random() * 0x100000000 >>> 0) + (Math.random() * 0x100000000 >>> 0) * 4294967296; |
| }, |
| getIsolateAffinityTag: function($name) { |
| return init.getIsolateTag($name); |
| }, |
| setRuntimeTypeInfo: function(target, rti) { |
| target.$ti = rti; |
| return target; |
| }, |
| getRuntimeTypeInfo: function(target) { |
| if (target == null) |
| return; |
| return target.$ti; |
| }, |
| 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) { |
| var t1 = H.runtimeTypeToStringV1(rti, onTypeVariable); |
| return t1; |
| }, |
| runtimeTypeToStringV1: function(rti, onTypeVariable) { |
| var typedefInfo; |
| if (rti == null) |
| return "dynamic"; |
| if (typeof rti === "object" && rti !== null && rti.constructor === Array) |
| return rti[0].builtin$cls + H.joinArgumentsV1(rti, 1, onTypeVariable); |
| if (typeof rti == "function") |
| return rti.builtin$cls; |
| if (typeof rti === "number" && Math.floor(rti) === rti) |
| return H.S(rti); |
| if (typeof rti.func != "undefined") { |
| typedefInfo = rti.typedef; |
| if (typedefInfo != null) |
| return H.runtimeTypeToStringV1(typedefInfo, onTypeVariable); |
| return H._functionRtiToStringV1(rti, onTypeVariable); |
| } |
| return "unknown-reified-type"; |
| }, |
| _functionRtiToStringV1: function(rti, onTypeVariable) { |
| var returnTypeText, $arguments, t1, argumentsText, sep, _i, argument, optionalArguments, namedArguments, t2, $name; |
| returnTypeText = !!rti.v ? "void" : H.runtimeTypeToStringV1(rti.ret, onTypeVariable); |
| if ("args" in rti) { |
| $arguments = rti.args; |
| for (t1 = $arguments.length, argumentsText = "", sep = "", _i = 0; _i < t1; ++_i, sep = ", ") { |
| argument = $arguments[_i]; |
| argumentsText = argumentsText + sep + H.runtimeTypeToStringV1(argument, onTypeVariable); |
| } |
| } else { |
| argumentsText = ""; |
| sep = ""; |
| } |
| if ("opt" in rti) { |
| optionalArguments = rti.opt; |
| argumentsText += sep + "["; |
| for (t1 = optionalArguments.length, sep = "", _i = 0; _i < t1; ++_i, sep = ", ") { |
| argument = optionalArguments[_i]; |
| argumentsText = argumentsText + sep + H.runtimeTypeToStringV1(argument, onTypeVariable); |
| } |
| argumentsText += "]"; |
| } |
| if ("named" in rti) { |
| namedArguments = rti.named; |
| argumentsText += sep + "{"; |
| for (t1 = H.extractKeys(namedArguments), t2 = t1.length, sep = "", _i = 0; _i < t2; ++_i, sep = ", ") { |
| $name = t1[_i]; |
| argumentsText = argumentsText + sep + H.runtimeTypeToStringV1(namedArguments[$name], onTypeVariable) + (" " + H.S($name)); |
| } |
| argumentsText += "}"; |
| } |
| return "(" + argumentsText + ") => " + returnTypeText; |
| }, |
| joinArgumentsV1: 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.runtimeTypeToStringV1(argument, onTypeVariable); |
| } |
| return allDynamic ? "" : "<" + buffer.toString$0(0) + ">"; |
| }, |
| substitute: function(substitution, $arguments) { |
| if (substitution == null) |
| return $arguments; |
| substitution = substitution.apply(null, $arguments); |
| if (substitution == null) |
| return; |
| if (typeof substitution === "object" && substitution !== null && substitution.constructor === Array) |
| return substitution; |
| if (typeof substitution == "function") |
| return substitution.apply(null, $arguments); |
| return $arguments; |
| }, |
| checkSubtype: function(object, isField, checks, asField) { |
| var $arguments, interceptor; |
| if (object == null) |
| return false; |
| $arguments = H.getRuntimeTypeInfo(object); |
| interceptor = J.getInterceptor(object); |
| if (interceptor[isField] == null) |
| return false; |
| return H.areSubtypes(H.substitute(interceptor[asField], $arguments), checks); |
| }, |
| 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 signature.apply(context, H.getRuntimeTypeArguments(context, contextName)); |
| }, |
| isSubtype: function(s, t) { |
| var t1, typeOfS, t2, typeOfT, typeOfTString, substitution; |
| if (s === t) |
| return true; |
| if (s == null || t == null) |
| return true; |
| if (typeof s === "number") |
| return false; |
| if (typeof t === "number") |
| return false; |
| if (s.builtin$cls === "Null") |
| return true; |
| if ('func' in t) |
| return H.isFunctionSubtype(s, t); |
| if ('func' in s) |
| return t.builtin$cls === "Function" || t.builtin$cls === "Object"; |
| 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) { |
| typeOfTString = H.runtimeTypeToString(typeOfT, null); |
| if (!('$is' + typeOfTString in typeOfS.prototype)) |
| return false; |
| substitution = typeOfS.prototype["$as" + typeOfTString]; |
| } else |
| substitution = null; |
| if (!t1 && substitution == null || !t2) |
| return true; |
| t1 = t1 ? s.slice(1) : null; |
| t2 = t.slice(1); |
| 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 sBounds, tBounds, sReturnType, tReturnType, sParameterTypes, tParameterTypes, sOptionalParameterTypes, tOptionalParameterTypes, sParametersLen, tParametersLen, sOptionalParametersLen, tOptionalParametersLen, pos, t1, t2, tPos, sPos; |
| if (!('func' in s)) |
| return false; |
| if ("bounds" in s) { |
| if (!("bounds" in t)) |
| return false; |
| sBounds = s.bounds; |
| tBounds = t.bounds; |
| if (sBounds.length !== tBounds.length) |
| return false; |
| } else if ("bounds" in t) |
| return false; |
| if ("v" in s) { |
| if (!("v" in t) && "ret" in t) |
| return false; |
| } else if (!("v" 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); |
| }, |
| 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_bDt(); |
| 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_gkc, H.applyHooksTransformer(C.JS_CONST_4hp, H.applyHooksTransformer(C.JS_CONST_QJm(C.JS_CONST_u2C), 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(t1); |
| } else { |
| t1 = t1.allMatches$1(other, C.JSString_methods.substring$1(receiver, startIndex)); |
| return !t1.get$isEmpty(t1); |
| } |
| } |
| }, |
| stringReplaceFirstRE: function(receiver, regexp, replacement, startIndex) { |
| var match, t1, start; |
| match = regexp._execGlobal$2(receiver, startIndex); |
| if (match == null) |
| return receiver; |
| t1 = match._match; |
| start = t1.index; |
| return H.stringReplaceRangeUnchecked(receiver, start, start + t1[0].length, replacement); |
| }, |
| stringReplaceAllUnchecked: function(receiver, pattern, replacement) { |
| var $length, t1, i, nativeRegexp; |
| if (typeof pattern === "string") |
| 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(/[[\]{}()*+?.\\^$|]/g, "\\$&"), 'g'), replacement.replace(/\$/g, "$$$$")); |
| else if (pattern instanceof H.JSSyntaxRegExp) { |
| nativeRegexp = pattern.get$_nativeGlobalVersion(); |
| nativeRegexp.lastIndex = 0; |
| return receiver.replace(nativeRegexp, replacement.replace(/\$/g, "$$$$")); |
| } else { |
| if (pattern == null) |
| H.throwExpression(H.argumentErrorValue(pattern)); |
| throw H.wrapException("String.replaceAll(Pattern) UNIMPLEMENTED"); |
| } |
| }, |
| stringReplaceFirstUnchecked: function(receiver, pattern, replacement, startIndex) { |
| var index, t1, matches, match; |
| if (typeof pattern === "string") { |
| index = receiver.indexOf(pattern, startIndex); |
| if (index < 0) |
| return receiver; |
| return H.stringReplaceRangeUnchecked(receiver, index, index + pattern.length, replacement); |
| } |
| t1 = J.getInterceptor(pattern); |
| if (!!t1.$isJSSyntaxRegExp) |
| return startIndex === 0 ? receiver.replace(pattern._nativeRegExp, replacement.replace(/\$/g, "$$$$")) : H.stringReplaceFirstRE(receiver, pattern, replacement, startIndex); |
| if (pattern == null) |
| H.throwExpression(H.argumentErrorValue(pattern)); |
| t1 = t1.allMatches$2(pattern, receiver, startIndex); |
| matches = t1.get$iterator(t1); |
| if (!matches.moveNext$0()) |
| return receiver; |
| match = matches.get$current(); |
| return C.JSString_methods.replaceRange$3(receiver, match.get$start(match), match.get$end(), replacement); |
| }, |
| stringReplaceRangeUnchecked: function(receiver, start, end, replacement) { |
| var prefix, suffix; |
| prefix = receiver.substring(0, start); |
| suffix = receiver.substring(end); |
| return prefix + replacement + suffix; |
| }, |
| ConstantMapView: { |
| "^": "UnmodifiableMapView;_collection$_map,$ti", |
| $asUnmodifiableMapView: Isolate.functionThatReturnsNull, |
| $isMap: 1, |
| $asMap: Isolate.functionThatReturnsNull |
| }, |
| ConstantMap: { |
| "^": "Object;", |
| get$isEmpty: function(_) { |
| return this.get$length(this) === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this.get$length(this) !== 0; |
| }, |
| toString$0: function(_) { |
| return P.Maps_mapToString(this); |
| }, |
| $indexSet: function(_, key, val) { |
| return H.ConstantMap__throwUnmodifiable(); |
| }, |
| $isMap: 1 |
| }, |
| ConstantStringMap: { |
| "^": "ConstantMap;_length,_jsObject,_keys,$ti", |
| get$length: function(_) { |
| return this._length; |
| }, |
| containsKey$1: function(key) { |
| if (typeof key !== "string") |
| return false; |
| if ("__proto__" === key) |
| return false; |
| return this._jsObject.hasOwnProperty(key); |
| }, |
| $index: function(_, key) { |
| if (!this.containsKey$1(key)) |
| return; |
| return this._fetch$1(key); |
| }, |
| _fetch$1: function(key) { |
| return this._jsObject[key]; |
| }, |
| forEach$1: function(_, f) { |
| var keys, t1, i, key; |
| keys = this._keys; |
| for (t1 = keys.length, i = 0; i < t1; ++i) { |
| key = keys[i]; |
| f.call$2(key, this._fetch$1(key)); |
| } |
| } |
| }, |
| JSInvocationMirror: { |
| "^": "Object;__js_helper$_memberName,_internalName,_kind,_typeArguments,_arguments,_namedArgumentNames,_namedIndices", |
| get$memberName: function() { |
| var t1 = this.__js_helper$_memberName; |
| return t1; |
| }, |
| get$positionalArguments: function() { |
| var t1, argumentCount, list, index; |
| if (this._kind === 1) |
| return C.List_empty0; |
| t1 = this._arguments; |
| argumentCount = t1.length - this._namedArgumentNames.length; |
| if (argumentCount === 0) |
| return C.List_empty0; |
| list = []; |
| for (index = 0; index < argumentCount; ++index) { |
| if (index >= t1.length) |
| return H.ioore(t1, index); |
| list.push(t1[index]); |
| } |
| return J.JSArray_markUnmodifiableList(list); |
| }, |
| get$namedArguments: function() { |
| var t1, namedArgumentCount, t2, namedArgumentsStartIndex, t3, map, i, t4, t5; |
| if (this._kind !== 0) |
| return C.Map_empty0; |
| t1 = this._namedArgumentNames; |
| namedArgumentCount = t1.length; |
| t2 = this._arguments; |
| namedArgumentsStartIndex = t2.length - namedArgumentCount; |
| if (namedArgumentCount === 0) |
| return C.Map_empty0; |
| t3 = P.Symbol0; |
| map = new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [t3, null]); |
| for (i = 0; i < namedArgumentCount; ++i) { |
| if (i >= t1.length) |
| return H.ioore(t1, i); |
| t4 = t1[i]; |
| t5 = namedArgumentsStartIndex + i; |
| if (t5 < 0 || t5 >= t2.length) |
| return H.ioore(t2, t5); |
| map.$indexSet(0, new H.Symbol(t4), t2[t5]); |
| } |
| return new H.ConstantMapView(map, [t3, null]); |
| } |
| }, |
| ReflectionInfo: { |
| "^": "Object;jsFunction,data>,isAccessor,requiredParameterCount,optionalParameterCount,areOptionalParametersNamed,functionType,cachedSortedIndices", |
| defaultValue$1: function(_, parameter) { |
| var t1 = this.requiredParameterCount; |
| if (typeof parameter !== "number") |
| return parameter.$lt(); |
| if (parameter < t1) |
| return; |
| return this.data[3 + parameter - t1]; |
| }, |
| 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); |
| } |
| } |
| }, |
| Primitives_functionNoSuchMethod_closure: { |
| "^": "Closure:12;_box_0,$arguments,namedArgumentList", |
| call$2: function($name, argument) { |
| var t1 = this._box_0; |
| t1.names = t1.names + "$" + H.S($name); |
| this.namedArgumentList.push($name); |
| this.$arguments.push(argument); |
| ++t1.argumentCount; |
| } |
| }, |
| 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(/[[\]{}()*+?.\\^$|]/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(new RegExp('\\\\\\$arguments\\\\\\$', 'g'), '((?:x|[^x])*)').replace(new RegExp('\\\\\\$argumentsExpr\\\\\\$', 'g'), '((?:x|[^x])*)').replace(new RegExp('\\\\\\$expr\\\\\\$', 'g'), '((?:x|[^x])*)').replace(new RegExp('\\\\\\$method\\\\\\$', 'g'), '((?:x|[^x])*)').replace(new RegExp('\\\\\\$receiver\\\\\\$', 'g'), '((?:x|[^x])*)'), $arguments, argumentsExpr, expr, method, receiver); |
| }, |
| TypeErrorDecoder_provokeCallErrorOn: 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: '" + t1 + "' (" + H.S(this._message) + ")"; |
| return "NoSuchMethodError: method not found: '" + t1 + "' on '" + 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 t1.length === 0 ? "Error" : "Error: " + t1; |
| } |
| }, |
| ExceptionAndStackTrace: { |
| "^": "Object;dartException,stackTrace<" |
| }, |
| unwrapException_saveStackTrace: { |
| "^": "Closure:0;ex", |
| call$1: function(error) { |
| if (!!J.getInterceptor(error).$isError) |
| if (error.$thrownJsError == null) |
| error.$thrownJsError = this.ex; |
| 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;closure", |
| call$0: function() { |
| return this.closure.call$0(); |
| } |
| }, |
| invokeClosure_closure0: { |
| "^": "Closure:1;closure,arg1", |
| call$0: function() { |
| return this.closure.call$1(this.arg1); |
| } |
| }, |
| invokeClosure_closure1: { |
| "^": "Closure:1;closure,arg1,arg2", |
| call$0: function() { |
| return this.closure.call$2(this.arg1, this.arg2); |
| } |
| }, |
| invokeClosure_closure2: { |
| "^": "Closure:1;closure,arg1,arg2,arg3", |
| call$0: function() { |
| return this.closure.call$3(this.arg1, this.arg2, this.arg3); |
| } |
| }, |
| invokeClosure_closure3: { |
| "^": "Closure:1;closure,arg1,arg2,arg3,arg4", |
| call$0: function() { |
| return this.closure.call$4(this.arg1, this.arg2, this.arg3, this.arg4); |
| } |
| }, |
| Closure: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "Closure '" + H.Primitives_objectTypeName(this).trim() + "'"; |
| }, |
| 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,_target,_receiver,_name", |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (this === other) |
| return true; |
| if (!(other instanceof H.BoundClosure)) |
| return false; |
| return this._self === other._self && this._target === other._target && this._receiver === other._receiver; |
| }, |
| get$hashCode: function(_) { |
| var t1, receiverHashCode; |
| t1 = this._receiver; |
| if (t1 == null) |
| receiverHashCode = H.Primitives_objectHashCode(this._self); |
| else |
| receiverHashCode = typeof t1 !== "object" ? J.get$hashCode$(t1) : H.Primitives_objectHashCode(t1); |
| return J.$xor$n(receiverHashCode, H.Primitives_objectHashCode(this._target)); |
| }, |
| toString$0: function(_) { |
| var receiver = this._receiver; |
| if (receiver == null) |
| receiver = this._self; |
| return "Closure '" + H.S(this._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; |
| } |
| } |
| } |
| }, |
| CastErrorImplementation: { |
| "^": "Error;message>", |
| toString$0: function(_) { |
| return this.message; |
| }, |
| static: { |
| CastErrorImplementation$: function(value, type) { |
| return new H.CastErrorImplementation("CastError: " + H.S(P.Error_safeToString(value)) + ": type '" + H._typeDescription(value) + "' is not a subtype of type '" + type + "'"); |
| } |
| } |
| }, |
| RuntimeError: { |
| "^": "Error;message>", |
| toString$0: function(_) { |
| return "RuntimeError: " + H.S(this.message); |
| } |
| }, |
| JsLinkedHashMap: { |
| "^": "Object;_length,_strings,_nums,_rest,_first,_last,_modifications,$ti", |
| get$length: function(_) { |
| return this._length; |
| }, |
| get$isEmpty: function(_) { |
| return this._length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return !this.get$isEmpty(this); |
| }, |
| get$keys: function() { |
| return 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._getTableBucket$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._getTableCell$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._getTableCell$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._getTableBucket$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._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._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._getTableBucket$2(rest, hash); |
| if (bucket == null) |
| this._setTableEntry$3(rest, hash, [this._newLinkedCell$2(key, value)]); |
| else { |
| index = this.internalFindBucketIndex$2(bucket, key); |
| if (index >= 0) |
| bucket[index].set$hashMapCellValue(value); |
| else |
| bucket.push(this._newLinkedCell$2(key, value)); |
| } |
| } |
| }, |
| remove$1: function(_, key) { |
| if (typeof key === "string") |
| return this._removeHashTableEntry$2(this._strings, key); |
| else if (typeof key === "number" && (key & 0x3ffffff) === key) |
| return this._removeHashTableEntry$2(this._nums, key); |
| else |
| return this.internalRemove$1(key); |
| }, |
| internalRemove$1: function(key) { |
| var rest, bucket, index, cell; |
| rest = this._rest; |
| if (rest == null) |
| return; |
| bucket = this._getTableBucket$2(rest, this.internalComputeHashCode$1(key)); |
| index = this.internalFindBucketIndex$2(bucket, key); |
| if (index < 0) |
| return; |
| cell = bucket.splice(index, 1)[0]; |
| this._unlinkCell$1(cell); |
| return cell.get$hashMapCellValue(); |
| }, |
| clear$0: function(_) { |
| if (this._length > 0) { |
| this._last = null; |
| this._first = null; |
| this._rest = null; |
| this._nums = null; |
| this._strings = null; |
| this._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; |
| } |
| }, |
| _addHashTableEntry$3: function(table, key, value) { |
| var cell = this._getTableCell$2(table, key); |
| if (cell == null) |
| this._setTableEntry$3(table, key, this._newLinkedCell$2(key, value)); |
| else |
| cell.set$hashMapCellValue(value); |
| }, |
| _removeHashTableEntry$2: function(table, key) { |
| var cell; |
| if (table == null) |
| return; |
| cell = this._getTableCell$2(table, key); |
| if (cell == null) |
| return; |
| this._unlinkCell$1(cell); |
| this._deleteTableEntry$2(table, key); |
| return cell.get$hashMapCellValue(); |
| }, |
| _newLinkedCell$2: function(key, value) { |
| var cell, last; |
| cell = new H.LinkedHashMapCell(key, value, null, null); |
| if (this._first == null) { |
| this._last = cell; |
| this._first = cell; |
| } else { |
| last = this._last; |
| cell._previous = last; |
| last._next = cell; |
| this._last = cell; |
| } |
| ++this._length; |
| this._modifications = this._modifications + 1 & 67108863; |
| return cell; |
| }, |
| _unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$_previous(); |
| next = cell.get$_next(); |
| if (previous == null) |
| this._first = next; |
| else |
| previous._next = next; |
| if (next == null) |
| this._last = previous; |
| else |
| next._previous = previous; |
| --this._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); |
| }, |
| _getTableCell$2: function(table, key) { |
| return table[key]; |
| }, |
| _getTableBucket$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._getTableCell$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, |
| $isMap: 1, |
| static: { |
| JsLinkedHashMap_JsLinkedHashMap$es6: function($K, $V) { |
| return new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [$K, $V]); |
| } |
| } |
| }, |
| JsLinkedHashMap_values_closure: { |
| "^": "Closure:0;$this", |
| call$1: [function(each) { |
| return this.$this.$index(0, each); |
| }, null, null, 2, 0, null, 30, "call"] |
| }, |
| LinkedHashMapCell: { |
| "^": "Object;hashMapCellKey<,hashMapCellValue@,_next<,_previous<" |
| }, |
| LinkedHashMapKeyIterable: { |
| "^": "EfficientLengthIterable;_map,$ti", |
| get$length: function(_) { |
| return this._map._length; |
| }, |
| get$isEmpty: function(_) { |
| return this._map._length === 0; |
| }, |
| get$iterator: function(_) { |
| var t1, t2; |
| t1 = this._map; |
| t2 = new H.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); |
| t2._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; |
| } |
| } |
| }, |
| LinkedHashMapKeyIterator: { |
| "^": "Object;_map,_modifications,_cell,_current", |
| get$current: function() { |
| return this._current; |
| }, |
| moveNext$0: function() { |
| var t1 = this._map; |
| if (this._modifications !== t1._modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(t1)); |
| else { |
| t1 = this._cell; |
| if (t1 == null) { |
| this._current = null; |
| return false; |
| } else { |
| this._current = t1.hashMapCellKey; |
| this._cell = t1._next; |
| return true; |
| } |
| } |
| } |
| }, |
| initHooks_closure: { |
| "^": "Closure:0;getTag", |
| call$1: function(o) { |
| return this.getTag(o); |
| } |
| }, |
| initHooks_closure0: { |
| "^": "Closure:15;getUnknownTag", |
| call$2: function(o, tag) { |
| return this.getUnknownTag(o, tag); |
| } |
| }, |
| initHooks_closure1: { |
| "^": "Closure:27;prototypeForTag", |
| call$1: function(tag) { |
| return this.prototypeForTag(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; |
| }, |
| firstMatch$1: function(string) { |
| var m = this._nativeRegExp.exec(H.checkString(string)); |
| if (m == null) |
| return; |
| return new H._MatchImplementation(this, m); |
| }, |
| allMatches$2: function(_, string, 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 new H._MatchImplementation(this, match); |
| }, |
| _execAnchored$2: function(string, start) { |
| var regexp, match; |
| regexp = this.get$_nativeAnchoredVersion(); |
| regexp.lastIndex = start; |
| match = regexp.exec(string); |
| if (match == null) |
| return; |
| if (0 >= match.length) |
| return H.ioore(match, -1); |
| if (match.pop() != null) |
| return; |
| return new H._MatchImplementation(this, match); |
| }, |
| matchAsPrefix$2: function(_, string, start) { |
| var t1 = J.getInterceptor$n(start); |
| if (t1.$lt(start, 0) || t1.$gt(start, string.length)) |
| throw H.wrapException(P.RangeError$range(start, 0, string.length, null, null)); |
| return this._execAnchored$2(string, start); |
| }, |
| $isRegExp: 1, |
| static: { |
| JSSyntaxRegExp_makeNative: function(source, multiLine, caseSensitive, global) { |
| var m, i, g, regexp; |
| m = multiLine ? "m" : ""; |
| i = caseSensitive ? "" : "i"; |
| g = global ? "g" : ""; |
| regexp = function(source, modifiers) { |
| try { |
| return new RegExp(source, modifiers); |
| } catch (e) { |
| return e; |
| } |
| }(source, m + i + g); |
| if (regexp instanceof RegExp) |
| return regexp; |
| throw H.wrapException(new P.FormatException("Illegal RegExp pattern (" + String(regexp) + ")", source, null)); |
| } |
| } |
| }, |
| _MatchImplementation: { |
| "^": "Object;pattern,_match", |
| get$start: function(_) { |
| return this._match.index; |
| }, |
| get$end: function() { |
| var t1 = this._match; |
| return t1.index + t1[0].length; |
| }, |
| $index: function(_, index) { |
| var t1 = this._match; |
| if (index >>> 0 !== index || index >= t1.length) |
| return H.ioore(t1, index); |
| return t1[index]; |
| } |
| }, |
| _AllMatchesIterable: { |
| "^": "IterableBase;_re,_string,_start", |
| get$iterator: function(_) { |
| return new H._AllMatchesIterator(this._re, this._string, this._start, null); |
| }, |
| $asIterable: function() { |
| return [P.Match]; |
| } |
| }, |
| _AllMatchesIterator: { |
| "^": "Object;_regExp,_string,_nextIndex,_current", |
| get$current: function() { |
| return this._current; |
| }, |
| moveNext$0: function() { |
| var t1, t2, match, 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._current = match; |
| t1 = match._match; |
| t2 = t1.index; |
| nextIndex = t2 + t1[0].length; |
| this._nextIndex = t2 === nextIndex ? nextIndex + 1 : nextIndex; |
| return true; |
| } |
| } |
| this._current = null; |
| this._string = null; |
| return false; |
| } |
| }, |
| StringMatch: { |
| "^": "Object;start>,input,pattern", |
| get$end: function() { |
| return J.$add$ns(this.start, this.pattern.length); |
| }, |
| $index: function(_, g) { |
| if (g !== 0) |
| H.throwExpression(P.RangeError$value(g, 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,_current", |
| moveNext$0: function() { |
| var t1, t2, t3, t4, t5, t6, index, end; |
| t1 = this.__js_helper$_index; |
| t2 = this._pattern; |
| t3 = t2.length; |
| t4 = this._input; |
| t5 = J.getInterceptor$asx(t4); |
| t6 = t5.get$length(t4); |
| if (typeof t6 !== "number") |
| return H.iae(t6); |
| if (t1 + t3 > t6) { |
| this._current = null; |
| return false; |
| } |
| index = t4.indexOf(t2, this.__js_helper$_index); |
| if (index < 0) { |
| this.__js_helper$_index = J.$add$ns(t5.get$length(t4), 1); |
| this._current = null; |
| return false; |
| } |
| end = index + t3; |
| this._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._current; |
| } |
| } |
| }], ["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; |
| } |
| }], ["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); |
| } |
| }], ["dart.typed_data.implementation", "dart:_native_typed_data",, H, { |
| "^": "", |
| _checkLength: function($length) { |
| if (typeof $length !== "number" || Math.floor($length) !== $length) |
| throw H.wrapException(P.ArgumentError$("Invalid length " + H.S($length))); |
| return $length; |
| }, |
| _ensureNativeList: function(list) { |
| return list; |
| }, |
| NativeInt8List_NativeInt8List$fromList: function(elements) { |
| return new Int8Array(H._ensureNativeList(elements)); |
| }, |
| _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;", |
| _invalidPosition$3: function(receiver, position, $length, $name) { |
| if (typeof position !== "number" || Math.floor(position) !== position) |
| throw H.wrapException(P.ArgumentError$value(position, $name, "Invalid list position")); |
| else |
| throw H.wrapException(P.RangeError$range(position, 0, $length, $name, null)); |
| }, |
| _checkPosition$3: function(receiver, position, $length, $name) { |
| if (position >>> 0 !== position || position > $length) |
| this._invalidPosition$3(receiver, position, $length, $name); |
| }, |
| $isNativeTypedData: 1, |
| "%": "DataView;ArrayBufferView;NativeTypedArray|NativeTypedArray_ListMixin0|NativeTypedArray_ListMixin_FixedLengthListMixin0|NativeTypedArrayOfDouble|NativeTypedArray_ListMixin|NativeTypedArray_ListMixin_FixedLengthListMixin|NativeTypedArrayOfInt" |
| }, |
| NativeTypedArray: { |
| "^": "NativeTypedData;", |
| get$length: function(receiver) { |
| return receiver.length; |
| }, |
| _setRangeFast$4: function(receiver, start, end, source, skipCount) { |
| var targetLength, count, sourceLength; |
| targetLength = receiver.length; |
| this._checkPosition$3(receiver, start, targetLength, "start"); |
| this._checkPosition$3(receiver, end, targetLength, "end"); |
| if (J.$gt$n(start, end)) |
| throw H.wrapException(P.RangeError$range(start, 0, end, null, null)); |
| if (typeof start !== "number") |
| return H.iae(start); |
| count = end - start; |
| if (J.$lt$n(skipCount, 0)) |
| throw H.wrapException(P.ArgumentError$(skipCount)); |
| sourceLength = source.length; |
| if (typeof skipCount !== "number") |
| return H.iae(skipCount); |
| if (sourceLength - skipCount < count) |
| throw H.wrapException(new P.StateError("Not enough elements")); |
| if (skipCount !== 0 || sourceLength !== count) |
| source = source.subarray(skipCount, skipCount + count); |
| receiver.set(source, start); |
| }, |
| $isJSIndexable: 1, |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $isJavaScriptIndexingBehavior: 1, |
| $asJavaScriptIndexingBehavior: Isolate.functionThatReturnsNull |
| }, |
| NativeTypedArrayOfDouble: { |
| "^": "NativeTypedArray_ListMixin_FixedLengthListMixin0;", |
| $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; |
| }, |
| setRange$4: function(receiver, start, end, iterable, skipCount) { |
| if (!!J.getInterceptor(iterable).$isNativeTypedArrayOfDouble) { |
| this._setRangeFast$4(receiver, start, end, iterable, skipCount); |
| return; |
| } |
| this.super$ListMixin$setRange(receiver, start, end, iterable, skipCount); |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| } |
| }, |
| NativeTypedArrayOfInt: { |
| "^": "NativeTypedArray_ListMixin_FixedLengthListMixin;", |
| $indexSet: function(receiver, index, value) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| receiver[index] = value; |
| }, |
| setRange$4: function(receiver, start, end, iterable, skipCount) { |
| if (!!J.getInterceptor(iterable).$isNativeTypedArrayOfInt) { |
| this._setRangeFast$4(receiver, start, end, iterable, skipCount); |
| return; |
| } |
| this.super$ListMixin$setRange(receiver, start, end, iterable, skipCount); |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| } |
| }, |
| NativeFloat32List: { |
| "^": "NativeTypedArrayOfDouble;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.double]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.double]; |
| }, |
| "%": "Float32Array" |
| }, |
| NativeFloat64List: { |
| "^": "NativeTypedArrayOfDouble;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.double]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.double]; |
| }, |
| "%": "Float64Array" |
| }, |
| NativeInt16List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "Int16Array" |
| }, |
| NativeInt32List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "Int32Array" |
| }, |
| NativeInt8List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "Int8Array" |
| }, |
| NativeUint16List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "Uint16Array" |
| }, |
| NativeUint32List: { |
| "^": "NativeTypedArrayOfInt;", |
| $index: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| H.throwExpression(H.diagnoseIndexError(receiver, index)); |
| return receiver[index]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "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]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": "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]; |
| }, |
| sublist$2: function(receiver, start, end) { |
| return new Uint8Array(receiver.subarray(start, H._checkValidRange(start, end, receiver.length))); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isNativeUint8List: 1, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| }, |
| "%": ";Uint8Array" |
| }, |
| NativeTypedArray_ListMixin: { |
| "^": "NativeTypedArray+ListMixin;", |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $asJavaScriptIndexingBehavior: Isolate.functionThatReturnsNull, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| } |
| }, |
| NativeTypedArray_ListMixin0: { |
| "^": "NativeTypedArray+ListMixin;", |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.double]; |
| }, |
| $asJavaScriptIndexingBehavior: Isolate.functionThatReturnsNull, |
| $isList: 1, |
| $asList: function() { |
| return [P.double]; |
| } |
| }, |
| NativeTypedArray_ListMixin_FixedLengthListMixin: { |
| "^": "NativeTypedArray_ListMixin+FixedLengthListMixin;", |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $asJavaScriptIndexingBehavior: Isolate.functionThatReturnsNull, |
| $asList: function() { |
| return [P.int]; |
| } |
| }, |
| NativeTypedArray_ListMixin_FixedLengthListMixin0: { |
| "^": "NativeTypedArray_ListMixin0+FixedLengthListMixin;", |
| $asJSIndexable: Isolate.functionThatReturnsNull, |
| $asEfficientLengthIterable: function() { |
| return [P.double]; |
| }, |
| $asJavaScriptIndexingBehavior: Isolate.functionThatReturnsNull, |
| $asList: function() { |
| return [P.double]; |
| } |
| } |
| }], ["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.storedCallback = 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], |
| _asyncStart: function(bodyFunction, completer) { |
| P._awaitOnObject(null, bodyFunction); |
| return completer.get$future(); |
| }, |
| _asyncAwait: function(object, bodyFunction) { |
| P._awaitOnObject(object, bodyFunction); |
| }, |
| _asyncReturn: function(object, completer) { |
| J.complete$1$x(completer, object); |
| }, |
| _asyncRethrow: function(object, completer) { |
| completer.completeError$2(H.unwrapException(object), H.getTraceFromException(object)); |
| }, |
| _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 = new P._Future(0, $.Zone__current, null, [null]); |
| future._state = 4; |
| future._resultOrListeners = object; |
| future._thenNoZoneRegistration$2(thenCallback, null); |
| } |
| }, |
| _wrapJsFunctionForAsync: function($function) { |
| var $protected = function(fn, ERROR) { |
| return function(errorCode, result) { |
| while (true) |
| try { |
| fn(errorCode, result); |
| break; |
| } catch (error) { |
| result = error; |
| errorCode = ERROR; |
| } |
| }; |
| }($function, 1); |
| return $.Zone__current.registerBinaryCallback$1(new P._wrapJsFunctionForAsync_closure($protected)); |
| }, |
| _invokeErrorHandler: function(errorHandler, error, stackTrace) { |
| if (H.functionTypeTest(errorHandler, {func: 1, args: [P.Null, P.Null]})) |
| return errorHandler.call$2(error, stackTrace); |
| else |
| return errorHandler.call$1(error); |
| }, |
| _registerErrorHandler: function(errorHandler, zone) { |
| if (H.functionTypeTest(errorHandler, {func: 1, args: [P.Null, P.Null]})) |
| return zone.registerBinaryCallback$1(errorHandler); |
| else |
| return zone.registerUnaryCallback$1(errorHandler); |
| }, |
| Completer_Completer$sync: function($T) { |
| return new P._SyncCompleter(new P._Future(0, $.Zone__current, null, [$T]), [$T]); |
| }, |
| _microtaskLoop: function() { |
| var t1, t2; |
| for (; t1 = $._nextCallback, t1 != null;) { |
| $._lastPriorityCallback = null; |
| t2 = t1.next; |
| $._nextCallback = t2; |
| if (t2 == null) |
| $._lastCallback = null; |
| t1.callback.call$0(); |
| } |
| }, |
| _startMicrotaskLoop: [function() { |
| $._isInCallbackLoop = true; |
| try { |
| P._microtaskLoop(); |
| } finally { |
| $._lastPriorityCallback = null; |
| $._isInCallbackLoop = false; |
| if ($._nextCallback != null) |
| $.$get$_AsyncRun__scheduleImmediateClosure().call$1(P.async___startMicrotaskLoop$closure()); |
| } |
| }, "call$0", "async___startMicrotaskLoop$closure", 0, 0, 2], |
| _scheduleAsyncCallback: function(callback) { |
| var newEntry = new P._AsyncCallbackEntry(callback, null); |
| if ($._nextCallback == null) { |
| $._lastCallback = newEntry; |
| $._nextCallback = newEntry; |
| if (!$._isInCallbackLoop) |
| $.$get$_AsyncRun__scheduleImmediateClosure().call$1(P.async___startMicrotaskLoop$closure()); |
| } else { |
| $._lastCallback.next = newEntry; |
| $._lastCallback = newEntry; |
| } |
| }, |
| _schedulePriorityAsyncCallback: function(callback) { |
| var t1, entry, t2; |
| t1 = $._nextCallback; |
| if (t1 == null) { |
| P._scheduleAsyncCallback(callback); |
| $._lastPriorityCallback = $._lastCallback; |
| return; |
| } |
| entry = new P._AsyncCallbackEntry(callback, null); |
| 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; |
| } |
| }, |
| scheduleMicrotask: function(callback) { |
| var currentZone, t1; |
| currentZone = $.Zone__current; |
| if (C.C__RootZone === currentZone) { |
| P._rootScheduleMicrotask(null, null, C.C__RootZone, callback); |
| return; |
| } |
| if (C.C__RootZone === currentZone.get$_scheduleMicrotask().zone) |
| t1 = C.C__RootZone.get$errorZone() === currentZone.get$errorZone(); |
| else |
| t1 = false; |
| if (t1) { |
| P._rootScheduleMicrotask(null, null, currentZone, currentZone.registerCallback$1(callback)); |
| return; |
| } |
| t1 = $.Zone__current; |
| t1.scheduleMicrotask$1(t1.bindCallbackGuarded$1(callback)); |
| }, |
| StreamIterator_StreamIterator: function(stream, $T) { |
| return new P._StreamIterator(null, stream, false, [$T]); |
| }, |
| _runGuarded: function(notificationHandler) { |
| var e, s, exception; |
| if (notificationHandler == null) |
| return; |
| try { |
| notificationHandler.call$0(); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| $.Zone__current.handleUncaughtError$2(e, s); |
| } |
| }, |
| _nullDataHandler: [function(value) { |
| }, "call$1", "async___nullDataHandler$closure", 2, 0, 28, 8], |
| _nullErrorHandler: [function(error, stackTrace) { |
| $.Zone__current.handleUncaughtError$2(error, stackTrace); |
| }, function(error) { |
| return P._nullErrorHandler(error, null); |
| }, "call$2", "call$1", "async___nullErrorHandler$closure", 2, 2, 5, 3, 0, 1], |
| _nullDoneHandler: [function() { |
| }, "call$0", "async___nullDoneHandler$closure", 0, 0, 2], |
| _runUserCode: function(userCode, onSuccess, onError) { |
| var e, s, replacement, error, stackTrace, exception, error0; |
| try { |
| onSuccess.call$1(userCode.call$0()); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| replacement = $.Zone__current.errorCallback$2(e, s); |
| if (replacement == null) |
| onError.call$2(e, s); |
| else { |
| error0 = J.get$error$x(replacement); |
| error = error0 == null ? new P.NullThrownError() : error0; |
| 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 !== $.$get$Future__nullFuture()) |
| 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 !== $.$get$Future__nullFuture()) |
| cancelFuture.whenComplete$1(new P._cancelAndValue_closure(future, value)); |
| else |
| future._complete$1(value); |
| }, |
| _addErrorWithReplacement: function(sink, error, stackTrace) { |
| var replacement = $.Zone__current.errorCallback$2(error, stackTrace); |
| if (replacement != null) { |
| error = J.get$error$x(replacement); |
| if (error == null) |
| error = new P.NullThrownError(); |
| stackTrace = replacement.get$stackTrace(); |
| } |
| sink._addError$2(error, stackTrace); |
| }, |
| Timer_Timer: function(duration, callback) { |
| var t1; |
| if (J.$eq$($.Zone__current, C.C__RootZone)) |
| return $.Zone__current.createTimer$2(duration, callback); |
| t1 = $.Zone__current; |
| return t1.createTimer$2(duration, t1.bindCallbackGuarded$1(callback)); |
| }, |
| Timer_Timer$periodic: function(duration, callback) { |
| var boundCallback; |
| if (J.$eq$($.Zone__current, C.C__RootZone)) |
| return $.Zone__current.createPeriodicTimer$2(duration, callback); |
| boundCallback = $.Zone__current.bindUnaryCallbackGuarded$1(callback); |
| return $.Zone__current.createPeriodicTimer$2(duration, boundCallback); |
| }, |
| Timer__createTimer: function(duration, callback) { |
| var milliseconds = duration.get$inMilliseconds(); |
| return H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback); |
| }, |
| Timer__createPeriodicTimer: function(duration, callback) { |
| var milliseconds = duration.get$inMilliseconds(); |
| return H.TimerImpl$periodic(milliseconds < 0 ? 0 : milliseconds, callback); |
| }, |
| _parentDelegate: function(zone) { |
| if (zone.get$parent(zone) == null) |
| return; |
| return zone.get$parent(zone).get$_delegate(); |
| }, |
| _rootHandleUncaughtError: [function($self, $parent, zone, error, stackTrace) { |
| var t1 = {}; |
| t1.error = error; |
| P._schedulePriorityAsyncCallback(new P._rootHandleUncaughtError_closure(t1, stackTrace)); |
| }, "call$5", "async___rootHandleUncaughtError$closure", 10, 0, 29], |
| _rootRun: [function($self, $parent, zone, f) { |
| var old, previous, t1; |
| if (J.$eq$($.Zone__current, zone)) |
| return f.call$0(); |
| previous = $.Zone__current; |
| $.Zone__current = zone; |
| old = previous; |
| try { |
| t1 = f.call$0(); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, "call$4", "async___rootRun$closure", 8, 0, function() { |
| return {func: 1, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1}]}; |
| }, 9, 10, 11, 14], |
| _rootRunUnary: [function($self, $parent, zone, f, arg) { |
| var old, previous, t1; |
| if (J.$eq$($.Zone__current, zone)) |
| return f.call$1(arg); |
| previous = $.Zone__current; |
| $.Zone__current = zone; |
| old = previous; |
| try { |
| t1 = f.call$1(arg); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, "call$5", "async___rootRunUnary$closure", 10, 0, function() { |
| return {func: 1, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1, args: [,]},,]}; |
| }, 9, 10, 11, 14, 12], |
| _rootRunBinary: [function($self, $parent, zone, f, arg1, arg2) { |
| var old, previous, t1; |
| if (J.$eq$($.Zone__current, zone)) |
| return f.call$2(arg1, arg2); |
| previous = $.Zone__current; |
| $.Zone__current = zone; |
| old = previous; |
| try { |
| t1 = f.call$2(arg1, arg2); |
| return t1; |
| } finally { |
| $.Zone__current = old; |
| } |
| }, "call$6", "async___rootRunBinary$closure", 12, 0, function() { |
| return {func: 1, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1, args: [,,]},,,]}; |
| }, 9, 10, 11, 14, 16, 17], |
| _rootRegisterCallback: [function($self, $parent, zone, f) { |
| return f; |
| }, "call$4", "async___rootRegisterCallback$closure", 8, 0, function() { |
| return {func: 1, ret: {func: 1}, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1}]}; |
| }], |
| _rootRegisterUnaryCallback: [function($self, $parent, zone, f) { |
| return f; |
| }, "call$4", "async___rootRegisterUnaryCallback$closure", 8, 0, function() { |
| return {func: 1, ret: {func: 1, args: [,]}, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1, args: [,]}]}; |
| }], |
| _rootRegisterBinaryCallback: [function($self, $parent, zone, f) { |
| return f; |
| }, "call$4", "async___rootRegisterBinaryCallback$closure", 8, 0, function() { |
| return {func: 1, ret: {func: 1, args: [,,]}, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1, args: [,,]}]}; |
| }], |
| _rootErrorCallback: [function($self, $parent, zone, error, stackTrace) { |
| return; |
| }, "call$5", "async___rootErrorCallback$closure", 10, 0, 30], |
| _rootScheduleMicrotask: [function($self, $parent, zone, f) { |
| var t1 = C.C__RootZone !== zone; |
| if (t1) |
| f = !(!t1 || C.C__RootZone.get$errorZone() === zone.get$errorZone()) ? zone.bindCallbackGuarded$1(f) : zone.bindCallback$1(f); |
| P._scheduleAsyncCallback(f); |
| }, "call$4", "async___rootScheduleMicrotask$closure", 8, 0, 31], |
| _rootCreateTimer: [function($self, $parent, zone, duration, callback) { |
| return P.Timer__createTimer(duration, C.C__RootZone !== zone ? zone.bindCallback$1(callback) : callback); |
| }, "call$5", "async___rootCreateTimer$closure", 10, 0, 32], |
| _rootCreatePeriodicTimer: [function($self, $parent, zone, duration, callback) { |
| return P.Timer__createPeriodicTimer(duration, C.C__RootZone !== zone ? zone.bindUnaryCallback$1(callback) : callback); |
| }, "call$5", "async___rootCreatePeriodicTimer$closure", 10, 0, 33], |
| _rootPrint: [function($self, $parent, zone, line) { |
| H.printString(H.S(line)); |
| }, "call$4", "async___rootPrint$closure", 8, 0, 34], |
| _printToZone: [function(line) { |
| J.print$1$x($.Zone__current, line); |
| }, "call$1", "async___printToZone$closure", 2, 0, 35], |
| _rootFork: [function($self, $parent, zone, specification, zoneValues) { |
| var valueMap, t1, t2; |
| $.printToZone = P.async___printToZone$closure(); |
| if (specification == null) |
| specification = C._ZoneSpecification_ALf; |
| else if (!(specification instanceof P._ZoneSpecification)) |
| throw H.wrapException(P.ArgumentError$("ZoneSpecifications must be instantiated with the provided constructor.")); |
| if (zoneValues == null) |
| valueMap = zone instanceof P._Zone ? zone.get$_async$_map() : P.HashMap_HashMap(null, null, null, null, null); |
| else |
| valueMap = P.HashMap_HashMap$from(zoneValues, null, null); |
| t1 = new P._CustomZone(null, null, null, null, null, null, null, null, null, null, null, null, null, null, zone, valueMap); |
| t2 = zone.get$_run(); |
| t1._run = t2; |
| t2 = zone.get$_runUnary(); |
| t1._runUnary = t2; |
| t2 = zone.get$_runBinary(); |
| t1._runBinary = t2; |
| t2 = zone.get$_registerCallback(); |
| t1._registerCallback = t2; |
| t2 = zone.get$_registerUnaryCallback(); |
| t1._registerUnaryCallback = t2; |
| t2 = zone.get$_registerBinaryCallback(); |
| t1._registerBinaryCallback = t2; |
| t2 = zone.get$_errorCallback(); |
| t1._errorCallback = t2; |
| t2 = zone.get$_scheduleMicrotask(); |
| t1._scheduleMicrotask = t2; |
| t2 = zone.get$_createTimer(); |
| t1._createTimer = t2; |
| t2 = zone.get$_createPeriodicTimer(); |
| t1._createPeriodicTimer = t2; |
| t2 = zone.get$_print(); |
| t1._print = t2; |
| t2 = zone.get$_fork(); |
| t1._fork = t2; |
| t2 = specification.handleUncaughtError; |
| t1._handleUncaughtError = t2 != null ? new P._ZoneFunction(t1, t2) : zone.get$_handleUncaughtError(); |
| return t1; |
| }, "call$5", "async___rootFork$closure", 10, 0, 36], |
| runZoned: function(body, onError, zoneSpecification, zoneValues) { |
| var zone, e, stackTrace, t1, exception; |
| t1 = !H.functionTypeTest(onError, {func: 1, args: [P.Object, P.StackTrace]}) && !H.functionTypeTest(onError, {func: 1, args: [P.Object]}); |
| if (t1) |
| throw H.wrapException(P.ArgumentError$("onError callback must take an Object (the error), or an Object (the error) and a StackTrace")); |
| zone = $.Zone__current.fork$2$specification$zoneValues(new P._ZoneSpecification(new P.runZoned_closure(onError), null, null, null, null, null, null, null, null, null, null, null, null), zoneValues); |
| try { |
| t1 = zone.run$1(body); |
| return t1; |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| stackTrace = H.getTraceFromException(exception); |
| if (H.functionTypeTest(onError, {func: 1, args: [P.Object, P.StackTrace]})) { |
| zone.runBinary$3(onError, e, stackTrace); |
| return; |
| } |
| zone.runUnary$2(onError, e); |
| return; |
| } |
| }, |
| _AsyncRun__initializeScheduleImmediate_internalCallback: { |
| "^": "Closure:0;_box_0", |
| call$1: [function(_) { |
| var t1, f; |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| t1 = this._box_0; |
| f = t1.storedCallback; |
| t1.storedCallback = null; |
| f.call$0(); |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| _AsyncRun__initializeScheduleImmediate_closure: { |
| "^": "Closure:37;_box_0,div,span", |
| call$1: function(callback) { |
| var t1, t2; |
| ++init.globalState.topEventLoop._activeJsAsyncCount; |
| this._box_0.storedCallback = callback; |
| t1 = this.div; |
| t2 = this.span; |
| t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2); |
| } |
| }, |
| _AsyncRun__scheduleImmediateJsOverride_internalCallback: { |
| "^": "Closure:1;callback", |
| call$0: [function() { |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| this.callback.call$0(); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: { |
| "^": "Closure:1;callback", |
| call$0: [function() { |
| --init.globalState.topEventLoop._activeJsAsyncCount; |
| this.callback.call$0(); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _awaitOnObject_closure: { |
| "^": "Closure:0;bodyFunction", |
| call$1: [function(result) { |
| return this.bodyFunction.call$2(0, result); |
| }, null, null, 2, 0, null, 13, "call"] |
| }, |
| _awaitOnObject_closure0: { |
| "^": "Closure:7;bodyFunction", |
| call$2: [function(error, stackTrace) { |
| this.bodyFunction.call$2(1, new H.ExceptionAndStackTrace(error, stackTrace)); |
| }, null, null, 4, 0, null, 0, 1, "call"] |
| }, |
| _wrapJsFunctionForAsync_closure: { |
| "^": "Closure:19;$protected", |
| call$2: [function(errorCode, result) { |
| this.$protected(errorCode, result); |
| }, null, null, 4, 0, null, 27, 13, "call"] |
| }, |
| Future: { |
| "^": "Object;$ti" |
| }, |
| _Completer: { |
| "^": "Object;future<,$ti", |
| completeError$2: function(error, stackTrace) { |
| var replacement; |
| if (error == null) |
| error = new P.NullThrownError(); |
| if (this.future._state !== 0) |
| throw H.wrapException(new P.StateError("Future already completed")); |
| replacement = $.Zone__current.errorCallback$2(error, stackTrace); |
| if (replacement != null) { |
| error = J.get$error$x(replacement); |
| if (error == null) |
| error = new P.NullThrownError(); |
| stackTrace = replacement.get$stackTrace(); |
| } |
| this._completeError$2(error, stackTrace); |
| }, |
| completeError$1: function(error) { |
| return this.completeError$2(error, null); |
| } |
| }, |
| _AsyncCompleter: { |
| "^": "_Completer;future,$ti", |
| 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); |
| }, |
| complete$0: function($receiver) { |
| return this.complete$1($receiver, null); |
| }, |
| _completeError$2: function(error, stackTrace) { |
| this.future._asyncCompleteError$2(error, stackTrace); |
| } |
| }, |
| _SyncCompleter: { |
| "^": "_Completer;future,$ti", |
| 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); |
| }, function($receiver) { |
| return this.complete$1($receiver, null); |
| }, "complete$0", "call$1", "call$0", "get$complete", 0, 2, 25, 3, 8], |
| _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$handlesError: function() { |
| return (this.state & 2) !== 0; |
| }, |
| get$handlesComplete: function() { |
| return this.state === 8; |
| }, |
| get$hasErrorCallback: function() { |
| return this.errorCallback != null; |
| }, |
| handleValue$1: function(sourceResult) { |
| return this.result._zone.runUnary$2(this.callback, sourceResult); |
| }, |
| matchesErrorTest$1: function(asyncError) { |
| if (this.state !== 6) |
| return true; |
| return this.result._zone.runUnary$2(this.callback, J.get$error$x(asyncError)); |
| }, |
| handleError$1: function(asyncError) { |
| var errorCallback, t1, t2; |
| errorCallback = this.errorCallback; |
| t1 = J.getInterceptor$x(asyncError); |
| t2 = this.result._zone; |
| if (H.functionTypeTest(errorCallback, {func: 1, args: [P.Object, P.StackTrace]})) |
| return t2.runBinary$3(errorCallback, t1.get$error(asyncError), asyncError.get$stackTrace()); |
| else |
| return t2.runUnary$2(errorCallback, t1.get$error(asyncError)); |
| }, |
| handleWhenComplete$0: function() { |
| return this.result._zone.run$1(this.callback); |
| }, |
| errorCallback$2: function(arg0, arg1) { |
| return this.errorCallback.call$2(arg0, arg1); |
| } |
| }, |
| _Future: { |
| "^": "Object;_state<,_zone<,_resultOrListeners<,$ti", |
| get$_isChained: function() { |
| return this._state === 2; |
| }, |
| get$_isComplete: function() { |
| return this._state >= 4; |
| }, |
| get$_hasError: function() { |
| return this._state === 8; |
| }, |
| _setChained$1: function(source) { |
| this._state = 2; |
| this._resultOrListeners = source; |
| }, |
| then$2$onError: function(f, onError) { |
| var currentZone = $.Zone__current; |
| if (currentZone !== C.C__RootZone) { |
| f = currentZone.registerUnaryCallback$1(f); |
| 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 = 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, this.$ti); |
| this._addListener$1(new P._FutureListener(null, result, 8, t1 !== C.C__RootZone ? t1.registerCallback$1(action) : action, null)); |
| return result; |
| }, |
| _setPendingComplete$0: function() { |
| this._state = 1; |
| }, |
| _clearPendingComplete$0: function() { |
| this._state = 0; |
| }, |
| get$_error: function() { |
| return this._resultOrListeners; |
| }, |
| get$_chainSource: function() { |
| return this._resultOrListeners; |
| }, |
| _setValue$1: function(value) { |
| this._state = 4; |
| this._resultOrListeners = value; |
| }, |
| _setErrorObject$1: function(error) { |
| this._state = 8; |
| this._resultOrListeners = error; |
| }, |
| _cloneResult$1: function(source) { |
| this._state = source.get$_state(); |
| this._resultOrListeners = source.get$_resultOrListeners(); |
| }, |
| _addListener$1: function(listener) { |
| var t1, source; |
| t1 = this._state; |
| if (t1 <= 1) { |
| listener._nextListener = this._resultOrListeners; |
| this._resultOrListeners = listener; |
| } else { |
| if (t1 === 2) { |
| source = this._resultOrListeners; |
| if (!source.get$_isComplete()) { |
| source._addListener$1(listener); |
| return; |
| } |
| this._state = source.get$_state(); |
| this._resultOrListeners = source.get$_resultOrListeners(); |
| } |
| this._zone.scheduleMicrotask$1(new P._Future__addListener_closure(this, listener)); |
| } |
| }, |
| _prependListeners$1: function(listeners) { |
| var _box_0, t1, existingListeners, cursor, source; |
| _box_0 = {}; |
| _box_0.listeners = listeners; |
| if (listeners == null) |
| return; |
| t1 = this._state; |
| if (t1 <= 1) { |
| existingListeners = this._resultOrListeners; |
| this._resultOrListeners = listeners; |
| if (existingListeners != null) { |
| for (cursor = listeners; cursor.get$_nextListener() != null;) |
| cursor = cursor.get$_nextListener(); |
| cursor.set$_nextListener(existingListeners); |
| } |
| } else { |
| if (t1 === 2) { |
| source = this._resultOrListeners; |
| if (!source.get$_isComplete()) { |
| source._prependListeners$1(listeners); |
| return; |
| } |
| this._state = source.get$_state(); |
| this._resultOrListeners = source.get$_resultOrListeners(); |
| } |
| _box_0.listeners = this._reverseListeners$1(listeners); |
| this._zone.scheduleMicrotask$1(new P._Future__prependListeners_closure(_box_0, this)); |
| } |
| }, |
| _removeListeners$0: function() { |
| var current = this._resultOrListeners; |
| this._resultOrListeners = null; |
| return this._reverseListeners$1(current); |
| }, |
| _reverseListeners$1: function(listeners) { |
| var current, prev, next; |
| for (current = listeners, prev = null; current != null; prev = current, current = next) { |
| next = current.get$_nextListener(); |
| current.set$_nextListener(prev); |
| } |
| return prev; |
| }, |
| _complete$1: function(value) { |
| var t1, listeners; |
| t1 = this.$ti; |
| if (H.checkSubtype(value, "$isFuture", t1, "$asFuture")) |
| if (H.checkSubtype(value, "$is_Future", t1, null)) |
| P._Future__chainCoreFuture(value, this); |
| else |
| P._Future__chainForeignFuture(value, this); |
| else { |
| listeners = this._removeListeners$0(); |
| this._state = 4; |
| this._resultOrListeners = value; |
| P._Future__propagateToListeners(this, listeners); |
| } |
| }, |
| _completeError$2: [function(error, stackTrace) { |
| var listeners = this._removeListeners$0(); |
| this._state = 8; |
| this._resultOrListeners = 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, 5, 3, 0, 1], |
| _asyncComplete$1: function(value) { |
| if (H.checkSubtype(value, "$isFuture", this.$ti, "$asFuture")) { |
| this._chainFuture$1(value); |
| return; |
| } |
| this._state = 1; |
| this._zone.scheduleMicrotask$1(new P._Future__asyncComplete_closure(this, value)); |
| }, |
| _chainFuture$1: function(value) { |
| if (H.checkSubtype(value, "$is_Future", this.$ti, null)) { |
| if (value._state === 8) { |
| this._state = 1; |
| this._zone.scheduleMicrotask$1(new P._Future__chainFuture_closure(this, value)); |
| } else |
| P._Future__chainCoreFuture(value, this); |
| return; |
| } |
| P._Future__chainForeignFuture(value, this); |
| }, |
| _asyncCompleteError$2: function(error, stackTrace) { |
| this._state = 1; |
| this._zone.scheduleMicrotask$1(new P._Future__asyncCompleteError_closure(this, error, stackTrace)); |
| }, |
| $isFuture: 1, |
| static: { |
| _Future$value: function(value, $T) { |
| var t1 = new P._Future(0, $.Zone__current, null, [$T]); |
| t1._state = 4; |
| t1._resultOrListeners = value; |
| return t1; |
| }, |
| _Future__chainForeignFuture: function(source, target) { |
| var e, s, exception; |
| target._setPendingComplete$0(); |
| try { |
| source.then$2$onError(new P._Future__chainForeignFuture_closure(target), new P._Future__chainForeignFuture_closure0(target)); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| P.scheduleMicrotask(new P._Future__chainForeignFuture_closure1(target, e, s)); |
| } |
| }, |
| _Future__chainCoreFuture: function(source, target) { |
| var listeners; |
| for (; source.get$_isChained();) |
| source = source.get$_chainSource(); |
| if (source.get$_isComplete()) { |
| listeners = target._removeListeners$0(); |
| target._cloneResult$1(source); |
| P._Future__propagateToListeners(target, listeners); |
| } else { |
| listeners = target.get$_resultOrListeners(); |
| target._setChained$1(source); |
| source._prependListeners$1(listeners); |
| } |
| }, |
| _Future__propagateToListeners: function(source, listeners) { |
| var _box_1, t1, _box_0, hasError, asyncError, listeners0, sourceResult, zone, oldZone, result, t2; |
| _box_1 = {}; |
| _box_1.source = source; |
| for (t1 = source; true;) { |
| _box_0 = {}; |
| hasError = t1.get$_hasError(); |
| if (listeners == null) { |
| if (hasError) { |
| asyncError = _box_1.source.get$_error(); |
| _box_1.source.get$_zone().handleUncaughtError$2(J.get$error$x(asyncError), asyncError.get$stackTrace()); |
| } |
| return; |
| } |
| for (; listeners.get$_nextListener() != null; listeners = listeners0) { |
| listeners0 = listeners.get$_nextListener(); |
| listeners.set$_nextListener(null); |
| P._Future__propagateToListeners(_box_1.source, listeners); |
| } |
| sourceResult = _box_1.source.get$_resultOrListeners(); |
| _box_0.listenerHasError = hasError; |
| _box_0.listenerValueOrError = sourceResult; |
| t1 = !hasError; |
| if (!t1 || listeners.get$handlesValue() || listeners.get$handlesComplete()) { |
| zone = listeners.get$_zone(); |
| if (hasError && !_box_1.source.get$_zone().inSameErrorZone$1(zone)) { |
| asyncError = _box_1.source.get$_error(); |
| _box_1.source.get$_zone().handleUncaughtError$2(J.get$error$x(asyncError), asyncError.get$stackTrace()); |
| return; |
| } |
| oldZone = $.Zone__current; |
| if (oldZone == null ? zone != null : oldZone !== zone) |
| $.Zone__current = zone; |
| else |
| oldZone = null; |
| if (listeners.get$handlesComplete()) |
| new P._Future__propagateToListeners_handleWhenCompleteCallback(_box_1, _box_0, hasError, listeners).call$0(); |
| else if (t1) { |
| if (listeners.get$handlesValue()) |
| new P._Future__propagateToListeners_handleValueCallback(_box_0, listeners, sourceResult).call$0(); |
| } else if (listeners.get$handlesError()) |
| new P._Future__propagateToListeners_handleError(_box_1, _box_0, listeners).call$0(); |
| if (oldZone != null) |
| $.Zone__current = oldZone; |
| t1 = _box_0.listenerValueOrError; |
| if (!!J.getInterceptor(t1).$isFuture) { |
| result = J.get$result$x(listeners); |
| if (t1._state >= 4) { |
| listeners = result._removeListeners$0(); |
| result._cloneResult$1(t1); |
| _box_1.source = t1; |
| continue; |
| } else |
| P._Future__chainCoreFuture(t1, result); |
| return; |
| } |
| } |
| result = J.get$result$x(listeners); |
| listeners = result._removeListeners$0(); |
| t1 = _box_0.listenerHasError; |
| t2 = _box_0.listenerValueOrError; |
| if (!t1) |
| result._setValue$1(t2); |
| else |
| result._setErrorObject$1(t2); |
| _box_1.source = result; |
| t1 = result; |
| } |
| } |
| } |
| }, |
| _Future__addListener_closure: { |
| "^": "Closure:1;$this,listener", |
| call$0: [function() { |
| P._Future__propagateToListeners(this.$this, this.listener); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__prependListeners_closure: { |
| "^": "Closure:1;_box_0,$this", |
| call$0: [function() { |
| P._Future__propagateToListeners(this.$this, this._box_0.listeners); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__chainForeignFuture_closure: { |
| "^": "Closure:0;target", |
| call$1: [function(value) { |
| var t1 = this.target; |
| t1._clearPendingComplete$0(); |
| t1._complete$1(value); |
| }, null, null, 2, 0, null, 8, "call"] |
| }, |
| _Future__chainForeignFuture_closure0: { |
| "^": "Closure:11;target", |
| call$2: [function(error, stackTrace) { |
| this.target._completeError$2(error, stackTrace); |
| }, function(error) { |
| return this.call$2(error, null); |
| }, "call$1", null, null, null, 2, 2, null, 3, 0, 1, "call"] |
| }, |
| _Future__chainForeignFuture_closure1: { |
| "^": "Closure:1;target,e,s", |
| call$0: [function() { |
| this.target._completeError$2(this.e, this.s); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__asyncComplete_closure: { |
| "^": "Closure:1;$this,value", |
| call$0: [function() { |
| var t1, listeners; |
| t1 = this.$this; |
| listeners = t1._removeListeners$0(); |
| t1._state = 4; |
| t1._resultOrListeners = this.value; |
| P._Future__propagateToListeners(t1, listeners); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__chainFuture_closure: { |
| "^": "Closure:1;$this,value", |
| call$0: [function() { |
| P._Future__chainCoreFuture(this.value, this.$this); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__asyncCompleteError_closure: { |
| "^": "Closure:1;$this,error,stackTrace", |
| call$0: [function() { |
| this.$this._completeError$2(this.error, this.stackTrace); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _Future__propagateToListeners_handleWhenCompleteCallback: { |
| "^": "Closure:2;_box_1,_box_0,hasError,listener", |
| call$0: function() { |
| var completeResult, e, s, exception, t1, t2, originalSource; |
| completeResult = null; |
| try { |
| completeResult = this.listener.handleWhenComplete$0(); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| if (this.hasError) { |
| t1 = J.get$error$x(this._box_1.source.get$_error()); |
| t2 = e; |
| t2 = t1 == null ? t2 == null : t1 === t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| t2 = this._box_0; |
| if (t1) |
| t2.listenerValueOrError = this._box_1.source.get$_error(); |
| else |
| t2.listenerValueOrError = new P.AsyncError(e, s); |
| t2.listenerHasError = true; |
| return; |
| } |
| if (!!J.getInterceptor(completeResult).$isFuture) { |
| if (completeResult instanceof P._Future && completeResult.get$_state() >= 4) { |
| if (completeResult.get$_state() === 8) { |
| t1 = this._box_0; |
| t1.listenerValueOrError = completeResult.get$_resultOrListeners(); |
| t1.listenerHasError = true; |
| } |
| return; |
| } |
| originalSource = this._box_1.source; |
| t1 = this._box_0; |
| t1.listenerValueOrError = completeResult.then$1(new P._Future__propagateToListeners_handleWhenCompleteCallback_closure(originalSource)); |
| t1.listenerHasError = false; |
| } |
| } |
| }, |
| _Future__propagateToListeners_handleWhenCompleteCallback_closure: { |
| "^": "Closure:0;originalSource", |
| call$1: [function(_) { |
| return this.originalSource; |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| _Future__propagateToListeners_handleValueCallback: { |
| "^": "Closure:2;_box_0,listener,sourceResult", |
| call$0: function() { |
| var e, s, exception, t1; |
| try { |
| this._box_0.listenerValueOrError = this.listener.handleValue$1(this.sourceResult); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| t1 = this._box_0; |
| t1.listenerValueOrError = new P.AsyncError(e, s); |
| t1.listenerHasError = true; |
| } |
| } |
| }, |
| _Future__propagateToListeners_handleError: { |
| "^": "Closure:2;_box_1,_box_0,listener", |
| call$0: function() { |
| var asyncError, e, s, t1, t2, exception, t3, t4; |
| try { |
| asyncError = this._box_1.source.get$_error(); |
| t1 = this.listener; |
| if (t1.matchesErrorTest$1(asyncError) === true && t1.get$hasErrorCallback()) { |
| t2 = this._box_0; |
| t2.listenerValueOrError = t1.handleError$1(asyncError); |
| t2.listenerHasError = false; |
| } |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| t1 = this._box_1; |
| t2 = J.get$error$x(t1.source.get$_error()); |
| t3 = e; |
| t4 = this._box_0; |
| if (t2 == null ? t3 == null : t2 === t3) |
| t4.listenerValueOrError = t1.source.get$_error(); |
| else |
| t4.listenerValueOrError = new P.AsyncError(e, s); |
| t4.listenerHasError = true; |
| } |
| } |
| }, |
| _AsyncCallbackEntry: { |
| "^": "Object;callback,next" |
| }, |
| Stream: { |
| "^": "Object;$ti", |
| map$1: function(_, convert) { |
| return new P._MapStream(convert, this, [H.getRuntimeTypeArgument(this, "Stream", 0), null]); |
| }, |
| handleError$2$test: function(onError, test) { |
| return new P._HandleErrorStream(onError, test, this, [H.getRuntimeTypeArgument(this, "Stream", 0)]); |
| }, |
| handleError$1: function(onError) { |
| return this.handleError$2$test(onError, null); |
| }, |
| pipe$1: function(streamConsumer) { |
| return streamConsumer.addStream$1(this).then$1(new P.Stream_pipe_closure(streamConsumer)); |
| }, |
| contains$1: function(_, needle) { |
| var t1, future; |
| t1 = {}; |
| future = new P._Future(0, $.Zone__current, null, [P.bool]); |
| t1.subscription = null; |
| t1.subscription = 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 = new P._Future(0, $.Zone__current, null, [null]); |
| t1.subscription = null; |
| t1.subscription = 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 = new P._Future(0, $.Zone__current, null, [P.int]); |
| t1.count = 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 = new P._Future(0, $.Zone__current, null, [P.bool]); |
| t1.subscription = null; |
| t1.subscription = 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 t1, result, future; |
| t1 = H.getRuntimeTypeArgument(this, "Stream", 0); |
| result = H.setRuntimeTypeInfo([], [t1]); |
| future = new P._Future(0, $.Zone__current, null, [[P.List, t1]]); |
| 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; |
| }, |
| skip$1: function(_, count) { |
| if (typeof count !== "number" || Math.floor(count) !== count || count < 0) |
| H.throwExpression(P.ArgumentError$(count)); |
| return new P._SkipStream(count, this, [H.getRuntimeTypeArgument(this, "Stream", 0)]); |
| } |
| }, |
| Stream_pipe_closure: { |
| "^": "Closure:0;streamConsumer", |
| call$1: [function(_) { |
| return this.streamConsumer.close$0(0); |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| Stream_contains_closure: { |
| "^": "Closure;_box_0,$this,needle,future", |
| call$1: [function(element) { |
| var t1, t2; |
| t1 = this._box_0; |
| t2 = this.future; |
| P._runUserCode(new P.Stream_contains__closure(this.needle, element), new P.Stream_contains__closure0(t1, t2), P._cancelAndErrorClosure(t1.subscription, t2)); |
| }, null, null, 2, 0, null, 21, "call"], |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this.$this, "Stream"); |
| } |
| }, |
| Stream_contains__closure: { |
| "^": "Closure:1;needle,element", |
| call$0: function() { |
| return J.$eq$(this.element, this.needle); |
| } |
| }, |
| Stream_contains__closure0: { |
| "^": "Closure:10;_box_0,future", |
| call$1: function(isMatch) { |
| if (isMatch === true) |
| P._cancelAndValue(this._box_0.subscription, this.future, true); |
| } |
| }, |
| Stream_contains_closure0: { |
| "^": "Closure:1;future", |
| call$0: [function() { |
| this.future._complete$1(false); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| Stream_forEach_closure: { |
| "^": "Closure;_box_0,$this,action,future", |
| call$1: [function(element) { |
| P._runUserCode(new P.Stream_forEach__closure(this.action, element), new P.Stream_forEach__closure0(), P._cancelAndErrorClosure(this._box_0.subscription, this.future)); |
| }, null, null, 2, 0, null, 21, "call"], |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this.$this, "Stream"); |
| } |
| }, |
| Stream_forEach__closure: { |
| "^": "Closure:1;action,element", |
| call$0: function() { |
| return this.action.call$1(this.element); |
| } |
| }, |
| Stream_forEach__closure0: { |
| "^": "Closure:0;", |
| call$1: function(_) { |
| } |
| }, |
| Stream_forEach_closure0: { |
| "^": "Closure:1;future", |
| call$0: [function() { |
| this.future._complete$1(null); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| Stream_length_closure: { |
| "^": "Closure:0;_box_0", |
| call$1: [function(_) { |
| ++this._box_0.count; |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| Stream_length_closure0: { |
| "^": "Closure:1;_box_0,future", |
| call$0: [function() { |
| this.future._complete$1(this._box_0.count); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| Stream_isEmpty_closure: { |
| "^": "Closure:0;_box_0,future", |
| call$1: [function(_) { |
| P._cancelAndValue(this._box_0.subscription, this.future, false); |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| Stream_isEmpty_closure0: { |
| "^": "Closure:1;future", |
| call$0: [function() { |
| this.future._complete$1(true); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| Stream_toList_closure: { |
| "^": "Closure;$this,result", |
| call$1: [function(data) { |
| this.result.push(data); |
| }, null, null, 2, 0, null, 15, "call"], |
| $signature: function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, args: [T]}; |
| }, this.$this, "Stream"); |
| } |
| }, |
| Stream_toList_closure0: { |
| "^": "Closure:1;result,future", |
| call$0: [function() { |
| this.future._complete$1(this.result); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| StreamSubscription: { |
| "^": "Object;" |
| }, |
| _StreamController: { |
| "^": "Object;_state<,$ti", |
| get$isPaused: function() { |
| var t1 = this._state; |
| return (t1 & 1) !== 0 ? this.get$_subscription().get$_isInputPaused() : (t1 & 2) === 0; |
| }, |
| get$_pendingEvents: function() { |
| if ((this._state & 8) === 0) |
| return this._varData; |
| return this._varData.get$varData(); |
| }, |
| _ensurePendingEvents$0: function() { |
| var t1, state; |
| if ((this._state & 8) === 0) { |
| t1 = this._varData; |
| if (t1 == null) { |
| t1 = new P._StreamImplEvents(null, null, 0); |
| this._varData = t1; |
| } |
| return t1; |
| } |
| state = this._varData; |
| if (state.get$varData() == null) |
| state.set$varData(new P._StreamImplEvents(null, null, 0)); |
| return state.get$varData(); |
| }, |
| get$_subscription: function() { |
| if ((this._state & 8) !== 0) |
| return this._varData.get$varData(); |
| return this._varData; |
| }, |
| _badEventState$0: function() { |
| if ((this._state & 4) !== 0) |
| return new P.StateError("Cannot add event after closing"); |
| return new P.StateError("Cannot add event while adding a stream"); |
| }, |
| _ensureDoneFuture$0: function() { |
| var t1 = this._doneFuture; |
| if (t1 == null) { |
| t1 = (this._state & 2) !== 0 ? $.$get$Future__nullFuture() : new P._Future(0, $.Zone__current, null, [null]); |
| this._doneFuture = t1; |
| } |
| return t1; |
| }, |
| add$1: [function(_, value) { |
| if (this._state >= 4) |
| throw H.wrapException(this._badEventState$0()); |
| this._async$_add$1(value); |
| }, "call$1", "get$add", 2, 0, function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, v: true, args: [T]}; |
| }, this.$receiver, "_StreamController"); |
| }, 8], |
| addError$2: [function(error, stackTrace) { |
| var replacement; |
| if (this._state >= 4) |
| throw H.wrapException(this._badEventState$0()); |
| if (error == null) |
| error = new P.NullThrownError(); |
| replacement = $.Zone__current.errorCallback$2(error, stackTrace); |
| if (replacement != null) { |
| error = J.get$error$x(replacement); |
| if (error == null) |
| error = new P.NullThrownError(); |
| stackTrace = replacement.get$stackTrace(); |
| } |
| this._addError$2(error, stackTrace); |
| }, function(error) { |
| return this.addError$2(error, null); |
| }, "addError$1", "call$2", "call$1", "get$addError", 2, 2, 5, 3, 0, 1], |
| close$0: [function(_) { |
| var t1 = this._state; |
| if ((t1 & 4) !== 0) |
| return this._ensureDoneFuture$0(); |
| if (t1 >= 4) |
| throw H.wrapException(this._badEventState$0()); |
| t1 |= 4; |
| this._state = t1; |
| if ((t1 & 1) !== 0) |
| this._sendDone$0(); |
| else if ((t1 & 3) === 0) |
| this._ensurePendingEvents$0().add$1(0, C.C__DelayedDone); |
| return this._ensureDoneFuture$0(); |
| }, null, "get$close", 0, 0, null], |
| _async$_add$1: function(value) { |
| var t1 = this._state; |
| if ((t1 & 1) !== 0) |
| this._sendData$1(value); |
| else if ((t1 & 3) === 0) |
| this._ensurePendingEvents$0().add$1(0, new P._DelayedData(value, null)); |
| }, |
| _addError$2: function(error, stackTrace) { |
| var t1 = this._state; |
| if ((t1 & 1) !== 0) |
| this._sendError$2(error, stackTrace); |
| else if ((t1 & 3) === 0) |
| this._ensurePendingEvents$0().add$1(0, new P._DelayedError(error, stackTrace, null)); |
| }, |
| _subscribe$4: function(onData, onError, onDone, cancelOnError) { |
| var t1, t2, subscription, pendingEvents, addState; |
| if ((this._state & 3) !== 0) |
| throw H.wrapException(new P.StateError("Stream has already been listened to.")); |
| t1 = $.Zone__current; |
| t2 = cancelOnError ? 1 : 0; |
| subscription = new P._ControllerSubscription(this, null, null, null, t1, t2, null, null, this.$ti); |
| subscription._BufferingStreamSubscription$4(onData, onError, onDone, cancelOnError, H.getTypeArgumentByIndex(this, 0)); |
| pendingEvents = this.get$_pendingEvents(); |
| t2 = this._state |= 1; |
| if ((t2 & 8) !== 0) { |
| addState = this._varData; |
| addState.set$varData(subscription); |
| addState.resume$0(0); |
| } else |
| this._varData = subscription; |
| subscription._setPendingEvents$1(pendingEvents); |
| subscription._guardCallback$1(new P._StreamController__subscribe_closure(this)); |
| return subscription; |
| }, |
| _recordCancel$1: function(subscription) { |
| var result, e, s, t1, exception, result0; |
| result = null; |
| if ((this._state & 8) !== 0) |
| result = this._varData.cancel$0(); |
| this._varData = null; |
| this._state = this._state & 4294967286 | 2; |
| t1 = this.onCancel; |
| if (t1 != null) |
| if (result == null) |
| try { |
| result = t1.call$0(); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| result0 = new P._Future(0, $.Zone__current, null, [null]); |
| result0._asyncCompleteError$2(e, s); |
| result = result0; |
| } |
| else |
| result = result.whenComplete$1(t1); |
| t1 = new P._StreamController__recordCancel_complete(this); |
| if (result != null) |
| result = result.whenComplete$1(t1); |
| else |
| t1.call$0(); |
| return result; |
| } |
| }, |
| _StreamController__subscribe_closure: { |
| "^": "Closure:1;$this", |
| call$0: function() { |
| P._runGuarded(this.$this.onListen); |
| } |
| }, |
| _StreamController__recordCancel_complete: { |
| "^": "Closure:2;$this", |
| call$0: [function() { |
| var t1 = this.$this._doneFuture; |
| if (t1 != null && t1._state === 0) |
| t1._asyncComplete$1(null); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _SyncStreamControllerDispatch: { |
| "^": "Object;", |
| _sendData$1: function(data) { |
| this.get$_subscription()._async$_add$1(data); |
| }, |
| _sendError$2: function(error, stackTrace) { |
| this.get$_subscription()._addError$2(error, stackTrace); |
| }, |
| _sendDone$0: function() { |
| this.get$_subscription()._async$_close$0(); |
| } |
| }, |
| _SyncStreamController: { |
| "^": "_StreamController+_SyncStreamControllerDispatch;_varData,_state,_doneFuture,onListen,onPause,onResume,onCancel,$ti" |
| }, |
| _ControllerStream: { |
| "^": "_StreamImpl;_controller,$ti", |
| get$hashCode: function(_) { |
| return (H.Primitives_objectHashCode(this._controller) ^ 892482866) >>> 0; |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (this === other) |
| return true; |
| if (!(other instanceof P._ControllerStream)) |
| return false; |
| return other._controller === this._controller; |
| } |
| }, |
| _ControllerSubscription: { |
| "^": "_BufferingStreamSubscription;_controller,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending,$ti", |
| _onCancel$0: function() { |
| return this._controller._recordCancel$1(this); |
| }, |
| _onPause$0: [function() { |
| var t1 = this._controller; |
| if ((t1._state & 8) !== 0) |
| t1._varData.pause$0(0); |
| P._runGuarded(t1.onPause); |
| }, "call$0", "get$_onPause", 0, 0, 2], |
| _onResume$0: [function() { |
| var t1 = this._controller; |
| if ((t1._state & 8) !== 0) |
| t1._varData.resume$0(0); |
| P._runGuarded(t1.onResume); |
| }, "call$0", "get$_onResume", 0, 0, 2] |
| }, |
| _StreamSinkWrapper: { |
| "^": "Object;_async$_target,$ti", |
| add$1: [function(_, data) { |
| var t1 = this._async$_target; |
| if (t1._state >= 4) |
| H.throwExpression(t1._badEventState$0()); |
| t1._async$_add$1(data); |
| }, "call$1", "get$add", 2, 0, function() { |
| return H.computeSignature(function(T) { |
| return {func: 1, v: true, args: [T]}; |
| }, this.$receiver, "_StreamSinkWrapper"); |
| }, 15] |
| }, |
| _BufferingStreamSubscription: { |
| "^": "Object;_zone<,_state<,$ti", |
| _BufferingStreamSubscription$4: function(onData, onError, onDone, cancelOnError, $T) { |
| var handleData, t1; |
| handleData = onData == null ? P.async___nullDataHandler$closure() : onData; |
| t1 = this._zone; |
| this._async$_onData = t1.registerUnaryCallback$1(handleData); |
| this._onError = P._registerErrorHandler(onError == null ? P.async___nullErrorHandler$closure() : onError, t1); |
| this._onDone = t1.registerCallback$1(onDone == null ? P.async___nullDoneHandler$closure() : onDone); |
| }, |
| _setPendingEvents$1: function(pendingEvents) { |
| if (pendingEvents == null) |
| return; |
| this._pending = pendingEvents; |
| if (!pendingEvents.get$isEmpty(pendingEvents)) { |
| this._state = (this._state | 64) >>> 0; |
| this._pending.schedule$1(this); |
| } |
| }, |
| 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) |
| this._cancel$0(); |
| t1 = this._cancelFuture; |
| return t1 == null ? $.$get$Future__nullFuture() : t1; |
| }, |
| get$_isInputPaused: function() { |
| return (this._state & 4) !== 0; |
| }, |
| get$isPaused: function() { |
| return this._state >= 128; |
| }, |
| _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(new P._DelayedData(data, 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)); |
| }], |
| _async$_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 !== $.$get$Future__nullFuture()) |
| 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 !== $.$get$Future__nullFuture()) |
| 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__sendError_sendError: { |
| "^": "Closure:2;$this,error,stackTrace", |
| call$0: [function() { |
| var t1, t2, t3, t4, t5, t6; |
| t1 = this.$this; |
| t2 = t1._state; |
| if ((t2 & 8) !== 0 && (t2 & 16) === 0) |
| return; |
| t1._state = (t2 | 32) >>> 0; |
| t2 = t1._onError; |
| t3 = H.functionTypeTest(t2, {func: 1, args: [P.Object, P.StackTrace]}); |
| t4 = t1._zone; |
| t5 = this.error; |
| t6 = t1._onError; |
| if (t3) |
| t4.runBinaryGuarded$3(t6, t5, this.stackTrace); |
| else |
| t4.runUnaryGuarded$2(t6, t5); |
| t1._state = (t1._state & 4294967263) >>> 0; |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _BufferingStreamSubscription__sendDone_sendDone: { |
| "^": "Closure:2;$this", |
| call$0: [function() { |
| var t1, t2; |
| t1 = this.$this; |
| 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; |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _StreamImpl: { |
| "^": "Stream;$ti", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| return this._controller._subscribe$4(onData, onError, onDone, true === cancelOnError); |
| }, |
| listen$1: function(onData) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| }, |
| listen$2$onDone: function(onData, onDone) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, null); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| } |
| }, |
| _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;$this,dispatch", |
| call$0: [function() { |
| var t1, oldState, $event, t2; |
| t1 = this.$this; |
| oldState = t1._state; |
| t1._state = 0; |
| if (oldState === 3) |
| return; |
| $event = t1.firstPendingEvent; |
| t2 = $event.get$next(); |
| t1.firstPendingEvent = t2; |
| if (t2 == null) |
| t1.lastPendingEvent = null; |
| $event.perform$1(this.dispatch); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _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; |
| } |
| } |
| }, |
| _DoneStreamSubscription: { |
| "^": "Object;_zone<,_state<,_onDone", |
| get$isPaused: function() { |
| return this._state >= 4; |
| }, |
| _schedule$0: function() { |
| if ((this._state & 2) !== 0) |
| return; |
| this._zone.scheduleMicrotask$1(this.get$_sendDone()); |
| this._state = (this._state | 2) >>> 0; |
| }, |
| pause$1: function(_, resumeSignal) { |
| this._state += 4; |
| }, |
| pause$0: function($receiver) { |
| return this.pause$1($receiver, null); |
| }, |
| resume$0: function(_) { |
| var t1 = this._state; |
| if (t1 >= 4) { |
| t1 -= 4; |
| this._state = t1; |
| if (t1 < 4 && (t1 & 1) === 0) |
| this._schedule$0(); |
| } |
| }, |
| cancel$0: function() { |
| return $.$get$Future__nullFuture(); |
| }, |
| _sendDone$0: [function() { |
| var t1 = (this._state & 4294967293) >>> 0; |
| this._state = t1; |
| if (t1 >= 4) |
| return; |
| this._state = (t1 | 1) >>> 0; |
| t1 = this._onDone; |
| if (t1 != null) |
| this._zone.runGuarded$1(t1); |
| }, "call$0", "get$_sendDone", 0, 0, 2] |
| }, |
| _StreamIterator: { |
| "^": "Object;_subscription,_stateData,_isPaused,$ti", |
| cancel$0: function() { |
| var subscription, stateData; |
| subscription = this._subscription; |
| stateData = this._stateData; |
| this._stateData = null; |
| if (subscription != null) { |
| this._subscription = null; |
| if (!this._isPaused) |
| stateData._asyncComplete$1(false); |
| return subscription.cancel$0(); |
| } |
| return $.$get$Future__nullFuture(); |
| } |
| }, |
| _EmptyStream: { |
| "^": "Stream;$ti", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| var t1 = new P._DoneStreamSubscription($.Zone__current, 0, onDone); |
| t1._schedule$0(); |
| return t1; |
| }, |
| listen$1: function(onData) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| } |
| }, |
| _cancelAndError_closure: { |
| "^": "Closure:1;future,error,stackTrace", |
| call$0: [function() { |
| return this.future._completeError$2(this.error, this.stackTrace); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _cancelAndErrorClosure_closure: { |
| "^": "Closure:7;subscription,future", |
| call$2: function(error, stackTrace) { |
| P._cancelAndError(this.subscription, this.future, error, stackTrace); |
| } |
| }, |
| _cancelAndValue_closure: { |
| "^": "Closure:1;future,value", |
| call$0: [function() { |
| return this.future._complete$1(this.value); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _ForwardingStream: { |
| "^": "Stream;$ti", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| return this._createSubscription$4(onData, onError, onDone, true === cancelOnError); |
| }, |
| listen$1: function(onData) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| }, |
| _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); |
| }, |
| _handleError$3: function(error, stackTrace, sink) { |
| sink._addError$2(error, stackTrace); |
| }, |
| $asStream: function($S, $T) { |
| return [$T]; |
| } |
| }, |
| _ForwardingStreamSubscription: { |
| "^": "_BufferingStreamSubscription;_stream,_subscription,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending,$ti", |
| _ForwardingStreamSubscription$5: function(_stream, onData, onError, onDone, cancelOnError, $S, $T) { |
| this._subscription = this._stream._async$_source.listen$3$onDone$onError(this.get$_handleData(), this.get$_handleDone(), this.get$_handleError()); |
| }, |
| _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(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, v: true, args: [S]}; |
| }, this.$receiver, "_ForwardingStreamSubscription"); |
| }, 15], |
| _handleError$2: [function(error, stackTrace) { |
| this._stream._handleError$3(error, stackTrace, this); |
| }, "call$2", "get$_handleError", 4, 0, 13, 0, 1], |
| _handleDone$0: [function() { |
| this._async$_close$0(); |
| }, "call$0", "get$_handleDone", 0, 0, 2], |
| $as_BufferingStreamSubscription: function($S, $T) { |
| return [$T]; |
| }, |
| static: { |
| _ForwardingStreamSubscription$: function(_stream, onData, onError, onDone, cancelOnError, $S, $T) { |
| var t1, t2; |
| t1 = $.Zone__current; |
| t2 = cancelOnError ? 1 : 0; |
| t2 = new P._ForwardingStreamSubscription(_stream, null, null, null, null, t1, t2, null, null, [$S, $T]); |
| t2._BufferingStreamSubscription$4(onData, onError, onDone, cancelOnError, $T); |
| t2._ForwardingStreamSubscription$5(_stream, onData, onError, onDone, cancelOnError, $S, $T); |
| return t2; |
| } |
| } |
| }, |
| _MapStream: { |
| "^": "_ForwardingStream;_transform,_async$_source,$ti", |
| _handleData$2: function(inputEvent, sink) { |
| var outputEvent, e, s, exception; |
| outputEvent = null; |
| try { |
| outputEvent = this._transform.call$1(inputEvent); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| P._addErrorWithReplacement(sink, e, s); |
| return; |
| } |
| sink._async$_add$1(outputEvent); |
| } |
| }, |
| _HandleErrorStream: { |
| "^": "_ForwardingStream;_transform,_test,_async$_source,$ti", |
| _handleError$3: function(error, stackTrace, sink) { |
| var matches, e, s, exception, t1; |
| matches = true; |
| if (matches === true) |
| try { |
| P._invokeErrorHandler(this._transform, error, stackTrace); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| t1 = e; |
| if (t1 == null ? error == null : t1 === error) |
| sink._addError$2(error, stackTrace); |
| else |
| P._addErrorWithReplacement(sink, e, s); |
| return; |
| } |
| else |
| sink._addError$2(error, stackTrace); |
| }, |
| $asStream: null, |
| $as_ForwardingStream: function($T) { |
| return [$T, $T]; |
| } |
| }, |
| _StateStreamSubscription: { |
| "^": "_ForwardingStreamSubscription;_sharedState,_stream,_subscription,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending,$ti", |
| get$_count: function() { |
| return this._sharedState; |
| }, |
| set$_count: function(count) { |
| this._sharedState = count; |
| }, |
| $as_BufferingStreamSubscription: null, |
| $as_ForwardingStreamSubscription: function($T) { |
| return [$T, $T]; |
| } |
| }, |
| _SkipStream: { |
| "^": "_ForwardingStream;_count,_async$_source,$ti", |
| _createSubscription$4: function(onData, onError, onDone, cancelOnError) { |
| var t1, t2, t3; |
| t1 = H.getTypeArgumentByIndex(this, 0); |
| t2 = $.Zone__current; |
| t3 = cancelOnError ? 1 : 0; |
| t3 = new P._StateStreamSubscription(this._count, this, null, null, null, null, t2, t3, null, null, this.$ti); |
| t3._BufferingStreamSubscription$4(onData, onError, onDone, cancelOnError, t1); |
| t3._ForwardingStreamSubscription$5(this, onData, onError, onDone, cancelOnError, t1, t1); |
| return t3; |
| }, |
| _handleData$2: function(inputEvent, sink) { |
| var count, t1; |
| count = sink.get$_count(); |
| t1 = J.getInterceptor$n(count); |
| if (t1.$gt(count, 0)) { |
| sink.set$_count(t1.$sub(count, 1)); |
| return; |
| } |
| sink._async$_add$1(inputEvent); |
| }, |
| $asStream: null, |
| $as_ForwardingStream: function($T) { |
| return [$T, $T]; |
| } |
| }, |
| Timer: { |
| "^": "Object;" |
| }, |
| AsyncError: { |
| "^": "Object;error>,stackTrace<", |
| toString$0: function(_) { |
| return H.S(this.error); |
| }, |
| $isError: 1 |
| }, |
| _ZoneFunction: { |
| "^": "Object;zone,$function" |
| }, |
| ZoneSpecification: { |
| "^": "Object;" |
| }, |
| _ZoneSpecification: { |
| "^": "Object;handleUncaughtError,run,runUnary,runBinary,registerCallback,registerUnaryCallback,registerBinaryCallback,errorCallback,scheduleMicrotask,createTimer,createPeriodicTimer,print,fork", |
| handleUncaughtError$2: function(arg0, arg1) { |
| return this.handleUncaughtError.call$2(arg0, arg1); |
| }, |
| handleUncaughtError$3: function(arg0, arg1, arg2) { |
| return this.handleUncaughtError.call$3(arg0, arg1, arg2); |
| }, |
| run$1: function(arg0) { |
| return this.run.call$1(arg0); |
| }, |
| runUnary$2: function(arg0, arg1) { |
| return this.runUnary.call$2(arg0, arg1); |
| }, |
| runBinary$3: function(arg0, arg1, arg2) { |
| return this.runBinary.call$3(arg0, arg1, arg2); |
| }, |
| registerCallback$1: function(arg0) { |
| return this.registerCallback.call$1(arg0); |
| }, |
| registerUnaryCallback$1: function(arg0) { |
| return this.registerUnaryCallback.call$1(arg0); |
| }, |
| registerBinaryCallback$1: function(arg0) { |
| return this.registerBinaryCallback.call$1(arg0); |
| }, |
| errorCallback$2: function(arg0, arg1) { |
| return this.errorCallback.call$2(arg0, arg1); |
| }, |
| scheduleMicrotask$1: function(arg0) { |
| return this.scheduleMicrotask.call$1(arg0); |
| }, |
| createTimer$2: function(arg0, arg1) { |
| return this.createTimer.call$2(arg0, arg1); |
| }, |
| createPeriodicTimer$2: function(arg0, arg1) { |
| return this.createPeriodicTimer.call$2(arg0, arg1); |
| }, |
| print$1: function($receiver, arg0) { |
| return this.print.call$1(arg0); |
| }, |
| fork$2$specification$zoneValues: function(arg0, arg1) { |
| return this.fork.call$2$specification$zoneValues(arg0, arg1); |
| } |
| }, |
| ZoneDelegate: { |
| "^": "Object;" |
| }, |
| Zone: { |
| "^": "Object;" |
| }, |
| _ZoneDelegate: { |
| "^": "Object;_delegationTarget", |
| handleUncaughtError$3: function(zone, error, stackTrace) { |
| var implementation, implZone; |
| implementation = this._delegationTarget.get$_handleUncaughtError(); |
| implZone = implementation.zone; |
| return implementation.$function.call$5(implZone, P._parentDelegate(implZone), zone, error, stackTrace); |
| } |
| }, |
| _Zone: { |
| "^": "Object;", |
| inSameErrorZone$1: function(otherZone) { |
| return this === otherZone || this.get$errorZone() === otherZone.get$errorZone(); |
| } |
| }, |
| _CustomZone: { |
| "^": "_Zone;_run<,_runUnary<,_runBinary<,_registerCallback<,_registerUnaryCallback<,_registerBinaryCallback<,_errorCallback<,_scheduleMicrotask<,_createTimer<,_createPeriodicTimer<,_print<,_fork<,_handleUncaughtError<,_delegateCache,parent>,_async$_map<", |
| get$_delegate: function() { |
| var t1 = this._delegateCache; |
| if (t1 != null) |
| return t1; |
| t1 = new P._ZoneDelegate(this); |
| this._delegateCache = t1; |
| return t1; |
| }, |
| get$errorZone: function() { |
| return this._handleUncaughtError.zone; |
| }, |
| runGuarded$1: function(f) { |
| var e, s, exception; |
| try { |
| this.run$1(f); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| this.handleUncaughtError$2(e, s); |
| } |
| }, |
| runUnaryGuarded$2: function(f, arg) { |
| var e, s, exception; |
| try { |
| this.runUnary$2(f, arg); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| this.handleUncaughtError$2(e, s); |
| } |
| }, |
| runBinaryGuarded$3: function(f, arg1, arg2) { |
| var e, s, exception; |
| try { |
| this.runBinary$3(f, arg1, arg2); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| this.handleUncaughtError$2(e, s); |
| } |
| }, |
| bindCallback$1: function(f) { |
| return new P._CustomZone_bindCallback_closure(this, this.registerCallback$1(f)); |
| }, |
| bindUnaryCallback$1: function(f) { |
| return new P._CustomZone_bindUnaryCallback_closure(this, this.registerUnaryCallback$1(f)); |
| }, |
| bindCallbackGuarded$1: function(f) { |
| return new P._CustomZone_bindCallbackGuarded_closure(this, this.registerCallback$1(f)); |
| }, |
| bindUnaryCallbackGuarded$1: function(f) { |
| return new P._CustomZone_bindUnaryCallbackGuarded_closure(this, this.registerUnaryCallback$1(f)); |
| }, |
| $index: function(_, key) { |
| var t1, result, t2, value; |
| t1 = this._async$_map; |
| result = t1.$index(0, key); |
| if (result != null || t1.containsKey$1(key)) |
| return result; |
| t2 = this.parent; |
| if (t2 != null) { |
| value = J.$index$asx(t2, key); |
| if (value != null) |
| t1.$indexSet(0, key, value); |
| return value; |
| } |
| return; |
| }, |
| handleUncaughtError$2: function(error, stackTrace) { |
| var implementation, t1, parentDelegate; |
| implementation = this._handleUncaughtError; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$5(t1, parentDelegate, this, error, stackTrace); |
| }, |
| fork$2$specification$zoneValues: function(specification, zoneValues) { |
| var implementation, t1, parentDelegate; |
| implementation = this._fork; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$5(t1, parentDelegate, this, specification, zoneValues); |
| }, |
| run$1: function(f) { |
| var implementation, t1, parentDelegate; |
| implementation = this._run; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, f); |
| }, |
| runUnary$2: function(f, arg) { |
| var implementation, t1, parentDelegate; |
| implementation = this._runUnary; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$5(t1, parentDelegate, this, f, arg); |
| }, |
| runBinary$3: function(f, arg1, arg2) { |
| var implementation, t1, parentDelegate; |
| implementation = this._runBinary; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$6(t1, parentDelegate, this, f, arg1, arg2); |
| }, |
| registerCallback$1: function(callback) { |
| var implementation, t1, parentDelegate; |
| implementation = this._registerCallback; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, callback); |
| }, |
| registerUnaryCallback$1: function(callback) { |
| var implementation, t1, parentDelegate; |
| implementation = this._registerUnaryCallback; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, callback); |
| }, |
| registerBinaryCallback$1: function(callback) { |
| var implementation, t1, parentDelegate; |
| implementation = this._registerBinaryCallback; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, callback); |
| }, |
| errorCallback$2: function(error, stackTrace) { |
| var implementation, implementationZone, parentDelegate; |
| implementation = this._errorCallback; |
| implementationZone = implementation.zone; |
| if (implementationZone === C.C__RootZone) |
| return; |
| parentDelegate = P._parentDelegate(implementationZone); |
| return implementation.$function.call$5(implementationZone, parentDelegate, this, error, stackTrace); |
| }, |
| scheduleMicrotask$1: function(f) { |
| var implementation, t1, parentDelegate; |
| implementation = this._scheduleMicrotask; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, f); |
| }, |
| createTimer$2: function(duration, f) { |
| var implementation, t1, parentDelegate; |
| implementation = this._createTimer; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$5(t1, parentDelegate, this, duration, f); |
| }, |
| createPeriodicTimer$2: function(duration, f) { |
| var implementation, t1, parentDelegate; |
| implementation = this._createPeriodicTimer; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$5(t1, parentDelegate, this, duration, f); |
| }, |
| print$1: function(_, line) { |
| var implementation, t1, parentDelegate; |
| implementation = this._print; |
| t1 = implementation.zone; |
| parentDelegate = P._parentDelegate(t1); |
| return implementation.$function.call$4(t1, parentDelegate, this, line); |
| } |
| }, |
| _CustomZone_bindCallback_closure: { |
| "^": "Closure:1;$this,registered", |
| call$0: function() { |
| return this.$this.run$1(this.registered); |
| } |
| }, |
| _CustomZone_bindUnaryCallback_closure: { |
| "^": "Closure:0;$this,registered", |
| call$1: function(arg) { |
| return this.$this.runUnary$2(this.registered, arg); |
| } |
| }, |
| _CustomZone_bindCallbackGuarded_closure: { |
| "^": "Closure:1;$this,registered", |
| call$0: [function() { |
| return this.$this.runGuarded$1(this.registered); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _CustomZone_bindUnaryCallbackGuarded_closure: { |
| "^": "Closure:0;$this,registered", |
| call$1: [function(arg) { |
| return this.$this.runUnaryGuarded$2(this.registered, arg); |
| }, null, null, 2, 0, null, 12, "call"] |
| }, |
| _rootHandleUncaughtError_closure: { |
| "^": "Closure:1;_box_0,stackTrace", |
| call$0: function() { |
| var t1, t2, error; |
| t1 = this._box_0; |
| t2 = t1.error; |
| if (t2 == null) { |
| error = new P.NullThrownError(); |
| t1.error = error; |
| t1 = error; |
| } else |
| t1 = t2; |
| t2 = this.stackTrace; |
| if (t2 == null) |
| throw H.wrapException(t1); |
| error = H.wrapException(t1); |
| error.stack = J.toString$0$(t2); |
| throw error; |
| } |
| }, |
| _RootZone: { |
| "^": "_Zone;", |
| get$_run: function() { |
| return C._ZoneFunction__RootZone__rootRun; |
| }, |
| get$_runUnary: function() { |
| return C._ZoneFunction__RootZone__rootRunUnary; |
| }, |
| get$_runBinary: function() { |
| return C._ZoneFunction__RootZone__rootRunBinary; |
| }, |
| get$_registerCallback: function() { |
| return C._ZoneFunction__RootZone__rootRegisterCallback; |
| }, |
| get$_registerUnaryCallback: function() { |
| return C._ZoneFunction_Eeh; |
| }, |
| get$_registerBinaryCallback: function() { |
| return C._ZoneFunction_7G2; |
| }, |
| get$_errorCallback: function() { |
| return C._ZoneFunction__RootZone__rootErrorCallback; |
| }, |
| get$_scheduleMicrotask: function() { |
| return C._ZoneFunction__RootZone__rootScheduleMicrotask; |
| }, |
| get$_createTimer: function() { |
| return C._ZoneFunction__RootZone__rootCreateTimer; |
| }, |
| get$_createPeriodicTimer: function() { |
| return C._ZoneFunction_3bB; |
| }, |
| get$_print: function() { |
| return C._ZoneFunction__RootZone__rootPrint; |
| }, |
| get$_fork: function() { |
| return C._ZoneFunction__RootZone__rootFork; |
| }, |
| get$_handleUncaughtError: function() { |
| return C._ZoneFunction_NMc; |
| }, |
| get$parent: function(_) { |
| return; |
| }, |
| get$_async$_map: function() { |
| return $.$get$_RootZone__rootMap(); |
| }, |
| get$_delegate: function() { |
| var t1 = $._RootZone__rootDelegate; |
| if (t1 != null) |
| return t1; |
| t1 = new P._ZoneDelegate(this); |
| $._RootZone__rootDelegate = t1; |
| return t1; |
| }, |
| get$errorZone: function() { |
| return this; |
| }, |
| runGuarded$1: function(f) { |
| var e, s, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| f.call$0(); |
| return; |
| } |
| P._rootRun(null, null, this, f); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| P._rootHandleUncaughtError(null, null, this, e, s); |
| } |
| }, |
| runUnaryGuarded$2: function(f, arg) { |
| var e, s, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| f.call$1(arg); |
| return; |
| } |
| P._rootRunUnary(null, null, this, f, arg); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| P._rootHandleUncaughtError(null, null, this, e, s); |
| } |
| }, |
| runBinaryGuarded$3: function(f, arg1, arg2) { |
| var e, s, exception; |
| try { |
| if (C.C__RootZone === $.Zone__current) { |
| f.call$2(arg1, arg2); |
| return; |
| } |
| P._rootRunBinary(null, null, this, f, arg1, arg2); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| P._rootHandleUncaughtError(null, null, this, e, s); |
| } |
| }, |
| bindCallback$1: function(f) { |
| return new P._RootZone_bindCallback_closure(this, f); |
| }, |
| bindUnaryCallback$1: function(f) { |
| return new P._RootZone_bindUnaryCallback_closure(this, f); |
| }, |
| bindCallbackGuarded$1: function(f) { |
| return new P._RootZone_bindCallbackGuarded_closure(this, f); |
| }, |
| bindUnaryCallbackGuarded$1: function(f) { |
| return new P._RootZone_bindUnaryCallbackGuarded_closure(this, f); |
| }, |
| $index: function(_, key) { |
| return; |
| }, |
| handleUncaughtError$2: function(error, stackTrace) { |
| P._rootHandleUncaughtError(null, null, this, error, stackTrace); |
| }, |
| fork$2$specification$zoneValues: function(specification, zoneValues) { |
| return P._rootFork(null, null, this, specification, zoneValues); |
| }, |
| 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); |
| }, |
| registerCallback$1: function(f) { |
| return f; |
| }, |
| registerUnaryCallback$1: function(f) { |
| return f; |
| }, |
| registerBinaryCallback$1: function(f) { |
| return f; |
| }, |
| errorCallback$2: function(error, stackTrace) { |
| return; |
| }, |
| scheduleMicrotask$1: function(f) { |
| P._rootScheduleMicrotask(null, null, this, f); |
| }, |
| createTimer$2: function(duration, f) { |
| return P.Timer__createTimer(duration, f); |
| }, |
| createPeriodicTimer$2: function(duration, f) { |
| return P.Timer__createPeriodicTimer(duration, f); |
| }, |
| print$1: function(_, line) { |
| H.printString(line); |
| } |
| }, |
| _RootZone_bindCallback_closure: { |
| "^": "Closure:1;$this,f", |
| call$0: function() { |
| return this.$this.run$1(this.f); |
| } |
| }, |
| _RootZone_bindUnaryCallback_closure: { |
| "^": "Closure:0;$this,f", |
| call$1: function(arg) { |
| return this.$this.runUnary$2(this.f, arg); |
| } |
| }, |
| _RootZone_bindCallbackGuarded_closure: { |
| "^": "Closure:1;$this,f", |
| call$0: [function() { |
| return this.$this.runGuarded$1(this.f); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _RootZone_bindUnaryCallbackGuarded_closure: { |
| "^": "Closure:0;$this,f", |
| call$1: [function(arg) { |
| return this.$this.runUnaryGuarded$2(this.f, arg); |
| }, null, null, 2, 0, null, 12, "call"] |
| }, |
| runZoned_closure: { |
| "^": "Closure:14;onError", |
| call$5: [function($self, $parent, zone, error, stackTrace) { |
| var e, s, t1, exception; |
| try { |
| t1 = this.onError; |
| if (H.functionTypeTest(t1, {func: 1, v: true, args: [P.Object, P.StackTrace]})) { |
| J.get$parent$x($self).runBinary$3(t1, error, stackTrace); |
| return; |
| } |
| J.get$parent$x($self).runUnary$2(t1, error); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| s = H.getTraceFromException(exception); |
| t1 = e; |
| if (t1 == null ? error == null : t1 === error) |
| $parent.handleUncaughtError$3(zone, error, stackTrace); |
| else |
| $parent.handleUncaughtError$3(zone, e, s); |
| } |
| }, null, null, 10, 0, null, 9, 10, 11, 0, 1, "call"] |
| } |
| }], ["dart.collection", "dart:collection",, P, { |
| "^": "", |
| LinkedHashMap_LinkedHashMap$_empty: function($K, $V) { |
| return new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [$K, $V]); |
| }, |
| LinkedHashMap__makeEmpty: function() { |
| return new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [null, null]); |
| }, |
| LinkedHashMap__makeLiteral: function(keyValuePairs) { |
| return H.fillLiteralMap(keyValuePairs, new H.JsLinkedHashMap(0, null, null, null, null, null, 0, [null, null])); |
| }, |
| HashMap_HashMap: function(equals, hashCode, isValidKey, $K, $V) { |
| return new P._HashMap(0, null, null, null, null, [$K, $V]); |
| }, |
| HashMap_HashMap$from: function(other, $K, $V) { |
| var result = P.HashMap_HashMap(null, null, null, $K, $V); |
| J.forEach$1$ax(other, new P.closure7(result)); |
| return result; |
| }, |
| 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.set$_contents(P.StringBuffer__writeAll(t2.get$_contents(), iterable, ", ")); |
| } finally { |
| if (0 >= t1.length) |
| return H.ioore(t1, -1); |
| t1.pop(); |
| } |
| t1 = buffer; |
| t1.set$_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) { |
| t1 = t1[i]; |
| if (o == null ? t1 == null : o === t1) |
| 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); |
| }, |
| LinkedHashSet_LinkedHashSet: function(equals, hashCode, isValidKey, $E) { |
| return new P._LinkedHashSet(0, null, null, null, null, null, 0, [$E]); |
| }, |
| Maps_mapToString: function(m) { |
| var t1, result, t2; |
| t1 = {}; |
| if (P._isToStringVisiting(m)) |
| return "{...}"; |
| result = new P.StringBuffer(""); |
| try { |
| $.$get$_toStringVisiting().push(m); |
| t2 = result; |
| t2.set$_contents(t2.get$_contents() + "{"); |
| t1.first = true; |
| m.forEach$1(0, new P.Maps_mapToString_closure(t1, result)); |
| t1 = result; |
| t1.set$_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; |
| }, |
| _HashMap: { |
| "^": "Object;_collection$_length,_collection$_strings,_collection$_nums,_collection$_rest,_collection$_keys,$ti", |
| get$length: function(_) { |
| return this._collection$_length; |
| }, |
| get$isEmpty: function(_) { |
| return this._collection$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._collection$_length !== 0; |
| }, |
| containsKey$1: function(key) { |
| var strings, nums; |
| if (typeof key === "string" && key !== "__proto__") { |
| strings = this._collection$_strings; |
| return strings == null ? false : strings[key] != null; |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { |
| nums = this._collection$_nums; |
| return nums == null ? false : nums[key] != null; |
| } else |
| return this._containsKey$1(key); |
| }, |
| _containsKey$1: function(key) { |
| var rest = this._collection$_rest; |
| if (rest == null) |
| return false; |
| return this._findBucketIndex$2(rest[this._computeHashCode$1(key)], key) >= 0; |
| }, |
| $index: function(_, key) { |
| var strings, t1, entry, nums; |
| if (typeof key === "string" && key !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) |
| t1 = null; |
| else { |
| entry = strings[key]; |
| t1 = entry === strings ? null : entry; |
| } |
| return t1; |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { |
| nums = this._collection$_nums; |
| if (nums == null) |
| t1 = null; |
| else { |
| entry = nums[key]; |
| t1 = entry === nums ? null : entry; |
| } |
| return t1; |
| } else |
| return this._get$1(key); |
| }, |
| _get$1: function(key) { |
| var rest, bucket, index; |
| rest = this._collection$_rest; |
| if (rest == null) |
| return; |
| bucket = rest[this._computeHashCode$1(key)]; |
| index = this._findBucketIndex$2(bucket, key); |
| return index < 0 ? null : bucket[index + 1]; |
| }, |
| $indexSet: function(_, key, value) { |
| var strings, nums; |
| if (typeof key === "string" && key !== "__proto__") { |
| strings = this._collection$_strings; |
| if (strings == null) { |
| strings = P._HashMap__newHashTable(); |
| this._collection$_strings = strings; |
| } |
| this._collection$_addHashTableEntry$3(strings, key, value); |
| } else if (typeof key === "number" && (key & 0x3ffffff) === key) { |
| nums = this._collection$_nums; |
| if (nums == null) { |
| nums = P._HashMap__newHashTable(); |
| this._collection$_nums = nums; |
| } |
| this._collection$_addHashTableEntry$3(nums, key, value); |
| } else |
| this._set$2(key, value); |
| }, |
| _set$2: function(key, value) { |
| var rest, hash, bucket, index; |
| rest = this._collection$_rest; |
| if (rest == null) { |
| rest = P._HashMap__newHashTable(); |
| this._collection$_rest = rest; |
| } |
| hash = this._computeHashCode$1(key); |
| bucket = rest[hash]; |
| if (bucket == null) { |
| P._HashMap__setTableEntry(rest, hash, [key, value]); |
| ++this._collection$_length; |
| this._collection$_keys = null; |
| } else { |
| index = this._findBucketIndex$2(bucket, key); |
| if (index >= 0) |
| bucket[index + 1] = value; |
| else { |
| bucket.push(key, value); |
| ++this._collection$_length; |
| this._collection$_keys = null; |
| } |
| } |
| }, |
| forEach$1: function(_, action) { |
| var keys, $length, i, key; |
| keys = this._collection$_computeKeys$0(); |
| for ($length = keys.length, i = 0; i < $length; ++i) { |
| key = keys[i]; |
| action.call$2(key, this.$index(0, key)); |
| if (keys !== this._collection$_keys) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| _collection$_computeKeys$0: function() { |
| var t1, result, strings, names, entries, index, i, nums, rest, bucket, $length, i0; |
| t1 = this._collection$_keys; |
| 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 += 2) { |
| result[index] = bucket[i0]; |
| ++index; |
| } |
| } |
| } |
| this._collection$_keys = result; |
| return result; |
| }, |
| _collection$_addHashTableEntry$3: function(table, key, value) { |
| if (table[key] == null) { |
| ++this._collection$_length; |
| this._collection$_keys = null; |
| } |
| P._HashMap__setTableEntry(table, key, value); |
| }, |
| _computeHashCode$1: function(key) { |
| return J.get$hashCode$(key) & 0x3ffffff; |
| }, |
| _findBucketIndex$2: function(bucket, key) { |
| var $length, i; |
| if (bucket == null) |
| return -1; |
| $length = bucket.length; |
| for (i = 0; i < $length; i += 2) |
| if (J.$eq$(bucket[i], key)) |
| return i; |
| return -1; |
| }, |
| $isMap: 1, |
| static: { |
| _HashMap__setTableEntry: function(table, key, value) { |
| if (value == null) |
| table[key] = table; |
| else |
| table[key] = value; |
| }, |
| _HashMap__newHashTable: function() { |
| var table = Object.create(null); |
| P._HashMap__setTableEntry(table, "<non-identifier-key>", table); |
| delete table["<non-identifier-key>"]; |
| return table; |
| } |
| } |
| }, |
| _LinkedIdentityHashMap: { |
| "^": "JsLinkedHashMap;_length,_strings,_nums,_rest,_first,_last,_modifications,$ti", |
| 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 new P._LinkedIdentityHashMap(0, null, null, null, null, null, 0, [$K, $V]); |
| } |
| } |
| }, |
| _LinkedHashSet: { |
| "^": "_HashSetBase;_collection$_length,_collection$_strings,_collection$_nums,_collection$_rest,_collection$_first,_collection$_last,_collection$_modifications,$ti", |
| get$iterator: function(_) { |
| var t1 = new P._LinkedHashSetIterator(this, this._collection$_modifications, null, null); |
| t1._collection$_cell = this._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$_element(); |
| }, |
| forEach$1: function(_, action) { |
| var cell, modifications; |
| cell = this._collection$_first; |
| modifications = this._collection$_modifications; |
| for (; cell != null;) { |
| action.call$1(cell.get$_element()); |
| if (modifications !== this._collection$_modifications) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| cell = cell.get$_collection$_next(); |
| } |
| }, |
| 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._collection$_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._collection$_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._collection$_newLinkedCell$1(element)]; |
| else { |
| if (this._findBucketIndex$2(bucket, element) >= 0) |
| return false; |
| bucket.push(this._collection$_newLinkedCell$1(element)); |
| } |
| return true; |
| }, |
| remove$1: function(_, object) { |
| if (typeof object === "string" && object !== "__proto__") |
| return this._collection$_removeHashTableEntry$2(this._collection$_strings, object); |
| else if (typeof object === "number" && (object & 0x3ffffff) === object) |
| return this._collection$_removeHashTableEntry$2(this._collection$_nums, object); |
| else |
| return this._remove$1(object); |
| }, |
| _remove$1: function(object) { |
| var rest, bucket, index; |
| rest = this._collection$_rest; |
| if (rest == null) |
| return false; |
| bucket = rest[this._computeHashCode$1(object)]; |
| index = this._findBucketIndex$2(bucket, object); |
| if (index < 0) |
| return false; |
| this._collection$_unlinkCell$1(bucket.splice(index, 1)[0]); |
| return true; |
| }, |
| clear$0: function(_) { |
| if (this._collection$_length > 0) { |
| this._collection$_last = null; |
| this._collection$_first = null; |
| this._collection$_rest = null; |
| this._collection$_nums = null; |
| this._collection$_strings = null; |
| this._collection$_length = 0; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| } |
| }, |
| _collection$_addHashTableEntry$2: function(table, element) { |
| if (table[element] != null) |
| return false; |
| table[element] = this._collection$_newLinkedCell$1(element); |
| return true; |
| }, |
| _collection$_removeHashTableEntry$2: function(table, element) { |
| var cell; |
| if (table == null) |
| return false; |
| cell = table[element]; |
| if (cell == null) |
| return false; |
| this._collection$_unlinkCell$1(cell); |
| delete table[element]; |
| return true; |
| }, |
| _collection$_newLinkedCell$1: function(element) { |
| var cell, last; |
| cell = new P._LinkedHashSetCell(element, null, null); |
| if (this._collection$_first == null) { |
| this._collection$_last = cell; |
| this._collection$_first = cell; |
| } else { |
| last = this._collection$_last; |
| cell._collection$_previous = last; |
| last._collection$_next = cell; |
| this._collection$_last = cell; |
| } |
| ++this._collection$_length; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| return cell; |
| }, |
| _collection$_unlinkCell$1: function(cell) { |
| var previous, next; |
| previous = cell.get$_collection$_previous(); |
| next = cell.get$_collection$_next(); |
| if (previous == null) |
| this._collection$_first = next; |
| else |
| previous._collection$_next = next; |
| if (next == null) |
| this._collection$_last = previous; |
| else |
| next.set$_collection$_previous(previous); |
| --this._collection$_length; |
| this._collection$_modifications = this._collection$_modifications + 1 & 67108863; |
| }, |
| _computeHashCode$1: function(element) { |
| return J.get$hashCode$(element) & 0x3ffffff; |
| }, |
| _findBucketIndex$2: function(bucket, element) { |
| var $length, i; |
| if (bucket == null) |
| return -1; |
| $length = bucket.length; |
| for (i = 0; i < $length; ++i) |
| if (J.$eq$(bucket[i].get$_element(), element)) |
| return i; |
| return -1; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| static: { |
| _LinkedHashSet__newHashTable: function() { |
| var table = Object.create(null); |
| table["<non-identifier-key>"] = table; |
| delete table["<non-identifier-key>"]; |
| return table; |
| } |
| } |
| }, |
| _LinkedHashSetCell: { |
| "^": "Object;_element<,_collection$_next<,_collection$_previous@" |
| }, |
| _LinkedHashSetIterator: { |
| "^": "Object;_set,_collection$_modifications,_collection$_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._collection$_cell; |
| if (t1 == null) { |
| this._collection$_current = null; |
| return false; |
| } else { |
| this._collection$_current = t1.get$_element(); |
| this._collection$_cell = this._collection$_cell.get$_collection$_next(); |
| return true; |
| } |
| } |
| } |
| }, |
| closure7: { |
| "^": "Closure:3;result", |
| call$2: function(k, v) { |
| this.result.$indexSet(0, k, v); |
| } |
| }, |
| _HashSetBase: { |
| "^": "SetBase;" |
| }, |
| IterableBase: { |
| "^": "Iterable;" |
| }, |
| ListBase: { |
| "^": "Object_ListMixin;" |
| }, |
| ListMixin: { |
| "^": "Object;$ti", |
| get$iterator: function(receiver) { |
| return new H.ListIterator(receiver, this.get$length(receiver), 0, null); |
| }, |
| elementAt$1: function(receiver, index) { |
| return this.$index(receiver, index); |
| }, |
| forEach$1: function(receiver, action) { |
| var $length, i; |
| $length = this.get$length(receiver); |
| for (i = 0; i < $length; ++i) { |
| action.call$1(this.$index(receiver, i)); |
| if ($length !== this.get$length(receiver)) |
| throw H.wrapException(new P.ConcurrentModificationError(receiver)); |
| } |
| }, |
| get$isEmpty: function(receiver) { |
| return this.get$length(receiver) === 0; |
| }, |
| get$isNotEmpty: function(receiver) { |
| return !this.get$isEmpty(receiver); |
| }, |
| contains$1: function(receiver, element) { |
| var $length, i; |
| $length = this.get$length(receiver); |
| for (i = 0; i < $length; ++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; |
| }, |
| map$1: function(receiver, f) { |
| return new H.MappedListIterable(receiver, f, [H.getRuntimeTypeArgument(receiver, "ListMixin", 0), null]); |
| }, |
| skip$1: function(receiver, count) { |
| return H.SubListIterable$(receiver, count, null, H.getRuntimeTypeArgument(receiver, "ListMixin", 0)); |
| }, |
| _closeGap$2: function(receiver, start, end) { |
| var $length, size, i, t1; |
| $length = this.get$length(receiver); |
| size = J.$sub$n(end, start); |
| for (i = end; t1 = J.getInterceptor$n(i), t1.$lt(i, $length); i = t1.$add(i, 1)) |
| this.$indexSet(receiver, t1.$sub(i, size), this.$index(receiver, i)); |
| this.set$length(receiver, $length - size); |
| }, |
| fillRange$3: function(receiver, start, end, fill) { |
| var i; |
| P.RangeError_checkValidRange(start, end, this.get$length(receiver), null, null, null); |
| for (i = start; i < end; ++i) |
| this.$indexSet(receiver, i, fill); |
| }, |
| setRange$4: ["super$ListMixin$setRange", function(receiver, start, end, iterable, skipCount) { |
| var $length, otherStart, otherList, t1, t2, i; |
| P.RangeError_checkValidRange(start, end, this.get$length(receiver), null, null, null); |
| if (typeof start !== "number") |
| return H.iae(start); |
| $length = end - start; |
| if ($length === 0) |
| return; |
| if (J.$lt$n(skipCount, 0)) |
| H.throwExpression(P.RangeError$range(skipCount, 0, null, "skipCount", null)); |
| if (H.checkSubtype(iterable, "$isList", [H.getRuntimeTypeArgument(receiver, "ListMixin", 0)], "$asList")) { |
| otherStart = skipCount; |
| otherList = iterable; |
| } else { |
| otherList = J.skip$1$ax(iterable, skipCount).toList$1$growable(0, false); |
| otherStart = 0; |
| } |
| t1 = J.getInterceptor$ns(otherStart); |
| t2 = J.getInterceptor$asx(otherList); |
| if (t1.$add(otherStart, $length) > t2.get$length(otherList)) |
| throw H.wrapException(H.IterableElementError_tooFew()); |
| if (t1.$lt(otherStart, start)) |
| for (i = $length - 1; i >= 0; --i) |
| this.$indexSet(receiver, start + i, t2.$index(otherList, t1.$add(otherStart, i))); |
| else |
| for (i = 0; i < $length; ++i) |
| this.$indexSet(receiver, start + i, t2.$index(otherList, t1.$add(otherStart, i))); |
| }, function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, "setRange$3", null, null, "get$setRange", 6, 2, null], |
| replaceRange$3: function(receiver, start, end, newContents) { |
| var removeLength, insertLength, t1, insertEnd, newLength; |
| P.RangeError_checkValidRange(start, end, this.get$length(receiver), null, null, null); |
| newContents = C.JSString_methods.toList$0(newContents); |
| removeLength = J.$sub$n(end, start); |
| insertLength = newContents.length; |
| t1 = J.getInterceptor$ns(start); |
| if (removeLength >= insertLength) { |
| insertEnd = t1.$add(start, insertLength); |
| this.setRange$3(receiver, start, insertEnd, newContents); |
| if (removeLength > insertLength) |
| this._closeGap$2(receiver, insertEnd, end); |
| } else { |
| newLength = this.get$length(receiver) + (insertLength - removeLength); |
| insertEnd = t1.$add(start, insertLength); |
| this.set$length(receiver, newLength); |
| this.setRange$4(receiver, insertEnd, newLength, receiver, end); |
| this.setRange$3(receiver, start, insertEnd, newContents); |
| } |
| }, |
| 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 == null) |
| startIndex = this.get$length(receiver) - 1; |
| else { |
| 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; |
| }, |
| lastIndexOf$1: function($receiver, element) { |
| return this.lastIndexOf$2($receiver, element, null); |
| }, |
| toString$0: function(receiver) { |
| return P.IterableBase_iterableToFullString(receiver, "[", "]"); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null |
| }, |
| _UnmodifiableMapMixin: { |
| "^": "Object;", |
| $indexSet: function(_, key, value) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify unmodifiable map")); |
| }, |
| $isMap: 1 |
| }, |
| MapView: { |
| "^": "Object;", |
| $index: function(_, key) { |
| return J.$index$asx(this._collection$_map, key); |
| }, |
| $indexSet: function(_, key, value) { |
| J.$indexSet$ax(this._collection$_map, key, value); |
| }, |
| forEach$1: function(_, action) { |
| J.forEach$1$ax(this._collection$_map, action); |
| }, |
| get$isEmpty: function(_) { |
| return J.get$isEmpty$asx(this._collection$_map); |
| }, |
| get$isNotEmpty: function(_) { |
| return J.get$isNotEmpty$asx(this._collection$_map); |
| }, |
| get$length: function(_) { |
| return J.get$length$asx(this._collection$_map); |
| }, |
| toString$0: function(_) { |
| return J.toString$0$(this._collection$_map); |
| }, |
| $isMap: 1 |
| }, |
| UnmodifiableMapView: { |
| "^": "MapView+_UnmodifiableMapMixin;_collection$_map,$ti", |
| $isMap: 1, |
| $asMap: null |
| }, |
| Maps_mapToString_closure: { |
| "^": "Closure:3;_box_0,result", |
| call$2: function(k, v) { |
| var t1, t2; |
| t1 = this._box_0; |
| if (!t1.first) |
| this.result._contents += ", "; |
| t1.first = false; |
| t1 = this.result; |
| t2 = t1._contents += H.S(k); |
| t1._contents = t2 + ": "; |
| t1._contents += H.S(v); |
| } |
| }, |
| ListQueue: { |
| "^": "ListIterable;_table,_head,_tail,_modificationCount,$ti", |
| ListQueue$1: function(initialCapacity, $E) { |
| var t1 = new Array(8); |
| t1.fixed$length = Array; |
| this._table = H.setRuntimeTypeInfo(t1, [$E]); |
| }, |
| get$iterator: function(_) { |
| return new P._ListQueueIterator(this, this._tail, this._modificationCount, this._head, null); |
| }, |
| forEach$1: function(_, f) { |
| 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); |
| f.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; |
| }, |
| elementAt$1: function(_, index) { |
| var $length, t1, t2, t3; |
| $length = (this._tail - this._head & this._table.length - 1) >>> 0; |
| if (typeof index !== "number") |
| return H.iae(index); |
| if (0 > index || index >= $length) |
| H.throwExpression(P.IndexError$(index, this, "index", null, $length)); |
| t1 = this._table; |
| t2 = t1.length; |
| t3 = (this._head + index & t2 - 1) >>> 0; |
| if (t3 < 0 || t3 >= t2) |
| return H.ioore(t1, t3); |
| return t1[t3]; |
| }, |
| 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, this.$ti); |
| 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; |
| }, |
| $asEfficientLengthIterable: null, |
| static: { |
| ListQueue$: function(initialCapacity, $E) { |
| var t1 = 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;$ti", |
| get$isEmpty: function(_) { |
| return this._collection$_length === 0; |
| }, |
| get$isNotEmpty: function(_) { |
| return this._collection$_length !== 0; |
| }, |
| map$1: function(_, f) { |
| return 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 = new P._LinkedHashSetIterator(this, this._collection$_modifications, null, null), t1._collection$_cell = this._collection$_first; t1.moveNext$0();) |
| f.call$1(t1._collection$_current); |
| }, |
| skip$1: function(_, n) { |
| return H.SkipIterable_SkipIterable(this, n, H.getTypeArgumentByIndex(this, 0)); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null |
| }, |
| SetBase: { |
| "^": "SetMixin;" |
| }, |
| Object_ListMixin: { |
| "^": "Object+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null |
| } |
| }], ["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, exception, t1; |
| if (typeof source !== "string") |
| throw H.wrapException(H.argumentErrorValue(source)); |
| parsed = null; |
| try { |
| parsed = JSON.parse(source); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| t1 = String(e); |
| throw H.wrapException(new P.FormatException(t1, null, null)); |
| } |
| t1 = P._convertJsonToDartLazy(parsed); |
| return t1; |
| }, |
| _defaultToEncodable: [function(object) { |
| return object.toJson$0(); |
| }, "call$1", "convert___defaultToEncodable$closure", 2, 0, 0, 18], |
| _JsonMap: { |
| "^": "Object;_original,_processed,_convert$_data", |
| $index: function(_, key) { |
| var t1, result; |
| t1 = this._processed; |
| if (t1 == null) |
| return this._convert$_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._convert$_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._convert$_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._convert$_data; |
| t1 = t1.get$length(t1); |
| } else |
| t1 = this._computeKeys$0().length; |
| return t1 > 0; |
| }, |
| $indexSet: function(_, key, value) { |
| var processed, original; |
| if (this._processed == null) |
| this._convert$_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._convert$_data.containsKey$1(key); |
| if (typeof key !== "string") |
| return false; |
| return Object.prototype.hasOwnProperty.call(this._original, key); |
| }, |
| forEach$1: function(_, f) { |
| var keys, i, key, value; |
| if (this._processed == null) |
| return this._convert$_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._convert$_data) |
| throw H.wrapException(new P.ConcurrentModificationError(this)); |
| } |
| }, |
| toString$0: function(_) { |
| return P.Maps_mapToString(this); |
| }, |
| _computeKeys$0: function() { |
| var keys = this._convert$_data; |
| if (keys == null) { |
| keys = Object.keys(this._original); |
| this._convert$_data = keys; |
| } |
| return keys; |
| }, |
| _upgrade$0: function() { |
| var result, keys, i, t1, key; |
| if (this._processed == null) |
| return this._convert$_data; |
| result = P.LinkedHashMap_LinkedHashMap$_empty(P.String, null); |
| 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._convert$_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; |
| }, |
| $isMap: 1, |
| $asMap: function() { |
| return [P.String, null]; |
| } |
| }, |
| AsciiCodec: { |
| "^": "Encoding;_allowInvalid", |
| get$encoder: function() { |
| return C.AsciiEncoder_127; |
| } |
| }, |
| _UnicodeSubsetEncoder: { |
| "^": "Converter;", |
| convert$3: function(string, start, end) { |
| var t1, stringLength, $length, t2, result, t3, i, codeUnit; |
| t1 = J.getInterceptor$asx(string); |
| stringLength = t1.get$length(string); |
| P.RangeError_checkValidRange(start, end, stringLength, null, null, null); |
| $length = J.$sub$n(stringLength, start); |
| t2 = H._checkLength($length); |
| result = new Uint8Array(t2); |
| for (t3 = ~this._subsetMask, i = 0; i < $length; ++i) { |
| codeUnit = t1.codeUnitAt$1(string, start + i); |
| if ((codeUnit & t3) !== 0) |
| throw H.wrapException(P.ArgumentError$("String contains invalid characters.")); |
| if (i >= t2) |
| return H.ioore(result, i); |
| result[i] = codeUnit; |
| } |
| return result; |
| }, |
| convert$1: function(string) { |
| return this.convert$3(string, 0, null); |
| }, |
| $asConverter: function() { |
| return [P.String, [P.List, P.int]]; |
| } |
| }, |
| AsciiEncoder: { |
| "^": "_UnicodeSubsetEncoder;_subsetMask" |
| }, |
| Base64Codec: { |
| "^": "Codec;_encoder", |
| normalize$3: function(source, start, end) { |
| var t1, inverseAlphabet, i, sliceStart, buffer, firstPadding, firstPaddingSourceIndex, paddingCount, i0, char, i1, digit1, digit2, char0, value, t2, t3, endLength, $length; |
| t1 = J.getInterceptor$asx(source); |
| end = P.RangeError_checkValidRange(start, end, t1.get$length(source), null, null, null); |
| inverseAlphabet = $.$get$_Base64Decoder__inverseAlphabet(); |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| sliceStart = i; |
| buffer = null; |
| firstPadding = -1; |
| firstPaddingSourceIndex = -1; |
| paddingCount = 0; |
| for (; i < end; i = i0) { |
| i0 = i + 1; |
| char = t1.codeUnitAt$1(source, i); |
| if (char === 37) { |
| i1 = i0 + 2; |
| if (i1 <= end) { |
| digit1 = H.hexDigitValue(t1.codeUnitAt$1(source, i0)); |
| digit2 = H.hexDigitValue(t1.codeUnitAt$1(source, i0 + 1)); |
| char0 = digit1 * 16 + digit2 - (digit2 & 256); |
| if (char0 === 37) |
| char0 = -1; |
| i0 = i1; |
| } else |
| char0 = -1; |
| } else |
| char0 = char; |
| if (0 <= char0 && char0 <= 127) { |
| if (char0 < 0 || char0 >= inverseAlphabet.length) |
| return H.ioore(inverseAlphabet, char0); |
| value = inverseAlphabet[char0]; |
| if (value >= 0) { |
| char0 = C.JSString_methods.codeUnitAt$1("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", value); |
| if (char0 === char) |
| continue; |
| char = char0; |
| } else { |
| if (value === -1) { |
| if (firstPadding < 0) { |
| t2 = buffer == null ? buffer : buffer._contents.length; |
| if (t2 == null) |
| t2 = 0; |
| firstPadding = J.$add$ns(t2, i - sliceStart); |
| firstPaddingSourceIndex = i; |
| } |
| ++paddingCount; |
| if (char === 61) |
| continue; |
| } |
| char = char0; |
| } |
| if (value !== -2) { |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| buffer._contents += t1.substring$2(source, sliceStart, i); |
| buffer._contents += H.Primitives_stringFromCharCode(char); |
| sliceStart = i0; |
| continue; |
| } |
| } |
| throw H.wrapException(new P.FormatException("Invalid base64 data", source, i)); |
| } |
| if (buffer != null) { |
| t2 = buffer._contents += t1.substring$2(source, sliceStart, end); |
| t3 = t2.length; |
| if (firstPadding >= 0) |
| P.Base64Codec__checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, t3); |
| else { |
| endLength = C.JSInt_methods.$mod(t3 - 1, 4) + 1; |
| if (endLength === 1) |
| throw H.wrapException(new P.FormatException("Invalid base64 encoding length ", source, end)); |
| for (; endLength < 4;) { |
| t2 += "="; |
| buffer._contents = t2; |
| ++endLength; |
| } |
| } |
| t2 = buffer._contents; |
| return t1.replaceRange$3(source, start, end, t2.charCodeAt(0) == 0 ? t2 : t2); |
| } |
| $length = end - start; |
| if (firstPadding >= 0) |
| P.Base64Codec__checkPadding(source, firstPaddingSourceIndex, end, firstPadding, paddingCount, $length); |
| else { |
| endLength = C.JSNumber_methods.$mod($length, 4); |
| if (endLength === 1) |
| throw H.wrapException(new P.FormatException("Invalid base64 encoding length ", source, end)); |
| if (endLength > 1) |
| source = t1.replaceRange$3(source, end, end, endLength === 2 ? "==" : "="); |
| } |
| return source; |
| }, |
| static: { |
| Base64Codec__checkPadding: function(source, sourceIndex, sourceEnd, firstPadding, paddingCount, $length) { |
| if (C.JSNumber_methods.$mod($length, 4) !== 0) |
| throw H.wrapException(new P.FormatException("Invalid base64 padding, padded length must be multiple of four, is " + H.S($length), source, sourceEnd)); |
| if (firstPadding + paddingCount !== $length) |
| throw H.wrapException(new P.FormatException("Invalid base64 padding, '=' not at the end", source, sourceIndex)); |
| if (paddingCount > 2) |
| throw H.wrapException(new P.FormatException("Invalid base64 padding, more than two '=' characters", source, sourceIndex)); |
| } |
| } |
| }, |
| Base64Encoder: { |
| "^": "Converter;_urlSafe", |
| $asConverter: function() { |
| return [[P.List, P.int], P.String]; |
| } |
| }, |
| Codec: { |
| "^": "Object;" |
| }, |
| Converter: { |
| "^": "Object;$ti" |
| }, |
| Encoding: { |
| "^": "Codec;" |
| }, |
| JsonUnsupportedObjectError: { |
| "^": "Error;unsupportedObject,cause,partialResult", |
| toString$0: function(_) { |
| var safeString = P.Error_safeToString(this.unsupportedObject); |
| return (this.cause != null ? "Converting object to an encodable object failed:" : "Converting object did not return an encodable object:") + " " + H.S(safeString); |
| } |
| }, |
| JsonCyclicError: { |
| "^": "JsonUnsupportedObjectError;unsupportedObject,cause,partialResult", |
| toString$0: function(_) { |
| return "Cyclic error in JSON stringify"; |
| } |
| }, |
| JsonCodec: { |
| "^": "Codec;_reviver,_toEncodable", |
| decode$2$reviver: function(source, reviver) { |
| var t1 = P._parseJson(source, this.get$decoder()._reviver); |
| return t1; |
| }, |
| decode$1: function(source) { |
| return this.decode$2$reviver(source, null); |
| }, |
| encode$2$toEncodable: function(value, toEncodable) { |
| var t1 = this.get$encoder(); |
| t1 = P._JsonStringStringifier_stringify(value, t1._toEncodable, t1.indent); |
| return t1; |
| }, |
| encode$1: function(value) { |
| return this.encode$2$toEncodable(value, null); |
| }, |
| get$encoder: function() { |
| return C.JsonEncoder_null_null; |
| }, |
| get$decoder: function() { |
| return C.JsonDecoder_null; |
| } |
| }, |
| JsonEncoder: { |
| "^": "Converter;indent,_toEncodable", |
| $asConverter: function() { |
| return [P.Object, P.String]; |
| } |
| }, |
| JsonDecoder: { |
| "^": "Converter;_reviver", |
| $asConverter: function() { |
| return [P.String, P.Object]; |
| } |
| }, |
| _JsonStringifier: { |
| "^": "Object;", |
| writeStringContent$1: function(s) { |
| var t1, $length, offset, i, charCode, t2; |
| t1 = J.getInterceptor$asx(s); |
| $length = t1.get$length(s); |
| if (typeof $length !== "number") |
| return H.iae($length); |
| offset = 0; |
| i = 0; |
| for (; i < $length; ++i) { |
| charCode = t1.codeUnitAt$1(s, i); |
| if (charCode > 92) |
| continue; |
| if (charCode < 32) { |
| if (i > offset) |
| this.writeStringSlice$3(s, offset, i); |
| offset = i + 1; |
| this.writeCharCode$1(92); |
| switch (charCode) { |
| case 8: |
| this.writeCharCode$1(98); |
| break; |
| case 9: |
| this.writeCharCode$1(116); |
| break; |
| case 10: |
| this.writeCharCode$1(110); |
| break; |
| case 12: |
| this.writeCharCode$1(102); |
| break; |
| case 13: |
| this.writeCharCode$1(114); |
| break; |
| default: |
| this.writeCharCode$1(117); |
| this.writeCharCode$1(48); |
| this.writeCharCode$1(48); |
| t2 = charCode >>> 4 & 15; |
| this.writeCharCode$1(t2 < 10 ? 48 + t2 : 87 + t2); |
| t2 = charCode & 15; |
| this.writeCharCode$1(t2 < 10 ? 48 + t2 : 87 + t2); |
| break; |
| } |
| } else if (charCode === 34 || charCode === 92) { |
| if (i > offset) |
| this.writeStringSlice$3(s, offset, i); |
| offset = i + 1; |
| this.writeCharCode$1(92); |
| this.writeCharCode$1(charCode); |
| } |
| } |
| if (offset === 0) |
| this.writeString$1(s); |
| else if (offset < $length) |
| this.writeStringSlice$3(s, offset, $length); |
| }, |
| _checkCycle$1: function(object) { |
| var t1, t2, i, t3; |
| for (t1 = this._seen, t2 = t1.length, i = 0; i < t2; ++i) { |
| t3 = t1[i]; |
| if (object == null ? t3 == null : object === t3) |
| throw H.wrapException(new P.JsonCyclicError(object, null, null)); |
| } |
| t1.push(object); |
| }, |
| writeObject$1: function(object) { |
| var customJson, e, t1, exception; |
| if (this.writeJsonValue$1(object)) |
| return; |
| this._checkCycle$1(object); |
| try { |
| customJson = this._toEncodable.call$1(object); |
| if (!this.writeJsonValue$1(customJson)) { |
| t1 = this.get$_partialResult(); |
| throw H.wrapException(new P.JsonUnsupportedObjectError(object, null, t1)); |
| } |
| t1 = this._seen; |
| if (0 >= t1.length) |
| return H.ioore(t1, -1); |
| t1.pop(); |
| } catch (exception) { |
| e = H.unwrapException(exception); |
| t1 = this.get$_partialResult(); |
| throw H.wrapException(new P.JsonUnsupportedObjectError(object, e, t1)); |
| } |
| }, |
| writeJsonValue$1: function(object) { |
| var t1, success; |
| if (typeof object === "number") { |
| if (!isFinite(object)) |
| return false; |
| this.writeNumber$1(object); |
| return true; |
| } else if (object === true) { |
| this.writeString$1("true"); |
| return true; |
| } else if (object === false) { |
| this.writeString$1("false"); |
| return true; |
| } else if (object == null) { |
| this.writeString$1("null"); |
| return true; |
| } else if (typeof object === "string") { |
| this.writeString$1('"'); |
| this.writeStringContent$1(object); |
| this.writeString$1('"'); |
| return true; |
| } else { |
| t1 = J.getInterceptor(object); |
| if (!!t1.$isList) { |
| this._checkCycle$1(object); |
| this.writeList$1(object); |
| t1 = this._seen; |
| if (0 >= t1.length) |
| return H.ioore(t1, -1); |
| t1.pop(); |
| return true; |
| } else if (!!t1.$isMap) { |
| this._checkCycle$1(object); |
| success = this.writeMap$1(object); |
| t1 = this._seen; |
| if (0 >= t1.length) |
| return H.ioore(t1, -1); |
| t1.pop(); |
| return success; |
| } else |
| return false; |
| } |
| }, |
| writeList$1: function(list) { |
| var t1, i; |
| this.writeString$1("["); |
| t1 = J.getInterceptor$asx(list); |
| if (t1.get$length(list) > 0) { |
| this.writeObject$1(t1.$index(list, 0)); |
| for (i = 1; i < t1.get$length(list); ++i) { |
| this.writeString$1(","); |
| this.writeObject$1(t1.$index(list, i)); |
| } |
| } |
| this.writeString$1("]"); |
| }, |
| writeMap$1: function(map) { |
| var _box_0, keyValueList, t1, separator, i, t2; |
| _box_0 = {}; |
| if (map.get$isEmpty(map) === true) { |
| this.writeString$1("{}"); |
| return true; |
| } |
| keyValueList = new Array(J.$mul$ns(map.get$length(map), 2)); |
| _box_0.i = 0; |
| _box_0.allStringKeys = true; |
| map.forEach$1(0, new P._JsonStringifier_writeMap_closure(_box_0, keyValueList)); |
| if (!_box_0.allStringKeys) |
| return false; |
| this.writeString$1("{"); |
| for (t1 = keyValueList.length, separator = '"', i = 0; i < t1; i += 2, separator = ',"') { |
| this.writeString$1(separator); |
| this.writeStringContent$1(keyValueList[i]); |
| this.writeString$1('":'); |
| t2 = i + 1; |
| if (t2 >= t1) |
| return H.ioore(keyValueList, t2); |
| this.writeObject$1(keyValueList[t2]); |
| } |
| this.writeString$1("}"); |
| return true; |
| } |
| }, |
| _JsonStringifier_writeMap_closure: { |
| "^": "Closure:3;_box_0,keyValueList", |
| call$2: function(key, value) { |
| var t1, t2, t3, i, t4; |
| if (typeof key !== "string") |
| this._box_0.allStringKeys = false; |
| t1 = this.keyValueList; |
| t2 = this._box_0; |
| t3 = t2.i; |
| i = t3 + 1; |
| t2.i = i; |
| t4 = t1.length; |
| if (t3 >= t4) |
| return H.ioore(t1, t3); |
| t1[t3] = key; |
| t2.i = i + 1; |
| if (i >= t4) |
| return H.ioore(t1, i); |
| t1[i] = value; |
| } |
| }, |
| _JsonStringStringifier: { |
| "^": "_JsonStringifier;_convert$_sink,_seen,_toEncodable", |
| get$_partialResult: function() { |
| var t1 = this._convert$_sink; |
| return !!t1.$isStringBuffer ? t1.toString$0(0) : null; |
| }, |
| writeNumber$1: function(number) { |
| this._convert$_sink.write$1(C.JSNumber_methods.toString$0(number)); |
| }, |
| writeString$1: function(string) { |
| this._convert$_sink.write$1(string); |
| }, |
| writeStringSlice$3: function(string, start, end) { |
| this._convert$_sink.write$1(J.substring$2$s(string, start, end)); |
| }, |
| writeCharCode$1: function(charCode) { |
| this._convert$_sink.writeCharCode$1(charCode); |
| }, |
| static: { |
| _JsonStringStringifier_stringify: function(object, toEncodable, indent) { |
| var output, t1; |
| output = new P.StringBuffer(""); |
| P._JsonStringStringifier_printOn(object, output, toEncodable, indent); |
| t1 = output._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _JsonStringStringifier_printOn: function(object, output, toEncodable, indent) { |
| var stringifier = new P._JsonStringStringifier(output, [], P.convert___defaultToEncodable$closure()); |
| stringifier.writeObject$1(object); |
| } |
| } |
| }, |
| Utf8Codec: { |
| "^": "Encoding;_allowMalformed", |
| get$encoder: function() { |
| return C.C_Utf8Encoder; |
| } |
| }, |
| Utf8Encoder: { |
| "^": "Converter;", |
| convert$3: function(string, start, end) { |
| var t1, stringLength, t2, $length, t3, encoder; |
| t1 = J.getInterceptor$asx(string); |
| stringLength = t1.get$length(string); |
| P.RangeError_checkValidRange(start, end, stringLength, null, null, null); |
| t2 = J.getInterceptor$n(stringLength); |
| $length = t2.$sub(stringLength, start); |
| if ($length === 0) |
| return new Uint8Array(H._checkLength(0)); |
| t3 = new Uint8Array(H._checkLength($length * 3)); |
| encoder = new P._Utf8Encoder(0, 0, t3); |
| if (encoder._fillBuffer$3(string, start, stringLength) !== stringLength) |
| encoder._writeSurrogate$2(t1.codeUnitAt$1(string, t2.$sub(stringLength, 1)), 0); |
| return C.NativeUint8List_methods.sublist$2(t3, 0, encoder._bufferIndex); |
| }, |
| 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, rune; |
| t1 = this._buffer; |
| t2 = this._bufferIndex; |
| t3 = t2 + 1; |
| t4 = t1.length; |
| if ((nextCodeUnit & 64512) === 56320) { |
| rune = 65536 + ((leadingSurrogate & 1023) << 10) | nextCodeUnit & 1023; |
| this._bufferIndex = t3; |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = 240 | rune >>> 18; |
| t2 = t3 + 1; |
| this._bufferIndex = t2; |
| if (t3 >= t4) |
| return H.ioore(t1, t3); |
| t1[t3] = 128 | rune >>> 12 & 63; |
| t3 = t2 + 1; |
| this._bufferIndex = t3; |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = 128 | rune >>> 6 & 63; |
| this._bufferIndex = t3 + 1; |
| if (t3 >= t4) |
| return H.ioore(t1, t3); |
| t1[t3] = 128 | rune & 63; |
| return true; |
| } else { |
| this._bufferIndex = t3; |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = 224 | leadingSurrogate >>> 12; |
| t2 = t3 + 1; |
| this._bufferIndex = t2; |
| if (t3 >= t4) |
| return H.ioore(t1, t3); |
| t1[t3] = 128 | leadingSurrogate >>> 6 & 63; |
| this._bufferIndex = t2 + 1; |
| if (t2 >= t4) |
| return H.ioore(t1, t2); |
| t1[t2] = 128 | leadingSurrogate & 63; |
| return false; |
| } |
| }, |
| _fillBuffer$3: function(str, start, end) { |
| var t1, t2, t3, stringIndex, codeUnit, t4, stringIndex0, t5; |
| if (start !== end && (J.codeUnitAt$1$s(str, J.$sub$n(end, 1)) & 64512) === 55296) |
| end = J.$sub$n(end, 1); |
| if (typeof end !== "number") |
| return H.iae(end); |
| t1 = this._buffer; |
| t2 = t1.length; |
| t3 = J.getInterceptor$s(str); |
| stringIndex = start; |
| for (; stringIndex < end; ++stringIndex) { |
| codeUnit = t3.codeUnitAt$1(str, stringIndex); |
| if (codeUnit <= 127) { |
| t4 = this._bufferIndex; |
| if (t4 >= t2) |
| break; |
| this._bufferIndex = t4 + 1; |
| t1[t4] = codeUnit; |
| } else if ((codeUnit & 64512) === 55296) { |
| if (this._bufferIndex + 3 >= t2) |
| break; |
| stringIndex0 = stringIndex + 1; |
| if (this._writeSurrogate$2(codeUnit, t3.codeUnitAt$1(str, stringIndex0))) |
| stringIndex = stringIndex0; |
| } else if (codeUnit <= 2047) { |
| t4 = this._bufferIndex; |
| t5 = t4 + 1; |
| if (t5 >= t2) |
| break; |
| this._bufferIndex = t5; |
| if (t4 >= t2) |
| return H.ioore(t1, t4); |
| t1[t4] = 192 | codeUnit >>> 6; |
| this._bufferIndex = t5 + 1; |
| t1[t5] = 128 | codeUnit & 63; |
| } else { |
| t4 = this._bufferIndex; |
| if (t4 + 2 >= t2) |
| break; |
| t5 = t4 + 1; |
| this._bufferIndex = t5; |
| if (t4 >= t2) |
| return H.ioore(t1, t4); |
| t1[t4] = 224 | codeUnit >>> 12; |
| t4 = t5 + 1; |
| this._bufferIndex = t4; |
| if (t5 >= t2) |
| return H.ioore(t1, t5); |
| t1[t5] = 128 | codeUnit >>> 6 & 63; |
| this._bufferIndex = t4 + 1; |
| if (t4 >= t2) |
| return H.ioore(t1, t4); |
| t1[t4] = 128 | codeUnit & 63; |
| } |
| } |
| return stringIndex; |
| } |
| }, |
| Utf8Decoder: { |
| "^": "Converter;_allowMalformed", |
| convert$3: function(codeUnits, start, end) { |
| var result, $length, buffer, decoder, t1; |
| result = P.Utf8Decoder__convertIntercepted(false, codeUnits, start, end); |
| if (result != null) |
| return result; |
| $length = J.get$length$asx(codeUnits); |
| P.RangeError_checkValidRange(start, end, $length, null, null, null); |
| buffer = new P.StringBuffer(""); |
| decoder = new P._Utf8Decoder(false, buffer, true, 0, 0, 0); |
| decoder.convert$3(codeUnits, start, $length); |
| decoder.flush$2(codeUnits, $length); |
| 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]; |
| }, |
| static: { |
| Utf8Decoder__convertInterceptedUint8List: function(allowMalformed, codeUnits, start, end) { |
| var decoder, t1, $length; |
| decoder = $.$get$Utf8Decoder__decoder(); |
| if (decoder == null) |
| return; |
| t1 = 0 === start; |
| if (t1 && true) |
| return P.Utf8Decoder__useTextDecoderChecked(decoder, codeUnits); |
| $length = codeUnits.length; |
| end = P.RangeError_checkValidRange(start, end, $length, null, null, null); |
| if (t1 && end === $length) |
| return P.Utf8Decoder__useTextDecoderChecked(decoder, codeUnits); |
| return P.Utf8Decoder__useTextDecoderChecked(decoder, codeUnits.subarray(start, end)); |
| }, |
| Utf8Decoder__useTextDecoderChecked: function(decoder, codeUnits) { |
| if (P.Utf8Decoder__unsafe(codeUnits)) |
| return; |
| return P.Utf8Decoder__useTextDecoderUnchecked(decoder, codeUnits); |
| }, |
| Utf8Decoder__useTextDecoderUnchecked: function(decoder, codeUnits) { |
| var t1, exception; |
| try { |
| t1 = decoder.decode(codeUnits); |
| return t1; |
| } catch (exception) { |
| H.unwrapException(exception); |
| } |
| return; |
| }, |
| Utf8Decoder__unsafe: function(codeUnits) { |
| var limit, i; |
| limit = codeUnits.length - 2; |
| for (i = 0; i < limit; ++i) |
| if (codeUnits[i] === 237) |
| if ((codeUnits[i + 1] & 224) === 160) |
| return true; |
| return false; |
| }, |
| Utf8Decoder__makeDecoder: function() { |
| var t1, exception; |
| try { |
| t1 = new TextDecoder("utf-8", {fatal: true}); |
| return t1; |
| } catch (exception) { |
| H.unwrapException(exception); |
| } |
| return; |
| }, |
| Utf8Decoder__convertIntercepted: function(allowMalformed, codeUnits, start, end) { |
| if (codeUnits instanceof Uint8Array) |
| return P.Utf8Decoder__convertInterceptedUint8List(false, codeUnits, start, end); |
| return; |
| } |
| } |
| }, |
| _Utf8Decoder: { |
| "^": "Object;_allowMalformed,_stringSink,_isFirstCharacter,_value,_expectedUnits,_extraUnits", |
| flush$2: function(source, offset) { |
| if (this._expectedUnits > 0) |
| throw H.wrapException(new P.FormatException("Unfinished UTF-8 octet sequence", source, offset)); |
| }, |
| convert$3: function(codeUnits, startIndex, endIndex) { |
| var value, expectedUnits, extraUnits, scanOneByteCharacters, addSingleBytes, t1, t2, i, unit, t3, oneBytes, i0, i1, t4; |
| value = this._value; |
| expectedUnits = this._expectedUnits; |
| extraUnits = this._extraUnits; |
| this._value = 0; |
| this._expectedUnits = 0; |
| this._extraUnits = 0; |
| scanOneByteCharacters = new P._Utf8Decoder_convert_scanOneByteCharacters(endIndex); |
| addSingleBytes = new P._Utf8Decoder_convert_addSingleBytes(this, codeUnits, startIndex, endIndex); |
| $loop$0: |
| for (t1 = J.getInterceptor$asx(codeUnits), t2 = this._stringSink, i = startIndex; true; i = i1) { |
| $multibyte$2: |
| if (expectedUnits > 0) { |
| do { |
| if (i === endIndex) |
| break $loop$0; |
| unit = t1.$index(codeUnits, i); |
| t3 = J.getInterceptor$n(unit); |
| if (t3.$and(unit, 192) !== 128) { |
| t3 = new P.FormatException("Bad UTF-8 encoding 0x" + t3.toRadixString$1(unit, 16), codeUnits, i); |
| throw H.wrapException(t3); |
| } else { |
| value = (value << 6 | t3.$and(unit, 63)) >>> 0; |
| --expectedUnits; |
| ++i; |
| } |
| } while (expectedUnits > 0); |
| t3 = extraUnits - 1; |
| if (t3 < 0 || t3 >= 4) |
| return H.ioore(C.List_127_2047_65535_1114111, t3); |
| if (value <= C.List_127_2047_65535_1114111[t3]) { |
| t3 = new P.FormatException("Overlong encoding of 0x" + C.JSInt_methods.toRadixString$1(value, 16), codeUnits, i - extraUnits - 1); |
| throw H.wrapException(t3); |
| } |
| if (value > 1114111) { |
| t3 = new P.FormatException("Character outside valid Unicode range: 0x" + C.JSInt_methods.toRadixString$1(value, 16), codeUnits, i - extraUnits - 1); |
| throw H.wrapException(t3); |
| } |
| if (!this._isFirstCharacter || value !== 65279) |
| t2._contents += H.Primitives_stringFromCharCode(value); |
| this._isFirstCharacter = false; |
| } |
| if (typeof endIndex !== "number") |
| return H.iae(endIndex); |
| t3 = i < endIndex; |
| for (; t3;) { |
| oneBytes = scanOneByteCharacters.call$2(codeUnits, i); |
| if (J.$gt$n(oneBytes, 0)) { |
| this._isFirstCharacter = false; |
| if (typeof oneBytes !== "number") |
| return H.iae(oneBytes); |
| i0 = i + oneBytes; |
| addSingleBytes.call$2(i, i0); |
| if (i0 === endIndex) |
| break; |
| } else |
| i0 = i; |
| i1 = i0 + 1; |
| unit = t1.$index(codeUnits, i0); |
| t4 = J.getInterceptor$n(unit); |
| if (t4.$lt(unit, 0)) { |
| t4 = new P.FormatException("Negative UTF-8 code unit: -0x" + J.toRadixString$1$n(t4.$negate(unit), 16), codeUnits, i1 - 1); |
| throw H.wrapException(t4); |
| } else { |
| if (t4.$and(unit, 224) === 192) { |
| value = t4.$and(unit, 31); |
| expectedUnits = 1; |
| extraUnits = 1; |
| continue $loop$0; |
| } |
| if (t4.$and(unit, 240) === 224) { |
| value = t4.$and(unit, 15); |
| expectedUnits = 2; |
| extraUnits = 2; |
| continue $loop$0; |
| } |
| if (t4.$and(unit, 248) === 240 && t4.$lt(unit, 245)) { |
| value = t4.$and(unit, 7); |
| expectedUnits = 3; |
| extraUnits = 3; |
| continue $loop$0; |
| } |
| t4 = new P.FormatException("Bad UTF-8 encoding 0x" + t4.toRadixString$1(unit, 16), codeUnits, i1 - 1); |
| throw H.wrapException(t4); |
| } |
| } |
| break $loop$0; |
| } |
| if (expectedUnits > 0) { |
| this._value = value; |
| this._expectedUnits = expectedUnits; |
| this._extraUnits = extraUnits; |
| } |
| } |
| }, |
| _Utf8Decoder_convert_scanOneByteCharacters: { |
| "^": "Closure:16;endIndex", |
| call$2: function(units, from) { |
| var to, t1, i, unit; |
| to = this.endIndex; |
| if (typeof to !== "number") |
| return H.iae(to); |
| t1 = J.getInterceptor$asx(units); |
| i = from; |
| for (; i < to; ++i) { |
| unit = t1.$index(units, i); |
| if (J.$and$n(unit, 127) !== unit) |
| return i - from; |
| } |
| return to - from; |
| } |
| }, |
| _Utf8Decoder_convert_addSingleBytes: { |
| "^": "Closure:17;$this,codeUnits,startIndex,endIndex", |
| call$2: function(from, to) { |
| this.$this._stringSink._contents += P.String_String$fromCharCodes(this.codeUnits, from, to); |
| } |
| } |
| }], ["dart.core", "dart:core",, P, { |
| "^": "", |
| 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 && J.$lt$n(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 { |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| for (; 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, growable, $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, i, t1; |
| result = H.setRuntimeTypeInfo([], [$E]); |
| C.JSArray_methods.set$length(result, $length); |
| 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; |
| }, |
| List_List$unmodifiable: function(elements, $E) { |
| return J.JSArray_markUnmodifiableList(P.List_List$from(elements, false, $E)); |
| }, |
| print: function(object) { |
| var line, t1; |
| line = H.S(object); |
| t1 = $.printToZone; |
| if (t1 == null) |
| H.printString(line); |
| else |
| t1.call$1(line); |
| }, |
| RegExp_RegExp: function(source, caseSensitive, multiLine) { |
| return new H.JSSyntaxRegExp(source, H.JSSyntaxRegExp_makeNative(source, multiLine, true, false), null, null); |
| }, |
| String_String$fromCharCodes: function(charCodes, start, end) { |
| var len; |
| if (typeof charCodes === "object" && charCodes !== null && charCodes.constructor === Array) { |
| len = charCodes.length; |
| end = P.RangeError_checkValidRange(start, end, len, null, null, null); |
| return H.Primitives_stringFromCharCodes(start > 0 || J.$lt$n(end, len) ? C.JSArray_methods.sublist$2(charCodes, start, end) : charCodes); |
| } |
| if (!!J.getInterceptor(charCodes).$isNativeUint8List) |
| return H.Primitives_stringFromNativeUint8List(charCodes, start, P.RangeError_checkValidRange(start, end, charCodes.length, null, null, null)); |
| return P.String__stringFromIterable(charCodes, start, end); |
| }, |
| String_String$fromCharCode: function(charCode) { |
| return H.Primitives_stringFromCharCode(charCode); |
| }, |
| 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_parse: function(uri, start, end) { |
| var t1, t2, t3, delta, indices, t4, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, t5, t6, isSimple, scheme, t7, t8, schemeAuth; |
| t1 = J.getInterceptor$asx(uri); |
| end = t1.get$length(uri); |
| t2 = start + 5; |
| t3 = J.getInterceptor$n(end); |
| if (t3.$ge(end, t2)) { |
| delta = ((t1.codeUnitAt$1(uri, start + 4) ^ 58) * 3 | t1.codeUnitAt$1(uri, start) ^ 100 | t1.codeUnitAt$1(uri, start + 1) ^ 97 | t1.codeUnitAt$1(uri, start + 2) ^ 116 | t1.codeUnitAt$1(uri, start + 3) ^ 97) >>> 0; |
| if (delta === 0) |
| return P.UriData__parse(start > 0 || t3.$lt(end, t1.get$length(uri)) ? t1.substring$2(uri, start, end) : uri, 5, null).get$uri(); |
| else if (delta === 32) |
| return P.UriData__parse(t1.substring$2(uri, t2, end), 0, null).get$uri(); |
| } |
| indices = H.setRuntimeTypeInfo(new Array(8), [P.int]); |
| indices[0] = 0; |
| t4 = start - 1; |
| indices[1] = t4; |
| indices[2] = t4; |
| indices[7] = t4; |
| indices[3] = start; |
| indices[4] = start; |
| indices[5] = end; |
| indices[6] = end; |
| if (P._scan(uri, start, end, 0, indices) >= 14) |
| indices[7] = end; |
| schemeEnd = indices[1]; |
| t4 = J.getInterceptor$n(schemeEnd); |
| if (t4.$ge(schemeEnd, start)) |
| if (P._scan(uri, start, schemeEnd, 20, indices) === 20) |
| indices[7] = schemeEnd; |
| hostStart = J.$add$ns(indices[2], 1); |
| portStart = indices[3]; |
| pathStart = indices[4]; |
| queryStart = indices[5]; |
| fragmentStart = indices[6]; |
| t5 = J.getInterceptor$n(fragmentStart); |
| if (t5.$lt(fragmentStart, queryStart)) |
| queryStart = fragmentStart; |
| t6 = J.getInterceptor$n(pathStart); |
| if (t6.$lt(pathStart, hostStart) || t6.$le(pathStart, schemeEnd)) |
| pathStart = queryStart; |
| if (J.$lt$n(portStart, hostStart)) |
| portStart = pathStart; |
| isSimple = J.$lt$n(indices[7], start); |
| if (isSimple) |
| if (hostStart > t4.$add(schemeEnd, 3)) { |
| scheme = null; |
| isSimple = false; |
| } else { |
| t6 = J.getInterceptor$n(portStart); |
| if (t6.$gt(portStart, start) && t6.$add(portStart, 1) === pathStart) { |
| scheme = null; |
| isSimple = false; |
| } else { |
| t7 = J.getInterceptor$n(queryStart); |
| if (!(t7.$lt(queryStart, end) && queryStart === J.$add$ns(pathStart, 2) && t1.startsWith$2(uri, "..", pathStart))) |
| t8 = t7.$gt(queryStart, J.$add$ns(pathStart, 2)) && t1.startsWith$2(uri, "/..", t7.$sub(queryStart, 3)); |
| else |
| t8 = true; |
| if (t8) { |
| scheme = null; |
| isSimple = false; |
| } else { |
| if (schemeEnd === start + 4) |
| if (t1.startsWith$2(uri, "file", start)) { |
| if (hostStart <= start) { |
| if (!t1.startsWith$2(uri, "/", pathStart)) { |
| schemeAuth = "file:///"; |
| delta = 3; |
| } else { |
| schemeAuth = "file://"; |
| delta = 2; |
| } |
| uri = schemeAuth + t1.substring$2(uri, pathStart, end); |
| schemeEnd = t4.$sub(schemeEnd, start); |
| t1 = delta - start; |
| queryStart = t7.$add(queryStart, t1); |
| fragmentStart = t5.$add(fragmentStart, t1); |
| end = uri.length; |
| start = 0; |
| hostStart = 7; |
| portStart = 7; |
| pathStart = 7; |
| } else if (pathStart == null ? queryStart == null : pathStart === queryStart) { |
| if (start === 0) { |
| t2 = t1.get$length(uri); |
| t2 = end == null ? t2 == null : end === t2; |
| } else |
| t2 = false; |
| if (t2) { |
| uri = t1.replaceRange$3(uri, pathStart, queryStart, "/"); |
| queryStart = t7.$add(queryStart, 1); |
| fragmentStart = t5.$add(fragmentStart, 1); |
| end = t3.$add(end, 1); |
| } else { |
| uri = t1.substring$2(uri, start, pathStart) + "/" + t1.substring$2(uri, queryStart, end); |
| schemeEnd = t4.$sub(schemeEnd, start); |
| hostStart -= start; |
| portStart = t6.$sub(portStart, start); |
| pathStart = J.$sub$n(pathStart, start); |
| t1 = 1 - start; |
| queryStart = t7.$add(queryStart, t1); |
| fragmentStart = t5.$add(fragmentStart, t1); |
| end = uri.length; |
| start = 0; |
| } |
| } |
| scheme = "file"; |
| } else if (t1.startsWith$2(uri, "http", start)) { |
| if (t6.$gt(portStart, start) && t6.$add(portStart, 3) === pathStart && t1.startsWith$2(uri, "80", t6.$add(portStart, 1))) { |
| if (start === 0) { |
| t2 = t1.get$length(uri); |
| t2 = end == null ? t2 == null : end === t2; |
| } else |
| t2 = false; |
| t8 = J.getInterceptor$n(pathStart); |
| if (t2) { |
| uri = t1.replaceRange$3(uri, portStart, pathStart, ""); |
| pathStart = t8.$sub(pathStart, 3); |
| queryStart = t7.$sub(queryStart, 3); |
| fragmentStart = t5.$sub(fragmentStart, 3); |
| end = t3.$sub(end, 3); |
| } else { |
| uri = t1.substring$2(uri, start, portStart) + t1.substring$2(uri, pathStart, end); |
| schemeEnd = t4.$sub(schemeEnd, start); |
| hostStart -= start; |
| portStart = t6.$sub(portStart, start); |
| t1 = 3 + start; |
| pathStart = t8.$sub(pathStart, t1); |
| queryStart = t7.$sub(queryStart, t1); |
| fragmentStart = t5.$sub(fragmentStart, t1); |
| end = uri.length; |
| start = 0; |
| } |
| } |
| scheme = "http"; |
| } else |
| scheme = null; |
| else if (schemeEnd === t2 && t1.startsWith$2(uri, "https", start)) { |
| if (t6.$gt(portStart, start) && t6.$add(portStart, 4) === pathStart && t1.startsWith$2(uri, "443", t6.$add(portStart, 1))) { |
| if (start === 0) { |
| t2 = t1.get$length(uri); |
| t2 = end == null ? t2 == null : end === t2; |
| } else |
| t2 = false; |
| t8 = J.getInterceptor$n(pathStart); |
| if (t2) { |
| uri = t1.replaceRange$3(uri, portStart, pathStart, ""); |
| pathStart = t8.$sub(pathStart, 4); |
| queryStart = t7.$sub(queryStart, 4); |
| fragmentStart = t5.$sub(fragmentStart, 4); |
| end = t3.$sub(end, 3); |
| } else { |
| uri = t1.substring$2(uri, start, portStart) + t1.substring$2(uri, pathStart, end); |
| schemeEnd = t4.$sub(schemeEnd, start); |
| hostStart -= start; |
| portStart = t6.$sub(portStart, start); |
| t1 = 4 + start; |
| pathStart = t8.$sub(pathStart, t1); |
| queryStart = t7.$sub(queryStart, t1); |
| fragmentStart = t5.$sub(fragmentStart, t1); |
| end = uri.length; |
| start = 0; |
| } |
| } |
| scheme = "https"; |
| } else |
| scheme = null; |
| isSimple = true; |
| } |
| } |
| } |
| else |
| scheme = null; |
| if (isSimple) { |
| if (start > 0 || J.$lt$n(end, J.get$length$asx(uri))) { |
| uri = J.substring$2$s(uri, start, end); |
| schemeEnd = J.$sub$n(schemeEnd, start); |
| hostStart -= start; |
| portStart = J.$sub$n(portStart, start); |
| pathStart = J.$sub$n(pathStart, start); |
| queryStart = J.$sub$n(queryStart, start); |
| fragmentStart = J.$sub$n(fragmentStart, start); |
| } |
| return new P._SimpleUri(uri, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme, null); |
| } |
| return P._Uri__Uri$notSimple(uri, start, end, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme); |
| }, |
| Uri_decodeComponent: [function(encodedComponent) { |
| return P._Uri__uriDecode(encodedComponent, 0, J.get$length$asx(encodedComponent), C.Utf8Codec_false, false); |
| }, "call$1", "core_Uri_decodeComponent$closure", 2, 0, 24, 28], |
| Uri_splitQueryString: function(query, encoding) { |
| return C.JSArray_methods.fold$2(H.setRuntimeTypeInfo(query.split("&"), [P.String]), P.LinkedHashMap__makeEmpty(), new P.Uri_splitQueryString_closure(encoding)); |
| }, |
| Uri__parseIPv4Address: function(host, start, end) { |
| var error, t1, result, t2, i, partStart, partIndex, char, part, partIndex0; |
| error = new P.Uri__parseIPv4Address_error(host); |
| t1 = H._checkLength(4); |
| result = new Uint8Array(t1); |
| if (typeof end !== "number") |
| return H.iae(end); |
| t2 = J.getInterceptor$s(host); |
| i = start; |
| partStart = i; |
| partIndex = 0; |
| for (; i < end; ++i) { |
| char = t2.codeUnitAt$1(host, i); |
| if (char !== 46) { |
| if ((char ^ 48) > 9) |
| error.call$2("invalid character", i); |
| } else { |
| if (partIndex === 3) |
| error.call$2("IPv4 address should contain exactly 4 parts", i); |
| part = H.Primitives_parseInt(t2.substring$2(host, partStart, i), null, null); |
| if (J.$gt$n(part, 255)) |
| error.call$2("each part must be in the range 0..255", partStart); |
| partIndex0 = partIndex + 1; |
| if (partIndex >= t1) |
| return H.ioore(result, partIndex); |
| result[partIndex] = part; |
| partStart = i + 1; |
| partIndex = partIndex0; |
| } |
| } |
| if (partIndex !== 3) |
| error.call$2("IPv4 address should contain exactly 4 parts", end); |
| part = H.Primitives_parseInt(t2.substring$2(host, partStart, end), null, null); |
| if (J.$gt$n(part, 255)) |
| error.call$2("each part must be in the range 0..255", partStart); |
| if (partIndex >= t1) |
| return H.ioore(result, partIndex); |
| result[partIndex] = part; |
| return result; |
| }, |
| Uri_parseIPv6Address: function(host, start, end) { |
| var error, parseHex, t1, parts, i, partStart, wildcardSeen, seenDot, char, atEnd, isLastWildcard, last, 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); |
| t1 = J.getInterceptor$asx(host); |
| if (J.$lt$n(t1.get$length(host), 2)) |
| error.call$1("address is too short"); |
| parts = []; |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| partStart = i; |
| wildcardSeen = false; |
| seenDot = false; |
| for (; i < end; ++i) { |
| char = t1.codeUnitAt$1(host, i); |
| if (char === 58) { |
| if (i === start) { |
| ++i; |
| if (t1.codeUnitAt$1(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); |
| parts.push(-1); |
| wildcardSeen = true; |
| } else |
| parts.push(parseHex.call$2(partStart, i)); |
| partStart = i + 1; |
| } else if (char === 46) |
| seenDot = true; |
| } |
| if (parts.length === 0) |
| error.call$1("too few parts"); |
| atEnd = partStart === end; |
| isLastWildcard = J.$eq$(C.JSArray_methods.get$last(parts), -1); |
| if (atEnd && !isLastWildcard) |
| error.call$2("expected a part after last `:`", end); |
| if (!atEnd) |
| if (!seenDot) |
| parts.push(parseHex.call$2(partStart, end)); |
| else { |
| last = P.Uri__parseIPv4Address(host, partStart, end); |
| t1 = J.$shl$n(last[0], 8); |
| t2 = last[1]; |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| parts.push((t1 | t2) >>> 0); |
| t2 = J.$shl$n(last[2], 8); |
| t1 = last[3]; |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| parts.push((t2 | t1) >>> 0); |
| } |
| if (wildcardSeen) { |
| if (parts.length > 7) |
| error.call$1("an address with a wildcard must have less than 7 parts"); |
| } else if (parts.length !== 8) |
| error.call$1("an address without a wildcard must contain exactly 8 parts"); |
| bytes = new Uint8Array(16); |
| for (i = 0, index = 0; i < parts.length; ++i) { |
| value = parts[i]; |
| t1 = J.getInterceptor(value); |
| if (t1.$eq(value, -1)) { |
| wildCardLength = 9 - parts.length; |
| 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 { |
| t2 = t1.$shr(value, 8); |
| if (index < 0 || index >= 16) |
| return H.ioore(bytes, index); |
| bytes[index] = t2; |
| t2 = index + 1; |
| t1 = t1.$and(value, 255); |
| if (t2 >= 16) |
| return H.ioore(bytes, t2); |
| bytes[t2] = t1; |
| index += 2; |
| } |
| } |
| return bytes; |
| }, |
| _createTables: function() { |
| var tables, t1, t2, t3, b; |
| tables = P.List_List$generate(22, new P._createTables_closure(), true, P.Uint8List); |
| t1 = new P._createTables_build(tables); |
| t2 = new P._createTables_setChars(); |
| t3 = new P._createTables_setRange(); |
| b = t1.call$2(0, 225); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 1); |
| t2.call$3(b, ".", 14); |
| t2.call$3(b, ":", 34); |
| t2.call$3(b, "/", 3); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(14, 225); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 1); |
| t2.call$3(b, ".", 15); |
| t2.call$3(b, ":", 34); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(15, 225); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 1); |
| t2.call$3(b, "%", 225); |
| t2.call$3(b, ":", 34); |
| t2.call$3(b, "/", 9); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(1, 225); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 1); |
| t2.call$3(b, ":", 34); |
| t2.call$3(b, "/", 10); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(2, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 139); |
| t2.call$3(b, "/", 131); |
| t2.call$3(b, ".", 146); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(3, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, "/", 68); |
| t2.call$3(b, ".", 18); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(4, 229); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 5); |
| t3.call$3(b, "AZ", 229); |
| t2.call$3(b, ":", 102); |
| t2.call$3(b, "@", 68); |
| t2.call$3(b, "[", 232); |
| t2.call$3(b, "/", 138); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(5, 229); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 5); |
| t3.call$3(b, "AZ", 229); |
| t2.call$3(b, ":", 102); |
| t2.call$3(b, "@", 68); |
| t2.call$3(b, "/", 138); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(6, 231); |
| t3.call$3(b, "19", 7); |
| t2.call$3(b, "@", 68); |
| t2.call$3(b, "/", 138); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(7, 231); |
| t3.call$3(b, "09", 7); |
| t2.call$3(b, "@", 68); |
| t2.call$3(b, "/", 138); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| t2.call$3(t1.call$2(8, 8), "]", 5); |
| b = t1.call$2(9, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, ".", 16); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(16, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, ".", 17); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(17, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, "/", 9); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(10, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, ".", 18); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(18, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, ".", 19); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(19, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, "/", 234); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(11, 235); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 11); |
| t2.call$3(b, "/", 10); |
| t2.call$3(b, "?", 172); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(12, 236); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 12); |
| t2.call$3(b, "?", 12); |
| t2.call$3(b, "#", 205); |
| b = t1.call$2(13, 237); |
| t2.call$3(b, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-._~!$&'()*+,;=", 13); |
| t2.call$3(b, "?", 13); |
| t3.call$3(t1.call$2(20, 245), "az", 21); |
| b = t1.call$2(21, 245); |
| t3.call$3(b, "az", 21); |
| t3.call$3(b, "09", 21); |
| t2.call$3(b, "+-.", 21); |
| return tables; |
| }, |
| _scan: function(uri, start, end, state, indices) { |
| var tables, t1, i, table, char, transition, t2; |
| tables = $.$get$_scannerTables(); |
| if (typeof end !== "number") |
| return H.iae(end); |
| t1 = J.getInterceptor$s(uri); |
| i = start; |
| for (; i < end; ++i) { |
| if (state < 0 || state >= tables.length) |
| return H.ioore(tables, state); |
| table = tables[state]; |
| char = t1.codeUnitAt$1(uri, i) ^ 96; |
| transition = J.$index$asx(table, char > 95 ? 31 : char); |
| t2 = J.getInterceptor$n(transition); |
| state = t2.$and(transition, 31); |
| t2 = t2.$shr(transition, 5); |
| if (t2 >= 8) |
| return H.ioore(indices, t2); |
| indices[t2] = i; |
| } |
| return state; |
| }, |
| NoSuchMethodError_toString_closure: { |
| "^": "Closure:18;_box_0,sb", |
| call$2: function(key, value) { |
| var t1, t2; |
| t1 = this.sb; |
| t2 = this._box_0; |
| t1.write$1(t2.comma); |
| t1.write$1(key.get$__internal$_name()); |
| t1.write$1(": "); |
| t1.write$1(P.Error_safeToString(value)); |
| t2.comma = ", "; |
| } |
| }, |
| bool: { |
| "^": "Object;" |
| }, |
| "+bool": 0, |
| DateTime: { |
| "^": "Object;_core$_value,isUtc", |
| DateTime$_withValue$2$isUtc: function(_value, isUtc) { |
| var t1; |
| if (!(Math.abs(this._core$_value) > 864e13)) |
| t1 = false; |
| else |
| t1 = true; |
| if (t1) |
| throw H.wrapException(P.ArgumentError$("DateTime is outside valid range: " + this.get$millisecondsSinceEpoch())); |
| }, |
| $eq: function(_, other) { |
| if (other == null) |
| return false; |
| if (!(other instanceof P.DateTime)) |
| return false; |
| return this._core$_value === other._core$_value && true; |
| }, |
| get$hashCode: function(_) { |
| var t1 = this._core$_value; |
| return (t1 ^ C.JSInt_methods._shrOtherPositive$1(t1, 30)) & 1073741823; |
| }, |
| toString$0: function(_) { |
| var y, m, d, h, min, sec, ms, t1; |
| y = P.DateTime__fourDigits(H.Primitives_getYear(this)); |
| m = P.DateTime__twoDigits(H.Primitives_getMonth(this)); |
| d = P.DateTime__twoDigits(H.Primitives_getDay(this)); |
| h = P.DateTime__twoDigits(H.Primitives_getHours(this)); |
| min = P.DateTime__twoDigits(H.Primitives_getMinutes(this)); |
| sec = P.DateTime__twoDigits(H.Primitives_getSeconds(this)); |
| ms = P.DateTime__threeDigits(H.Primitives_getMilliseconds(this)); |
| t1 = y + "-" + m + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + "Z"; |
| return t1; |
| }, |
| get$millisecondsSinceEpoch: function() { |
| return this._core$_value; |
| }, |
| static: { |
| DateTime__fourDigits: function(n) { |
| var absN, sign; |
| absN = Math.abs(n); |
| sign = n < 0 ? "-" : ""; |
| if (absN >= 1000) |
| return "" + n; |
| if (absN >= 100) |
| return sign + "0" + H.S(absN); |
| if (absN >= 10) |
| return sign + "00" + H.S(absN); |
| return sign + "000" + H.S(absN); |
| }, |
| DateTime__threeDigits: function(n) { |
| if (n >= 100) |
| return "" + n; |
| if (n >= 10) |
| return "0" + n; |
| return "00" + n; |
| }, |
| DateTime__twoDigits: function(n) { |
| if (n >= 10) |
| return "" + n; |
| return "0" + n; |
| } |
| } |
| }, |
| double: { |
| "^": "num;" |
| }, |
| "+double": 0, |
| Duration: { |
| "^": "Object;_duration", |
| $add: function(_, other) { |
| return new P.Duration(C.JSInt_methods.$add(this._duration, other.get$_duration())); |
| }, |
| $sub: function(_, other) { |
| return new P.Duration(C.JSInt_methods.$sub(this._duration, other.get$_duration())); |
| }, |
| $tdiv: function(_, quotient) { |
| if (quotient === 0) |
| throw H.wrapException(new P.IntegerDivisionByZeroException()); |
| return new P.Duration(C.JSInt_methods.$tdiv(this._duration, quotient)); |
| }, |
| $lt: function(_, other) { |
| return C.JSInt_methods.$lt(this._duration, other.get$_duration()); |
| }, |
| $gt: function(_, other) { |
| return C.JSInt_methods.$gt(this._duration, other.get$_duration()); |
| }, |
| $le: function(_, other) { |
| return C.JSInt_methods.$le(this._duration, other.get$_duration()); |
| }, |
| get$inMilliseconds: function() { |
| return C.JSInt_methods._tdivFast$1(this._duration, 1000); |
| }, |
| $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(0 - t2).toString$0(0); |
| twoDigitMinutes = t1.call$1(C.JSInt_methods._tdivFast$1(t2, 60000000) % 60); |
| twoDigitSeconds = t1.call$1(C.JSInt_methods._tdivFast$1(t2, 1000000) % 60); |
| sixDigitUs = new P.Duration_toString_sixDigits().call$1(t2 % 1000000); |
| return "" + C.JSInt_methods._tdivFast$1(t2, 3600000000) + ":" + H.S(twoDigitMinutes) + ":" + H.S(twoDigitSeconds) + "." + H.S(sixDigitUs); |
| }, |
| $negate: function(_) { |
| return new P.Duration(0 - this._duration); |
| }, |
| static: { |
| Duration$: function(days, hours, microseconds, milliseconds, minutes, seconds) { |
| return new P.Duration(864e8 * days + 3600000000 * hours + 60000000 * minutes + 1000000 * seconds + 1000 * milliseconds + microseconds); |
| } |
| } |
| }, |
| 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 ? " (" + 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); |
| }, |
| ArgumentError$notNull: function($name) { |
| return new P.ArgumentError(false, null, $name, "Must not be null"); |
| } |
| } |
| }, |
| RangeError: { |
| "^": "ArgumentError;start,end,_hasValue,invalidValue,name,message", |
| get$_errorName: function() { |
| return "RangeError"; |
| }, |
| get$_errorExplanation: function() { |
| var t1, explanation, t2, t3; |
| 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 { |
| t3 = J.getInterceptor$n(t2); |
| if (t3.$gt(t2, t1)) |
| explanation = ": Not in range " + H.S(t1) + ".." + H.S(t2) + ", inclusive"; |
| else |
| explanation = t3.$lt(t2, t1) ? ": Valid value range is empty" : ": Only valid value is " + H.S(t1); |
| } |
| } |
| return explanation; |
| }, |
| static: { |
| RangeError$value: function(value, $name, message) { |
| return new P.RangeError(null, null, true, value, $name, "Value not in range"); |
| }, |
| RangeError$range: function(invalidValue, minValue, maxValue, $name, message) { |
| return new P.RangeError(minValue, maxValue, true, invalidValue, $name, "Invalid value"); |
| }, |
| RangeError_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) { |
| var t1; |
| if (typeof start !== "number") |
| return H.iae(start); |
| if (!(0 > start)) { |
| if (typeof $length !== "number") |
| return H.iae($length); |
| t1 = start > $length; |
| } else |
| t1 = true; |
| if (t1) |
| throw H.wrapException(P.RangeError$range(start, 0, $length, "start", message)); |
| if (end != null) { |
| if (typeof end !== "number") |
| return H.iae(end); |
| if (!(start > end)) { |
| if (typeof $length !== "number") |
| return H.iae($length); |
| t1 = end > $length; |
| } else |
| t1 = true; |
| if (t1) |
| 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 (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"); |
| } |
| } |
| }, |
| NoSuchMethodError: { |
| "^": "Error;_core$_receiver,_memberName,_core$_arguments,_namedArguments,_existingArgumentNames", |
| toString$0: function(_) { |
| var _box_0, sb, t1, t2, _i, t3, t4, argument, receiverText, actualParameters; |
| _box_0 = {}; |
| sb = new P.StringBuffer(""); |
| _box_0.comma = ""; |
| for (t1 = this._core$_arguments, t2 = t1.length, _i = 0, t3 = "", t4 = ""; _i < t2; ++_i, t4 = ", ") { |
| argument = t1[_i]; |
| sb._contents = t3 + t4; |
| t3 = sb._contents += H.S(P.Error_safeToString(argument)); |
| _box_0.comma = ", "; |
| } |
| this._namedArguments.forEach$1(0, new P.NoSuchMethodError_toString_closure(_box_0, sb)); |
| receiverText = P.Error_safeToString(this._core$_receiver); |
| actualParameters = sb.toString$0(0); |
| t1 = "NoSuchMethodError: method not found: '" + H.S(this._memberName.__internal$_name) + "'\nReceiver: " + H.S(receiverText) + "\nArguments: [" + actualParameters + "]"; |
| return t1; |
| }, |
| static: { |
| NoSuchMethodError$: function(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) { |
| return new P.NoSuchMethodError(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames); |
| } |
| } |
| }, |
| 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(_) { |
| var t1 = this.variableName; |
| return t1 == null ? "Reading static variable during its initialization" : "Reading static variable '" + H.S(t1) + "' 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, previousCharWasCR, 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 = J.getInterceptor$n(offset); |
| t1 = t1.$lt(offset, 0) || t1.$gt(offset, source.length); |
| } else |
| t1 = false; |
| if (t1) |
| offset = null; |
| if (offset == null) { |
| if (source.length > 78) |
| source = C.JSString_methods.substring$2(source, 0, 75) + "..."; |
| return report + "\n" + source; |
| } |
| if (typeof offset !== "number") |
| return H.iae(offset); |
| lineNum = 1; |
| lineStart = 0; |
| previousCharWasCR = false; |
| i = 0; |
| for (; i < offset; ++i) { |
| char = C.JSString_methods._codeUnitAt$1(source, i); |
| if (char === 10) { |
| if (lineStart !== i || !previousCharWasCR) |
| ++lineNum; |
| lineStart = i + 1; |
| previousCharWasCR = false; |
| } else if (char === 13) { |
| ++lineNum; |
| lineStart = i + 1; |
| previousCharWasCR = true; |
| } |
| } |
| report = lineNum > 1 ? report + (" (at line " + lineNum + ", character " + H.S(offset - lineStart + 1) + ")\n") : report + (" (at character " + H.S(offset + 1) + ")\n"); |
| lineEnd = source.length; |
| for (i = offset; i < source.length; ++i) { |
| char = C.JSString_methods.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 = C.JSString_methods.substring$2(source, start, end); |
| return report + prefix + slice + postfix + "\n" + C.JSString_methods.$mul(" ", offset - start + prefix.length) + "^\n"; |
| } |
| }, |
| IntegerDivisionByZeroException: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return "IntegerDivisionByZeroException"; |
| } |
| }, |
| Expando: { |
| "^": "Object;name,_jsWeakMapOrKey", |
| toString$0: function(_) { |
| return "Expando:" + H.S(this.name); |
| }, |
| $index: function(_, object) { |
| var t1, values; |
| t1 = this._jsWeakMapOrKey; |
| if (typeof t1 !== "string") { |
| if (object == null || typeof object === "boolean" || typeof object === "number" || typeof object === "string") |
| H.throwExpression(P.ArgumentError$value(object, "Expandos are not allowed on strings, numbers, booleans or null", null)); |
| return t1.get(object); |
| } |
| values = H.Primitives_getProperty(object, "expando$values"); |
| return values == null ? null : H.Primitives_getProperty(values, t1); |
| }, |
| $indexSet: function(_, object, value) { |
| var t1, values; |
| t1 = this._jsWeakMapOrKey; |
| if (typeof t1 !== "string") |
| t1.set(object, value); |
| else { |
| 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, t1, value); |
| } |
| } |
| }, |
| Function: { |
| "^": "Object;" |
| }, |
| int: { |
| "^": "num;" |
| }, |
| "+int": 0, |
| Iterable: { |
| "^": "Object;$ti", |
| map$1: function(_, f) { |
| return H.MappedIterable_MappedIterable(this, f, H.getRuntimeTypeArgument(this, "Iterable", 0), null); |
| }, |
| where$1: ["super$Iterable$where", function(_, test) { |
| return new H.WhereIterable(this, test, [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); |
| }, |
| skip$1: function(_, count) { |
| return H.SkipIterable_SkipIterable(this, count, H.getRuntimeTypeArgument(this, "Iterable", 0)); |
| }, |
| skipWhile$1: ["super$Iterable$skipWhile", function(_, test) { |
| return new H.SkipWhileIterable(this, test, [H.getRuntimeTypeArgument(this, "Iterable", 0)]); |
| }], |
| get$first: function(_) { |
| var it = this.get$iterator(this); |
| if (!it.moveNext$0()) |
| throw H.wrapException(H.IterableElementError_noElement()); |
| return it.get$current(); |
| }, |
| 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; |
| }, |
| elementAt$1: function(_, index) { |
| var t1, elementIndex, element; |
| if (typeof index !== "number" || Math.floor(index) !== index) |
| throw H.wrapException(P.ArgumentError$notNull("index")); |
| 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;$ti", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $asList: null |
| }, |
| "+List": 0, |
| Map: { |
| "^": "Object;$ti" |
| }, |
| Null: { |
| "^": "Object;", |
| get$hashCode: function(_) { |
| return P.Object.prototype.get$hashCode.call(this, this); |
| }, |
| 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); |
| }, |
| noSuchMethod$1: function(_, invocation) { |
| throw H.wrapException(P.NoSuchMethodError$(this, invocation.get$memberName(), invocation.get$positionalArguments(), invocation.get$namedArguments(), null)); |
| }, |
| toString: function() { |
| return this.toString$0(this); |
| } |
| }, |
| Match: { |
| "^": "Object;" |
| }, |
| StackTrace: { |
| "^": "Object;" |
| }, |
| _StringStackTrace: { |
| "^": "Object;_stackTrace", |
| toString$0: function(_) { |
| return this._stackTrace; |
| } |
| }, |
| String: { |
| "^": "Object;" |
| }, |
| "+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; |
| }, |
| write$1: function(obj) { |
| this._contents += H.S(obj); |
| }, |
| writeCharCode$1: function(charCode) { |
| this._contents += H.Primitives_stringFromCharCode(charCode); |
| }, |
| 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; |
| } |
| } |
| }, |
| Symbol0: { |
| "^": "Object;" |
| }, |
| Uri_splitQueryString_closure: { |
| "^": "Closure:3;encoding", |
| call$2: function(map, element) { |
| var t1, index, key, value; |
| t1 = J.getInterceptor$asx(element); |
| index = t1.indexOf$1(element, "="); |
| if (index === -1) { |
| if (!t1.$eq(element, "")) |
| J.$indexSet$ax(map, P._Uri__uriDecode(element, 0, t1.get$length(element), this.encoding, true), ""); |
| } else if (index !== 0) { |
| key = t1.substring$2(element, 0, index); |
| value = t1.substring$1(element, index + 1); |
| t1 = this.encoding; |
| J.$indexSet$ax(map, P._Uri__uriDecode(key, 0, key.length, t1, true), P._Uri__uriDecode(value, 0, value.length, t1, true)); |
| } |
| return map; |
| } |
| }, |
| Uri__parseIPv4Address_error: { |
| "^": "Closure:20;host", |
| call$2: function(msg, position) { |
| throw H.wrapException(new P.FormatException("Illegal IPv4 address, " + msg, this.host, position)); |
| } |
| }, |
| Uri_parseIPv6Address_error: { |
| "^": "Closure:21;host", |
| call$2: function(msg, position) { |
| throw H.wrapException(new P.FormatException("Illegal IPv6 address, " + msg, this.host, position)); |
| }, |
| call$1: function(msg) { |
| return this.call$2(msg, null); |
| } |
| }, |
| Uri_parseIPv6Address_parseHex: { |
| "^": "Closure:22;host,error", |
| call$2: function(start, end) { |
| var value, t1; |
| if (J.$sub$n(end, start) > 4) |
| this.error.call$2("an IPv6 part can only contain a maximum of 4 hex digits", start); |
| value = H.Primitives_parseInt(J.substring$2$s(this.host, start, end), 16, null); |
| t1 = J.getInterceptor$n(value); |
| if (t1.$lt(value, 0) || t1.$gt(value, 65535)) |
| this.error.call$2("each part must be in the range of `0x0..0xFFFF`", start); |
| return value; |
| } |
| }, |
| _Uri: { |
| "^": "Object;scheme<,_userInfo,_host,_port,path>,_query,_fragment,_pathSegments,_text,_hashCodeCache,_queryParameters,_queryParameterLists", |
| get$userInfo: function() { |
| return this._userInfo; |
| }, |
| get$host: function(_) { |
| var t1 = this._host; |
| if (t1 == null) |
| return ""; |
| if (C.JSString_methods.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$query: function(_) { |
| var t1 = this._query; |
| return t1 == null ? "" : t1; |
| }, |
| get$fragment: function() { |
| var t1 = this._fragment; |
| return t1 == null ? "" : t1; |
| }, |
| get$pathSegments: function() { |
| var result, pathToSplit, t1; |
| result = this._pathSegments; |
| if (result != null) |
| return result; |
| pathToSplit = this.path; |
| t1 = J.getInterceptor$asx(pathToSplit); |
| if (t1.get$isNotEmpty(pathToSplit) && t1.codeUnitAt$1(pathToSplit, 0) === 47) |
| pathToSplit = t1.substring$1(pathToSplit, 1); |
| t1 = J.getInterceptor(pathToSplit); |
| if (t1.$eq(pathToSplit, "")) |
| result = C.List_empty; |
| else { |
| t1 = t1.split$1(pathToSplit, "/"); |
| result = P.List_List$unmodifiable(new H.MappedListIterable(t1, P.core_Uri_decodeComponent$closure(), [H.getTypeArgumentByIndex(t1, 0), null]), P.String); |
| } |
| this._pathSegments = result; |
| return result; |
| }, |
| get$queryParameters: function() { |
| var t1, t2; |
| t1 = this._queryParameters; |
| if (t1 == null) { |
| t1 = this._query; |
| t2 = P.String; |
| t2 = new P.UnmodifiableMapView(P.Uri_splitQueryString(t1 == null ? "" : t1, C.Utf8Codec_false), [t2, t2]); |
| this._queryParameters = t2; |
| t1 = t2; |
| } |
| return t1; |
| }, |
| _mergePaths$2: function(base, reference) { |
| var t1, backCount, refStart, t2, baseEnd, newEnd, delta, t3; |
| for (t1 = J.getInterceptor$s(reference), backCount = 0, refStart = 0; t1.startsWith$2(reference, "../", refStart);) { |
| refStart += 3; |
| ++backCount; |
| } |
| t2 = J.getInterceptor$asx(base); |
| baseEnd = t2.lastIndexOf$1(base, "/"); |
| while (true) { |
| if (!(baseEnd > 0 && backCount > 0)) |
| break; |
| newEnd = t2.lastIndexOf$2(base, "/", baseEnd - 1); |
| if (newEnd < 0) |
| break; |
| delta = baseEnd - newEnd; |
| t3 = delta !== 2; |
| if (!t3 || delta === 3) |
| if (t2.codeUnitAt$1(base, newEnd + 1) === 46) |
| t3 = !t3 || t2.codeUnitAt$1(base, newEnd + 2) === 46; |
| else |
| t3 = false; |
| else |
| t3 = false; |
| if (t3) |
| break; |
| --backCount; |
| baseEnd = newEnd; |
| } |
| return t2.replaceRange$3(base, baseEnd + 1, null, t1.substring$1(reference, refStart - 3 * backCount)); |
| }, |
| resolve$1: function(reference) { |
| return this.resolveUri$1(P.Uri_parse(reference, 0, null)); |
| }, |
| resolveUri$1: function(reference) { |
| var targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, t1, t2, mergedPath, t3; |
| if (reference.get$scheme().length !== 0) { |
| targetScheme = reference.get$scheme(); |
| if (reference.get$hasAuthority()) { |
| targetUserInfo = reference.get$userInfo(); |
| targetHost = reference.get$host(reference); |
| targetPort = reference.get$hasPort() ? reference.get$port(reference) : null; |
| } else { |
| targetUserInfo = ""; |
| targetHost = null; |
| targetPort = null; |
| } |
| targetPath = P._Uri__removeDotSegments(reference.get$path(reference)); |
| targetQuery = reference.get$hasQuery() ? reference.get$query(reference) : null; |
| } else { |
| targetScheme = this.scheme; |
| if (reference.get$hasAuthority()) { |
| targetUserInfo = reference.get$userInfo(); |
| targetHost = reference.get$host(reference); |
| targetPort = P._Uri__makePort(reference.get$hasPort() ? reference.get$port(reference) : null, targetScheme); |
| targetPath = P._Uri__removeDotSegments(reference.get$path(reference)); |
| targetQuery = reference.get$hasQuery() ? reference.get$query(reference) : null; |
| } else { |
| targetUserInfo = this._userInfo; |
| targetHost = this._host; |
| targetPort = this._port; |
| if (J.$eq$(reference.get$path(reference), "")) { |
| targetPath = this.path; |
| targetQuery = reference.get$hasQuery() ? reference.get$query(reference) : this._query; |
| } else { |
| if (reference.get$hasAbsolutePath()) |
| targetPath = P._Uri__removeDotSegments(reference.get$path(reference)); |
| else { |
| t1 = this.path; |
| t2 = J.getInterceptor$asx(t1); |
| if (t2.get$isEmpty(t1) === true) |
| if (targetHost == null) |
| targetPath = targetScheme.length === 0 ? reference.get$path(reference) : P._Uri__removeDotSegments(reference.get$path(reference)); |
| else |
| targetPath = P._Uri__removeDotSegments(C.JSString_methods.$add("/", reference.get$path(reference))); |
| else { |
| mergedPath = this._mergePaths$2(t1, reference.get$path(reference)); |
| t3 = targetScheme.length === 0; |
| if (!t3 || targetHost != null || t2.startsWith$1(t1, "/")) |
| targetPath = P._Uri__removeDotSegments(mergedPath); |
| else |
| targetPath = P._Uri__normalizeRelativePath(mergedPath, !t3 || targetHost != null); |
| } |
| } |
| targetQuery = reference.get$hasQuery() ? reference.get$query(reference) : null; |
| } |
| } |
| } |
| return new P._Uri(targetScheme, targetUserInfo, targetHost, targetPort, targetPath, targetQuery, reference.get$hasFragment() ? reference.get$fragment() : null, null, null, null, null, null); |
| }, |
| get$hasAuthority: function() { |
| return this._host != null; |
| }, |
| get$hasPort: function() { |
| return this._port != null; |
| }, |
| get$hasQuery: function() { |
| return this._query != null; |
| }, |
| get$hasFragment: function() { |
| return this._fragment != null; |
| }, |
| get$hasAbsolutePath: function() { |
| return J.startsWith$1$s(this.path, "/"); |
| }, |
| get$origin: function(_) { |
| var t1, t2, t3; |
| t1 = this.scheme; |
| if (t1 === "") |
| throw H.wrapException(new P.StateError("Cannot use origin without a scheme: " + this.toString$0(0))); |
| if (t1 !== "http" && t1 !== "https") |
| throw H.wrapException(new P.StateError("Origin is only applicable schemes http and https: " + this.toString$0(0))); |
| t2 = this._host; |
| if (t2 == null || t2 === "") |
| throw H.wrapException(new P.StateError("A " + H.S(t1) + ": URI should have a non-empty host name: " + this.toString$0(0))); |
| t3 = this._port; |
| if (t3 == null) |
| return H.S(t1) + "://" + H.S(t2); |
| return H.S(t1) + "://" + H.S(t2) + ":" + H.S(t3); |
| }, |
| toFilePath$1$windows: function(windows) { |
| var t1, pathSegments; |
| t1 = this.scheme; |
| if (t1 !== "" && t1 !== "file") |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a " + H.S(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")); |
| windows = $.$get$_Uri__isWindowsCached(); |
| if (windows === true) |
| t1 = P._Uri__toWindowsFilePath(this); |
| else { |
| if (this._host != null && this.get$host(this) !== "") |
| H.throwExpression(new P.UnsupportedError("Cannot extract a non-Windows file path from a file URI with an authority")); |
| pathSegments = this.get$pathSegments(); |
| P._Uri__checkNonWindowsPathReservedCharacters(pathSegments, false); |
| t1 = P.StringBuffer__writeAll(J.startsWith$1$s(this.path, "/") ? "/" : "", pathSegments, "/"); |
| t1 = t1.charCodeAt(0) == 0 ? t1 : t1; |
| } |
| return t1; |
| }, |
| toFilePath$0: function() { |
| return this.toFilePath$1$windows(null); |
| }, |
| get$data: function(_) { |
| return this.scheme === "data" ? P.UriData_UriData$fromUri(this) : null; |
| }, |
| toString$0: function(_) { |
| var t1 = this._text; |
| if (t1 == null) { |
| t1 = this._initializeText$0(); |
| this._text = t1; |
| } |
| return t1; |
| }, |
| _initializeText$0: function() { |
| var t1, t2, t3, t4; |
| t1 = this.scheme; |
| t2 = t1.length !== 0 ? H.S(t1) + ":" : ""; |
| t3 = this._host; |
| t4 = t3 == null; |
| if (!t4 || t1 === "file") { |
| t1 = t2 + "//"; |
| t2 = this._userInfo; |
| if (t2.length !== 0) |
| t1 = t1 + H.S(t2) + "@"; |
| if (!t4) |
| t1 += t3; |
| t2 = this._port; |
| if (t2 != null) |
| t1 = t1 + ":" + H.S(t2); |
| } else |
| t1 = t2; |
| t1 += H.S(this.path); |
| t2 = this._query; |
| if (t2 != null) |
| t1 = t1 + "?" + t2; |
| t2 = this._fragment; |
| if (t2 != null) |
| t1 = t1 + "#" + t2; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| $eq: function(_, other) { |
| var t1, t2, t3; |
| if (other == null) |
| return false; |
| if (this === other) |
| return true; |
| t1 = J.getInterceptor(other); |
| if (!!t1.$isUri) { |
| t2 = this.scheme; |
| t3 = other.get$scheme(); |
| if (t2 == null ? t3 == null : t2 === t3) |
| if (this._host != null === other.get$hasAuthority()) { |
| t2 = this._userInfo; |
| t3 = other.get$userInfo(); |
| if (t2 == null ? t3 == null : t2 === t3) { |
| t2 = this.get$host(this); |
| t3 = t1.get$host(other); |
| if (t2 == null ? t3 == null : t2 === t3) |
| if (J.$eq$(this.get$port(this), t1.get$port(other))) |
| if (J.$eq$(this.path, t1.get$path(other))) { |
| t2 = this._query; |
| t3 = t2 == null; |
| if (!t3 === other.get$hasQuery()) { |
| if (t3) |
| t2 = ""; |
| if (t2 === t1.get$query(other)) { |
| t1 = this._fragment; |
| t2 = t1 == null; |
| if (!t2 === other.get$hasFragment()) { |
| if (t2) |
| t1 = ""; |
| t1 = t1 === other.get$fragment(); |
| } 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; |
| } |
| return false; |
| }, |
| get$hashCode: function(_) { |
| var t1 = this._hashCodeCache; |
| if (t1 == null) { |
| t1 = this._text; |
| if (t1 == null) { |
| t1 = this._initializeText$0(); |
| this._text = t1; |
| } |
| t1 = C.JSString_methods.get$hashCode(t1); |
| this._hashCodeCache = t1; |
| } |
| return t1; |
| }, |
| $isUri: 1, |
| static: { |
| _Uri__Uri$notSimple: function(uri, start, end, schemeEnd, hostStart, portStart, pathStart, queryStart, fragmentStart, scheme) { |
| var userInfoStart, userInfo, host, t1, t2, port, path, query; |
| if (scheme == null) |
| if (J.$gt$n(schemeEnd, start)) |
| scheme = P._Uri__makeScheme(uri, start, schemeEnd); |
| else { |
| if (schemeEnd === start) |
| P._Uri__fail(uri, start, "Invalid empty scheme"); |
| scheme = ""; |
| } |
| if (hostStart > start) { |
| userInfoStart = J.$add$ns(schemeEnd, 3); |
| userInfo = userInfoStart < hostStart ? P._Uri__makeUserInfo(uri, userInfoStart, hostStart - 1) : ""; |
| host = P._Uri__makeHost(uri, hostStart, portStart, false); |
| t1 = J.getInterceptor$ns(portStart); |
| t2 = t1.$add(portStart, 1); |
| if (typeof pathStart !== "number") |
| return H.iae(pathStart); |
| port = t2 < pathStart ? P._Uri__makePort(H.Primitives_parseInt(J.substring$2$s(uri, t1.$add(portStart, 1), pathStart), null, new P.closure(uri, portStart)), scheme) : null; |
| } else { |
| userInfo = ""; |
| host = null; |
| port = null; |
| } |
| path = P._Uri__makePath(uri, pathStart, queryStart, null, scheme, host != null); |
| t1 = J.getInterceptor$n(queryStart); |
| query = t1.$lt(queryStart, fragmentStart) ? P._Uri__makeQuery(uri, t1.$add(queryStart, 1), fragmentStart, null) : null; |
| t1 = J.getInterceptor$n(fragmentStart); |
| return new P._Uri(scheme, userInfo, host, port, path, query, t1.$lt(fragmentStart, end) ? P._Uri__makeFragment(uri, t1.$add(fragmentStart, 1), end) : null, null, null, null, null, null); |
| }, |
| _Uri__Uri: function(fragment, host, path, pathSegments, port, query, queryParameters, scheme, userInfo) { |
| var isFile, t1, hasAuthority, t2; |
| scheme = P._Uri__makeScheme(scheme, 0, scheme == null ? 0 : scheme.length); |
| userInfo = P._Uri__makeUserInfo(userInfo, 0, 0); |
| host = P._Uri__makeHost(host, 0, host == null ? 0 : J.get$length$asx(host), false); |
| query = P._Uri__makeQuery(query, 0, 0, queryParameters); |
| fragment = P._Uri__makeFragment(fragment, 0, 0); |
| port = P._Uri__makePort(port, scheme); |
| isFile = scheme === "file"; |
| if (host == null) |
| t1 = userInfo.length !== 0 || port != null || isFile; |
| else |
| t1 = false; |
| if (t1) |
| host = ""; |
| t1 = host == null; |
| hasAuthority = !t1; |
| path = P._Uri__makePath(path, 0, path == null ? 0 : path.length, pathSegments, scheme, hasAuthority); |
| t2 = scheme.length === 0; |
| if (t2 && t1 && !J.startsWith$1$s(path, "/")) |
| path = P._Uri__normalizeRelativePath(path, !t2 || hasAuthority); |
| else |
| path = P._Uri__removeDotSegments(path); |
| return new P._Uri(scheme, userInfo, t1 && J.startsWith$1$s(path, "//") ? "" : host, port, path, query, fragment, null, null, null, null, null); |
| }, |
| _Uri__defaultPort: function(scheme) { |
| if (scheme === "http") |
| return 80; |
| if (scheme === "https") |
| return 443; |
| return 0; |
| }, |
| _Uri__fail: function(uri, index, message) { |
| throw H.wrapException(new P.FormatException(message, uri, index)); |
| }, |
| _Uri__Uri$file: function(path, windows) { |
| return windows ? P._Uri__makeWindowsFileUrl(path, false) : P._Uri__makeFileUri(path, false); |
| }, |
| _Uri__checkNonWindowsPathReservedCharacters: function(segments, argumentError) { |
| C.JSArray_methods.forEach$1(segments, new P._Uri__checkNonWindowsPathReservedCharacters_closure(false)); |
| }, |
| _Uri__checkWindowsPathReservedCharacters: function(segments, argumentError, firstSegment) { |
| var t1, segment; |
| for (t1 = H.SubListIterable$(segments, firstSegment, null, H.getTypeArgumentByIndex(segments, 0)), t1 = new H.ListIterator(t1, t1.get$length(t1), 0, null); t1.moveNext$0();) { |
| segment = t1.__internal$_current; |
| if (J.contains$1$asx(segment, P.RegExp_RegExp('["*/:<>?\\\\|]', true, false)) === true) |
| if (argumentError) |
| throw H.wrapException(P.ArgumentError$("Illegal character in path")); |
| else |
| throw H.wrapException(new P.UnsupportedError("Illegal character in path: " + H.S(segment))); |
| } |
| }, |
| _Uri__checkWindowsDriveLetter: function(charCode, argumentError) { |
| var t1; |
| if (!(65 <= charCode && charCode <= 90)) |
| t1 = 97 <= charCode && charCode <= 122; |
| else |
| t1 = true; |
| if (t1) |
| return; |
| if (argumentError) |
| throw H.wrapException(P.ArgumentError$("Illegal drive letter " + P.String_String$fromCharCode(charCode))); |
| else |
| throw H.wrapException(new P.UnsupportedError("Illegal drive letter " + P.String_String$fromCharCode(charCode))); |
| }, |
| _Uri__makeFileUri: function(path, slashTerminated) { |
| var t1, segments; |
| t1 = J.getInterceptor$s(path); |
| segments = t1.split$1(path, "/"); |
| if (t1.startsWith$1(path, "/")) |
| return P._Uri__Uri(null, null, null, segments, null, null, null, "file", null); |
| else |
| return P._Uri__Uri(null, null, null, segments, null, null, null, null, null); |
| }, |
| _Uri__makeWindowsFileUrl: function(path, slashTerminated) { |
| var t1, pathSegments, pathStart, hostPart; |
| t1 = J.getInterceptor$s(path); |
| if (t1.startsWith$1(path, "\\\\?\\")) |
| if (t1.startsWith$2(path, "UNC\\", 4)) |
| path = t1.replaceRange$3(path, 0, 7, "\\"); |
| else { |
| path = t1.substring$1(path, 4); |
| if (path.length < 3 || C.JSString_methods._codeUnitAt$1(path, 1) !== 58 || C.JSString_methods._codeUnitAt$1(path, 2) !== 92) |
| throw H.wrapException(P.ArgumentError$("Windows paths with \\\\?\\ prefix must be absolute")); |
| } |
| else |
| path = t1.replaceAll$2(path, "/", "\\"); |
| t1 = path.length; |
| if (t1 > 1 && C.JSString_methods._codeUnitAt$1(path, 1) === 58) { |
| P._Uri__checkWindowsDriveLetter(C.JSString_methods._codeUnitAt$1(path, 0), true); |
| if (t1 === 2 || C.JSString_methods._codeUnitAt$1(path, 2) !== 92) |
| throw H.wrapException(P.ArgumentError$("Windows paths with drive letter must be absolute")); |
| pathSegments = H.setRuntimeTypeInfo(path.split("\\"), [P.String]); |
| P._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 1); |
| return P._Uri__Uri(null, null, null, pathSegments, null, null, null, "file", null); |
| } |
| if (C.JSString_methods.startsWith$1(path, "\\")) |
| if (C.JSString_methods.startsWith$2(path, "\\", 1)) { |
| pathStart = C.JSString_methods.indexOf$2(path, "\\", 2); |
| t1 = pathStart < 0; |
| hostPart = t1 ? C.JSString_methods.substring$1(path, 2) : C.JSString_methods.substring$2(path, 2, pathStart); |
| pathSegments = H.setRuntimeTypeInfo((t1 ? "" : C.JSString_methods.substring$1(path, pathStart + 1)).split("\\"), [P.String]); |
| P._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); |
| return P._Uri__Uri(null, hostPart, null, pathSegments, null, null, null, "file", null); |
| } else { |
| pathSegments = H.setRuntimeTypeInfo(path.split("\\"), [P.String]); |
| P._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); |
| return P._Uri__Uri(null, null, null, pathSegments, null, null, null, "file", null); |
| } |
| else { |
| pathSegments = H.setRuntimeTypeInfo(path.split("\\"), [P.String]); |
| P._Uri__checkWindowsPathReservedCharacters(pathSegments, true, 0); |
| return P._Uri__Uri(null, null, null, pathSegments, null, null, null, null, null); |
| } |
| }, |
| _Uri__makePort: function(port, scheme) { |
| if (port != null && J.$eq$(port, P._Uri__defaultPort(scheme))) |
| return; |
| return port; |
| }, |
| _Uri__makeHost: function(host, start, end, strictIPv6) { |
| var t1, t2, i; |
| if (host == null) |
| return; |
| if (start === end) |
| return ""; |
| t1 = J.getInterceptor$s(host); |
| if (t1.codeUnitAt$1(host, start) === 91) { |
| t2 = J.getInterceptor$n(end); |
| if (t1.codeUnitAt$1(host, t2.$sub(end, 1)) !== 93) |
| P._Uri__fail(host, start, "Missing end `]` to match `[` in host"); |
| P.Uri_parseIPv6Address(host, start + 1, t2.$sub(end, 1)); |
| return t1.substring$2(host, start, end).toLowerCase(); |
| } |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| for (; i < end; ++i) |
| if (t1.codeUnitAt$1(host, i) === 58) { |
| P.Uri_parseIPv6Address(host, start, end); |
| return "[" + H.S(host) + "]"; |
| } |
| return P._Uri__normalizeRegName(host, start, end); |
| }, |
| _Uri__normalizeRegName: function(host, start, end) { |
| var t1, index, sectionStart, buffer, isNormalized, char, replacement, t2, slice, sourceLength, tail; |
| if (typeof end !== "number") |
| return H.iae(end); |
| t1 = J.getInterceptor$s(host); |
| index = start; |
| sectionStart = index; |
| buffer = null; |
| isNormalized = true; |
| for (; index < end;) { |
| char = t1.codeUnitAt$1(host, index); |
| if (char === 37) { |
| replacement = P._Uri__normalizeEscape(host, index, true); |
| t2 = replacement == null; |
| if (t2 && isNormalized) { |
| index += 3; |
| continue; |
| } |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| slice = t1.substring$2(host, sectionStart, index); |
| buffer._contents += !isNormalized ? slice.toLowerCase() : slice; |
| if (t2) { |
| replacement = t1.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) { |
| t2 = char >>> 4; |
| if (t2 >= 8) |
| return H.ioore(C.List_qNA, t2); |
| t2 = (C.List_qNA[t2] & 1 << (char & 15)) !== 0; |
| } else |
| t2 = false; |
| if (t2) { |
| if (isNormalized && 65 <= char && 90 >= char) { |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| if (sectionStart < index) { |
| buffer._contents += t1.substring$2(host, sectionStart, index); |
| sectionStart = index; |
| } |
| isNormalized = false; |
| } |
| ++index; |
| } else { |
| if (char <= 93) { |
| t2 = char >>> 4; |
| if (t2 >= 8) |
| return H.ioore(C.List_2Vk, t2); |
| t2 = (C.List_2Vk[t2] & 1 << (char & 15)) !== 0; |
| } else |
| t2 = false; |
| if (t2) |
| P._Uri__fail(host, index, "Invalid character"); |
| else { |
| if ((char & 64512) === 55296 && index + 1 < end) { |
| tail = t1.codeUnitAt$1(host, index + 1); |
| if ((tail & 64512) === 56320) { |
| char = 65536 | (char & 1023) << 10 | tail & 1023; |
| sourceLength = 2; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| slice = t1.substring$2(host, sectionStart, index); |
| buffer._contents += !isNormalized ? slice.toLowerCase() : slice; |
| buffer._contents += P._Uri__escapeChar(char); |
| index += sourceLength; |
| sectionStart = index; |
| } |
| } |
| } |
| } |
| if (buffer == null) |
| return t1.substring$2(host, start, end); |
| if (sectionStart < end) { |
| slice = t1.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 t1, i, containsUpperCase, codeUnit, t2; |
| if (start === end) |
| return ""; |
| t1 = J.getInterceptor$s(scheme); |
| if (!P._Uri__isAlphabeticCharacter(t1.codeUnitAt$1(scheme, start))) |
| P._Uri__fail(scheme, start, "Scheme not starting with alphabetic character"); |
| if (typeof end !== "number") |
| return H.iae(end); |
| i = start; |
| containsUpperCase = false; |
| for (; i < end; ++i) { |
| codeUnit = t1.codeUnitAt$1(scheme, i); |
| if (codeUnit < 128) { |
| t2 = codeUnit >>> 4; |
| if (t2 >= 8) |
| return H.ioore(C.List_JYB, t2); |
| t2 = (C.List_JYB[t2] & 1 << (codeUnit & 15)) !== 0; |
| } else |
| t2 = false; |
| if (!t2) |
| P._Uri__fail(scheme, i, "Illegal scheme character"); |
| if (65 <= codeUnit && codeUnit <= 90) |
| containsUpperCase = true; |
| } |
| scheme = t1.substring$2(scheme, start, end); |
| return P._Uri__canonicalizeScheme(containsUpperCase ? scheme.toLowerCase() : scheme); |
| }, |
| _Uri__canonicalizeScheme: function(scheme) { |
| if (scheme === "http") |
| return "http"; |
| if (scheme === "file") |
| return "file"; |
| if (scheme === "https") |
| return "https"; |
| if (scheme === "package") |
| return "package"; |
| return scheme; |
| }, |
| _Uri__makeUserInfo: function(userInfo, start, end) { |
| var t1; |
| if (userInfo == null) |
| return ""; |
| t1 = P._Uri__normalize(userInfo, start, end, C.List_gRj, false); |
| return t1 == null ? J.substring$2$s(userInfo, start, end) : t1; |
| }, |
| _Uri__makePath: function(path, start, end, pathSegments, scheme, hasAuthority) { |
| var isFile, ensureLeadingSlash, t1, result; |
| isFile = scheme === "file"; |
| ensureLeadingSlash = isFile || hasAuthority; |
| t1 = path == null; |
| if (t1 && pathSegments == null) |
| return isFile ? "/" : ""; |
| t1 = !t1; |
| if (t1 && pathSegments != null) |
| throw H.wrapException(P.ArgumentError$("Both path and pathSegments specified")); |
| if (t1) { |
| result = P._Uri__normalize(path, start, end, C.List_qg4, false); |
| if (result == null) |
| result = J.substring$2$s(path, start, end); |
| } else { |
| pathSegments.toString; |
| result = new H.MappedListIterable(pathSegments, new P._Uri__makePath_closure(), [H.getTypeArgumentByIndex(pathSegments, 0), null]).join$1(0, "/"); |
| } |
| 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) { |
| var t1 = scheme.length === 0; |
| if (t1 && !hasAuthority && !C.JSString_methods.startsWith$1(path, "/")) |
| return P._Uri__normalizeRelativePath(path, !t1 || hasAuthority); |
| return P._Uri__removeDotSegments(path); |
| }, |
| _Uri__makeQuery: function(query, start, end, queryParameters) { |
| var t1; |
| if (query != null) { |
| t1 = P._Uri__normalize(query, start, end, C.List_CVk, false); |
| return t1 == null ? J.substring$2$s(query, start, end) : t1; |
| } |
| return; |
| }, |
| _Uri__makeFragment: function(fragment, start, end) { |
| var t1; |
| if (fragment == null) |
| return; |
| t1 = P._Uri__normalize(fragment, start, end, C.List_CVk, false); |
| return t1 == null ? J.substring$2$s(fragment, start, end) : t1; |
| }, |
| _Uri__normalizeEscape: function(source, index, lowerCase) { |
| var t1, t2, t3, t4, firstDigit, secondDigit, firstDigitValue, secondDigitValue, value; |
| t1 = J.getInterceptor$ns(index); |
| t2 = t1.$add(index, 2); |
| t3 = J.getInterceptor$asx(source); |
| t4 = t3.get$length(source); |
| if (typeof t4 !== "number") |
| return H.iae(t4); |
| if (t2 >= t4) |
| return "%"; |
| firstDigit = t3.codeUnitAt$1(source, t1.$add(index, 1)); |
| secondDigit = t3.codeUnitAt$1(source, t1.$add(index, 2)); |
| firstDigitValue = H.hexDigitValue(firstDigit); |
| secondDigitValue = H.hexDigitValue(secondDigit); |
| if (firstDigitValue < 0 || secondDigitValue < 0) |
| return "%"; |
| value = firstDigitValue * 16 + secondDigitValue; |
| if (value < 127) { |
| t2 = C.JSInt_methods._shrOtherPositive$1(value, 4); |
| if (t2 >= 8) |
| return H.ioore(C.List_nxB, t2); |
| t2 = (C.List_nxB[t2] & 1 << (value & 15)) !== 0; |
| } else |
| t2 = false; |
| if (t2) |
| return H.Primitives_stringFromCharCode(lowerCase && 65 <= value && 90 >= value ? (value | 32) >>> 0 : value); |
| if (firstDigit >= 97 || secondDigit >= 97) |
| return t3.substring$2(source, index, t1.$add(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, escapeDelimiters) { |
| var t1, t2, index, sectionStart, buffer, t3, char, t4, replacement, sourceLength, tail; |
| for (t1 = J.getInterceptor$s(component), t2 = !escapeDelimiters, index = start, sectionStart = index, buffer = null; t3 = J.getInterceptor$n(index), t3.$lt(index, end);) { |
| char = t1.codeUnitAt$1(component, index); |
| if (char < 127) { |
| t4 = char >>> 4; |
| if (t4 >= 8) |
| return H.ioore(charTable, t4); |
| t4 = (charTable[t4] & 1 << (char & 15)) !== 0; |
| } else |
| t4 = false; |
| if (t4) |
| index = t3.$add(index, 1); |
| else { |
| if (char === 37) { |
| replacement = P._Uri__normalizeEscape(component, index, false); |
| if (replacement == null) { |
| index = t3.$add(index, 3); |
| continue; |
| } |
| if ("%" === replacement) { |
| replacement = "%25"; |
| sourceLength = 1; |
| } else |
| sourceLength = 3; |
| } else { |
| if (t2) |
| if (char <= 93) { |
| t4 = char >>> 4; |
| if (t4 >= 8) |
| return H.ioore(C.List_2Vk, t4); |
| t4 = (C.List_2Vk[t4] & 1 << (char & 15)) !== 0; |
| } else |
| t4 = false; |
| else |
| t4 = false; |
| if (t4) { |
| P._Uri__fail(component, index, "Invalid character"); |
| replacement = null; |
| sourceLength = null; |
| } else { |
| if ((char & 64512) === 55296) { |
| t4 = t3.$add(index, 1); |
| if (typeof end !== "number") |
| return H.iae(end); |
| if (t4 < end) { |
| tail = t1.codeUnitAt$1(component, t3.$add(index, 1)); |
| if ((tail & 64512) === 56320) { |
| char = 65536 | (char & 1023) << 10 | tail & 1023; |
| sourceLength = 2; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| } else |
| sourceLength = 1; |
| replacement = P._Uri__escapeChar(char); |
| } |
| } |
| if (buffer == null) |
| buffer = new P.StringBuffer(""); |
| buffer._contents += t1.substring$2(component, sectionStart, index); |
| buffer._contents += H.S(replacement); |
| index = t3.$add(index, sourceLength); |
| sectionStart = index; |
| } |
| } |
| if (buffer == null) |
| return; |
| if (J.$lt$n(sectionStart, end)) |
| buffer._contents += t1.substring$2(component, sectionStart, end); |
| t1 = buffer._contents; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _Uri__mayContainDotSegments: function(path) { |
| var t1 = J.getInterceptor$s(path); |
| if (t1.startsWith$1(path, ".")) |
| return true; |
| return t1.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 = J.split$1$s(path, "/"), 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, allowScheme) { |
| var output, t1, t2, appendSlash, _i, segment; |
| if (!P._Uri__mayContainDotSegments(path)) |
| return !allowScheme ? P._Uri__escapeScheme(path) : path; |
| output = []; |
| for (t1 = J.split$1$s(path, "/"), 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(""); |
| if (!allowScheme) { |
| if (0 >= output.length) |
| return H.ioore(output, 0); |
| t1 = P._Uri__escapeScheme(output[0]); |
| if (0 >= output.length) |
| return H.ioore(output, 0); |
| output[0] = t1; |
| } |
| return C.JSArray_methods.join$1(output, "/"); |
| }, |
| _Uri__escapeScheme: function(path) { |
| var t1, i, t2, char; |
| t1 = J.getInterceptor$asx(path); |
| if (J.$ge$n(t1.get$length(path), 2) && P._Uri__isAlphabeticCharacter(t1.codeUnitAt$1(path, 0))) { |
| i = 1; |
| while (true) { |
| t2 = t1.get$length(path); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| char = t1.codeUnitAt$1(path, i); |
| if (char === 58) |
| return t1.substring$2(path, 0, i) + "%3A" + t1.substring$1(path, i + 1); |
| if (char <= 127) { |
| t2 = char >>> 4; |
| if (t2 >= 8) |
| return H.ioore(C.List_JYB, t2); |
| t2 = (C.List_JYB[t2] & 1 << (char & 15)) === 0; |
| } else |
| t2 = true; |
| if (t2) |
| break; |
| ++i; |
| } |
| } |
| return path; |
| }, |
| _Uri__toWindowsFilePath: function(uri) { |
| var segments, t1, hasDriveLetter, t2, host; |
| segments = uri.get$pathSegments(); |
| t1 = segments.length; |
| if (t1 > 0 && J.get$length$asx(segments[0]) === 2 && J.codeUnitAt$1$s(segments[0], 1) === 58) { |
| if (0 >= t1) |
| return H.ioore(segments, 0); |
| P._Uri__checkWindowsDriveLetter(J.codeUnitAt$1$s(segments[0], 0), false); |
| P._Uri__checkWindowsPathReservedCharacters(segments, false, 1); |
| hasDriveLetter = true; |
| } else { |
| P._Uri__checkWindowsPathReservedCharacters(segments, false, 0); |
| hasDriveLetter = false; |
| } |
| t2 = uri.get$hasAbsolutePath() && !hasDriveLetter ? "\\" : ""; |
| if (uri.get$hasAuthority()) { |
| host = uri.get$host(uri); |
| if (host.length !== 0) |
| t2 = t2 + "\\" + H.S(host) + "\\"; |
| } |
| t2 = P.StringBuffer__writeAll(t2, segments, "\\"); |
| t1 = hasDriveLetter && t1 === 1 ? t2 + "\\" : t2; |
| return t1.charCodeAt(0) == 0 ? t1 : t1; |
| }, |
| _Uri__uriEncode: function(canonicalTable, text, encoding, spaceToPlus) { |
| var bytes, t1, i, t2, byte, t3; |
| if (encoding === C.Utf8Codec_false && $.$get$_Uri__needsNoEncoding()._nativeRegExp.test(H.checkString(text))) |
| return text; |
| bytes = encoding.get$encoder().convert$1(text); |
| for (t1 = bytes.length, i = 0, t2 = ""; i < t1; ++i) { |
| byte = bytes[i]; |
| if (byte < 128) { |
| t3 = byte >>> 4; |
| if (t3 >= 8) |
| return H.ioore(canonicalTable, t3); |
| t3 = (canonicalTable[t3] & 1 << (byte & 15)) !== 0; |
| } else |
| t3 = false; |
| if (t3) |
| t2 += H.Primitives_stringFromCharCode(byte); |
| else |
| t2 = spaceToPlus && byte === 32 ? t2 + "+" : t2 + "%" + "0123456789ABCDEF"[byte >>> 4 & 15] + "0123456789ABCDEF"[byte & 15]; |
| } |
| return t2.charCodeAt(0) == 0 ? t2 : t2; |
| }, |
| _Uri__hexCharPairToByte: function(s, pos) { |
| var t1, byte, i, charCode; |
| for (t1 = J.getInterceptor$s(s), byte = 0, i = 0; i < 2; ++i) { |
| charCode = t1.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, start, end, encoding, plusToSpace) { |
| var t1, i, simple, codeUnit, t2, bytes; |
| if (typeof end !== "number") |
| return H.iae(end); |
| t1 = J.getInterceptor$asx(text); |
| i = start; |
| while (true) { |
| if (!(i < end)) { |
| simple = true; |
| break; |
| } |
| codeUnit = t1.codeUnitAt$1(text, i); |
| if (codeUnit <= 127) |
| if (codeUnit !== 37) |
| t2 = plusToSpace && codeUnit === 43; |
| else |
| t2 = true; |
| else |
| t2 = true; |
| if (t2) { |
| simple = false; |
| break; |
| } |
| ++i; |
| } |
| if (simple) { |
| if (C.Utf8Codec_false !== encoding) |
| t2 = false; |
| else |
| t2 = true; |
| if (t2) |
| return t1.substring$2(text, start, end); |
| else |
| bytes = new H.CodeUnits(t1.substring$2(text, start, end)); |
| } else { |
| bytes = []; |
| for (i = start; i < end; ++i) { |
| codeUnit = t1.codeUnitAt$1(text, i); |
| if (codeUnit > 127) |
| throw H.wrapException(P.ArgumentError$("Illegal percent encoding in URI")); |
| if (codeUnit === 37) { |
| t2 = t1.get$length(text); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (i + 3 > t2) |
| 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); |
| } |
| } |
| return new P.Utf8Decoder(false).convert$1(bytes); |
| }, |
| _Uri__isAlphabeticCharacter: function(codeUnit) { |
| var lowerCase = codeUnit | 32; |
| return 97 <= lowerCase && lowerCase <= 122; |
| } |
| } |
| }, |
| closure: { |
| "^": "Closure:0;uri,portStart", |
| call$1: function(_) { |
| throw H.wrapException(new P.FormatException("Invalid port", this.uri, J.$add$ns(this.portStart, 1))); |
| } |
| }, |
| _Uri__checkNonWindowsPathReservedCharacters_closure: { |
| "^": "Closure:0;argumentError", |
| call$1: function(segment) { |
| if (J.contains$1$asx(segment, "/") === true) |
| if (this.argumentError) |
| 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__makePath_closure: { |
| "^": "Closure:0;", |
| call$1: [function(s) { |
| return P._Uri__uriEncode(C.List_qg40, s, C.Utf8Codec_false, false); |
| }, null, null, 2, 0, null, 29, "call"] |
| }, |
| UriData: { |
| "^": "Object;_text,_separatorIndices,_uriCache", |
| get$uri: function() { |
| var t1, t2, t3, queryIndex, end, t4, query, path; |
| t1 = this._uriCache; |
| if (t1 != null) |
| return t1; |
| t1 = this._separatorIndices; |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t2 = this._text; |
| t1 = t1[0] + 1; |
| t3 = J.getInterceptor$asx(t2); |
| queryIndex = t3.indexOf$2(t2, "?", t1); |
| end = t3.get$length(t2); |
| if (queryIndex >= 0) { |
| t4 = queryIndex + 1; |
| query = P._Uri__normalize(t2, t4, end, C.List_CVk, false); |
| if (query == null) |
| query = t3.substring$2(t2, t4, end); |
| end = queryIndex; |
| } else |
| query = null; |
| path = P._Uri__normalize(t2, t1, end, C.List_qg4, false); |
| t1 = new P._DataUri(this, "data", null, null, null, path == null ? t3.substring$2(t2, t1, end) : path, query, null, null, null, null, null, null); |
| this._uriCache = t1; |
| return t1; |
| }, |
| toString$0: function(_) { |
| var t1, t2; |
| t1 = this._separatorIndices; |
| if (0 >= t1.length) |
| return H.ioore(t1, 0); |
| t2 = this._text; |
| return t1[0] === -1 ? "data:" + H.S(t2) : t2; |
| }, |
| static: { |
| UriData_UriData$fromUri: function(uri) { |
| var t1; |
| if (uri.scheme !== "data") |
| throw H.wrapException(P.ArgumentError$value(uri, "uri", "Scheme must be 'data'")); |
| if (uri._host != null) |
| throw H.wrapException(P.ArgumentError$value(uri, "uri", "Data uri must not have authority")); |
| if (uri._fragment != null) |
| throw H.wrapException(P.ArgumentError$value(uri, "uri", "Data uri must not have a fragment part")); |
| if (uri._query == null) |
| return P.UriData__parse(uri.path, 0, uri); |
| t1 = uri._text; |
| if (t1 == null) { |
| t1 = uri._initializeText$0(); |
| uri._text = t1; |
| } |
| return P.UriData__parse(t1, 5, uri); |
| }, |
| UriData__writeUri: function(mimeType, charsetName, parameters, buffer, indices) { |
| var slashIndex, t1; |
| if (true) |
| buffer._contents = buffer._contents; |
| else { |
| slashIndex = P.UriData__validateMimeType(""); |
| if (slashIndex < 0) |
| throw H.wrapException(P.ArgumentError$value("", "mimeType", "Invalid MIME type")); |
| t1 = buffer._contents += H.S(P._Uri__uriEncode(C.List_qFt, C.JSString_methods.substring$2("", 0, slashIndex), C.Utf8Codec_false, false)); |
| buffer._contents = t1 + "/"; |
| buffer._contents += H.S(P._Uri__uriEncode(C.List_qFt, C.JSString_methods.substring$1("", slashIndex + 1), C.Utf8Codec_false, false)); |
| } |
| }, |
| UriData__validateMimeType: function(mimeType) { |
| var t1, slashIndex, i; |
| for (t1 = mimeType.length, slashIndex = -1, i = 0; i < t1; ++i) { |
| if (C.JSString_methods._codeUnitAt$1(mimeType, i) !== 47) |
| continue; |
| if (slashIndex < 0) { |
| slashIndex = i; |
| continue; |
| } |
| return -1; |
| } |
| return slashIndex; |
| }, |
| UriData__parse: function(text, start, sourceUri) { |
| var indices, t1, i, slashIndex, char, t2, equalsIndex, lastSeparator, data; |
| indices = [start - 1]; |
| t1 = J.getInterceptor$asx(text); |
| i = start; |
| slashIndex = -1; |
| char = null; |
| while (true) { |
| t2 = t1.get$length(text); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| c$0: { |
| char = t1.codeUnitAt$1(text, i); |
| if (char === 44 || char === 59) |
| break; |
| if (char === 47) { |
| if (slashIndex < 0) { |
| slashIndex = i; |
| break c$0; |
| } |
| throw H.wrapException(new P.FormatException("Invalid MIME type", text, i)); |
| } |
| } |
| ++i; |
| } |
| if (slashIndex < 0 && i > start) |
| throw H.wrapException(new P.FormatException("Invalid MIME type", text, i)); |
| for (; char !== 44;) { |
| indices.push(i); |
| ++i; |
| equalsIndex = -1; |
| while (true) { |
| t2 = t1.get$length(text); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| char = t1.codeUnitAt$1(text, i); |
| if (char === 61) { |
| if (equalsIndex < 0) |
| equalsIndex = i; |
| } else if (char === 59 || char === 44) |
| break; |
| ++i; |
| } |
| if (equalsIndex >= 0) |
| indices.push(equalsIndex); |
| else { |
| lastSeparator = C.JSArray_methods.get$last(indices); |
| if (char !== 44 || i !== lastSeparator + 7 || !t1.startsWith$2(text, "base64", lastSeparator + 1)) |
| throw H.wrapException(new P.FormatException("Expecting '='", text, i)); |
| break; |
| } |
| } |
| indices.push(i); |
| t2 = i + 1; |
| if ((indices.length & 1) === 1) |
| text = C.Base64Codec_Base64Encoder_false.normalize$3(text, t2, t1.get$length(text)); |
| else { |
| data = P._Uri__normalize(text, t2, t1.get$length(text), C.List_CVk, true); |
| if (data != null) |
| text = t1.replaceRange$3(text, t2, t1.get$length(text), data); |
| } |
| return new P.UriData(text, indices, sourceUri); |
| }, |
| UriData__uriEncodeBytes: function(canonicalTable, bytes, buffer) { |
| var t1, byteOr, i, t2, byte; |
| t1 = J.getInterceptor$asx(bytes); |
| byteOr = 0; |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(bytes); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| byte = t1.$index(bytes, i); |
| if (typeof byte !== "number") |
| return H.iae(byte); |
| byteOr |= byte; |
| if (byte < 128) { |
| t2 = C.JSNumber_methods._shrOtherPositive$1(byte, 4); |
| if (t2 >= 8) |
| return H.ioore(canonicalTable, t2); |
| t2 = (canonicalTable[t2] & 1 << (byte & 15)) !== 0; |
| } else |
| t2 = false; |
| if (t2) |
| buffer._contents += H.Primitives_stringFromCharCode(byte); |
| else { |
| buffer._contents += H.Primitives_stringFromCharCode(37); |
| buffer._contents += H.Primitives_stringFromCharCode(C.JSString_methods._codeUnitAt$1("0123456789ABCDEF", C.JSNumber_methods._shrOtherPositive$1(byte, 4))); |
| buffer._contents += H.Primitives_stringFromCharCode(C.JSString_methods._codeUnitAt$1("0123456789ABCDEF", byte & 15)); |
| } |
| ++i; |
| } |
| if ((byteOr & 4294967040) >>> 0 !== 0) { |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(bytes); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| byte = t1.$index(bytes, i); |
| t2 = J.getInterceptor$n(byte); |
| if (t2.$lt(byte, 0) || t2.$gt(byte, 255)) |
| throw H.wrapException(P.ArgumentError$value(byte, "non-byte value", null)); |
| ++i; |
| } |
| } |
| } |
| } |
| }, |
| _createTables_closure: { |
| "^": "Closure:0;", |
| call$1: function(_) { |
| return new Uint8Array(H._checkLength(96)); |
| } |
| }, |
| _createTables_build: { |
| "^": "Closure:23;tables", |
| call$2: function(state, defaultTransition) { |
| var t1 = this.tables; |
| if (state >= t1.length) |
| return H.ioore(t1, state); |
| t1 = t1[state]; |
| J.fillRange$3$ax(t1, 0, 96, defaultTransition); |
| return t1; |
| } |
| }, |
| _createTables_setChars: { |
| "^": "Closure:6;", |
| call$3: function(target, chars, transition) { |
| var t1, t2, i; |
| for (t1 = chars.length, t2 = J.getInterceptor$ax(target), i = 0; i < t1; ++i) |
| t2.$indexSet(target, C.JSString_methods._codeUnitAt$1(chars, i) ^ 96, transition); |
| } |
| }, |
| _createTables_setRange: { |
| "^": "Closure:6;", |
| call$3: function(target, range, transition) { |
| var i, n, t1; |
| for (i = C.JSString_methods._codeUnitAt$1(range, 0), n = C.JSString_methods._codeUnitAt$1(range, 1), t1 = J.getInterceptor$ax(target); i <= n; ++i) |
| t1.$indexSet(target, (i ^ 96) >>> 0, transition); |
| } |
| }, |
| _SimpleUri: { |
| "^": "Object;_uri,_schemeEnd,_hostStart,_portStart,_pathStart,_queryStart,_fragmentStart,_schemeCache,_hashCodeCache", |
| get$hasAuthority: function() { |
| return this._hostStart > 0; |
| }, |
| get$hasPort: function() { |
| var t1, t2; |
| if (this._hostStart > 0) { |
| t1 = J.$add$ns(this._portStart, 1); |
| t2 = this._pathStart; |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| t2 = t1 < t2; |
| t1 = t2; |
| } else |
| t1 = false; |
| return t1; |
| }, |
| get$hasQuery: function() { |
| return J.$lt$n(this._queryStart, this._fragmentStart); |
| }, |
| get$hasFragment: function() { |
| return J.$lt$n(this._fragmentStart, J.get$length$asx(this._uri)); |
| }, |
| get$hasAbsolutePath: function() { |
| return J.startsWith$2$s(this._uri, "/", this._pathStart); |
| }, |
| get$scheme: function() { |
| var t1, t2; |
| t1 = this._schemeEnd; |
| if (J.$le$n(t1, 0)) |
| return ""; |
| t2 = this._schemeCache; |
| if (t2 != null) |
| return t2; |
| t2 = t1 === 4; |
| if (t2 && J.startsWith$1$s(this._uri, "http")) { |
| this._schemeCache = "http"; |
| t1 = "http"; |
| } else if (t1 === 5 && J.startsWith$1$s(this._uri, "https")) { |
| this._schemeCache = "https"; |
| t1 = "https"; |
| } else if (t2 && J.startsWith$1$s(this._uri, "file")) { |
| this._schemeCache = "file"; |
| t1 = "file"; |
| } else if (t1 === 7 && J.startsWith$1$s(this._uri, "package")) { |
| this._schemeCache = "package"; |
| t1 = "package"; |
| } else { |
| t1 = J.substring$2$s(this._uri, 0, t1); |
| this._schemeCache = t1; |
| } |
| return t1; |
| }, |
| get$userInfo: function() { |
| var t1, t2, t3; |
| t1 = this._hostStart; |
| t2 = this._schemeEnd; |
| t3 = J.getInterceptor$ns(t2); |
| return t1 > t3.$add(t2, 3) ? J.substring$2$s(this._uri, t3.$add(t2, 3), t1 - 1) : ""; |
| }, |
| get$host: function(_) { |
| var t1 = this._hostStart; |
| return t1 > 0 ? J.substring$2$s(this._uri, t1, this._portStart) : ""; |
| }, |
| get$port: function(_) { |
| var t1; |
| if (this.get$hasPort()) |
| return H.Primitives_parseInt(J.substring$2$s(this._uri, J.$add$ns(this._portStart, 1), this._pathStart), null, null); |
| t1 = this._schemeEnd; |
| if (t1 === 4 && J.startsWith$1$s(this._uri, "http")) |
| return 80; |
| if (t1 === 5 && J.startsWith$1$s(this._uri, "https")) |
| return 443; |
| return 0; |
| }, |
| get$path: function(_) { |
| return J.substring$2$s(this._uri, this._pathStart, this._queryStart); |
| }, |
| get$query: function(_) { |
| var t1, t2, t3; |
| t1 = this._queryStart; |
| t2 = this._fragmentStart; |
| t3 = J.getInterceptor$n(t1); |
| return t3.$lt(t1, t2) ? J.substring$2$s(this._uri, t3.$add(t1, 1), t2) : ""; |
| }, |
| get$fragment: function() { |
| var t1, t2, t3, t4; |
| t1 = this._fragmentStart; |
| t2 = this._uri; |
| t3 = J.getInterceptor$asx(t2); |
| t4 = J.getInterceptor$n(t1); |
| return t4.$lt(t1, t3.get$length(t2)) ? t3.substring$1(t2, t4.$add(t1, 1)) : ""; |
| }, |
| get$origin: function(_) { |
| var t1, isHttp, t2, t3, t4, t5; |
| t1 = this._schemeEnd; |
| isHttp = t1 === 4 && J.startsWith$1$s(this._uri, "http"); |
| t2 = J.getInterceptor$n(t1); |
| if (t2.$lt(t1, 0)) |
| throw H.wrapException(new P.StateError("Cannot use origin without a scheme: " + H.S(this))); |
| if (!isHttp) |
| t3 = !(t1 === 5 && J.startsWith$1$s(this._uri, "https")); |
| else |
| t3 = false; |
| if (t3) |
| throw H.wrapException(new P.StateError("Origin is only applicable to schemes http and https: " + H.S(this))); |
| t3 = this._hostStart; |
| if (t3 === this._portStart) |
| throw H.wrapException(new P.StateError("A " + H.S(this.get$scheme()) + ": URI should have a non-empty host name: " + H.S(this))); |
| if (t3 === t2.$add(t1, 3)) |
| return J.substring$2$s(this._uri, 0, this._pathStart); |
| t4 = this._uri; |
| t5 = J.getInterceptor$s(t4); |
| return t5.substring$2(t4, 0, t2.$add(t1, 3)) + t5.substring$2(t4, t3, this._pathStart); |
| }, |
| get$pathSegments: function() { |
| var start, end, t1, t2, parts, i, t3; |
| start = this._pathStart; |
| end = this._queryStart; |
| t1 = this._uri; |
| t2 = J.getInterceptor$s(t1); |
| if (t2.startsWith$2(t1, "/", start)) |
| start = J.$add$ns(start, 1); |
| if (start == null ? end == null : start === end) |
| return C.List_empty; |
| parts = []; |
| for (i = start; t3 = J.getInterceptor$n(i), t3.$lt(i, end); i = t3.$add(i, 1)) |
| if (t2.codeUnitAt$1(t1, i) === 47) { |
| parts.push(t2.substring$2(t1, start, i)); |
| start = t3.$add(i, 1); |
| } |
| parts.push(t2.substring$2(t1, start, end)); |
| return P.List_List$unmodifiable(parts, P.String); |
| }, |
| get$queryParameters: function() { |
| if (!J.$lt$n(this._queryStart, this._fragmentStart)) |
| return C.Map_empty; |
| var t1 = P.String; |
| return new P.UnmodifiableMapView(P.Uri_splitQueryString(this.get$query(this), C.Utf8Codec_false), [t1, t1]); |
| }, |
| _isPort$1: function(port) { |
| var portDigitStart = J.$add$ns(this._portStart, 1); |
| return portDigitStart + port.length === this._pathStart && J.startsWith$2$s(this._uri, port, portDigitStart); |
| }, |
| removeFragment$0: function() { |
| var t1, t2, t3; |
| t1 = this._fragmentStart; |
| t2 = this._uri; |
| t3 = J.getInterceptor$asx(t2); |
| if (!J.$lt$n(t1, t3.get$length(t2))) |
| return this; |
| return new P._SimpleUri(t3.substring$2(t2, 0, t1), this._schemeEnd, this._hostStart, this._portStart, this._pathStart, this._queryStart, t1, this._schemeCache, null); |
| }, |
| resolve$1: function(reference) { |
| return this.resolveUri$1(P.Uri_parse(reference, 0, null)); |
| }, |
| resolveUri$1: function(reference) { |
| if (reference instanceof P._SimpleUri) |
| return this._simpleMerge$2(this, reference); |
| return this._toNonSimple$0().resolveUri$1(reference); |
| }, |
| _simpleMerge$2: function(base, ref) { |
| var t1, t2, t3, t4, t5, t6, t7, isSimple, delta, refStart, baseStart, baseEnd, baseUri, baseStart0, backCount, insert; |
| t1 = ref._schemeEnd; |
| t2 = J.getInterceptor$n(t1); |
| if (t2.$gt(t1, 0)) |
| return ref; |
| t3 = ref._hostStart; |
| if (t3 > 0) { |
| t4 = base._schemeEnd; |
| t5 = J.getInterceptor$n(t4); |
| if (!t5.$gt(t4, 0)) |
| return ref; |
| t6 = t4 === 4; |
| if (t6 && J.startsWith$1$s(base._uri, "file")) { |
| t6 = ref._pathStart; |
| t7 = ref._queryStart; |
| isSimple = t6 == null ? t7 != null : t6 !== t7; |
| } else if (t6 && J.startsWith$1$s(base._uri, "http")) |
| isSimple = !ref._isPort$1("80"); |
| else |
| isSimple = !(t4 === 5 && J.startsWith$1$s(base._uri, "https")) || !ref._isPort$1("443"); |
| if (isSimple) { |
| delta = t5.$add(t4, 1); |
| return new P._SimpleUri(J.substring$2$s(base._uri, 0, t5.$add(t4, 1)) + J.substring$1$s(ref._uri, t2.$add(t1, 1)), t4, t3 + delta, J.$add$ns(ref._portStart, delta), J.$add$ns(ref._pathStart, delta), J.$add$ns(ref._queryStart, delta), J.$add$ns(ref._fragmentStart, delta), base._schemeCache, null); |
| } else |
| return this._toNonSimple$0().resolveUri$1(ref); |
| } |
| refStart = ref._pathStart; |
| t1 = ref._queryStart; |
| if (refStart == null ? t1 == null : refStart === t1) { |
| t2 = ref._fragmentStart; |
| t3 = J.getInterceptor$n(t1); |
| if (t3.$lt(t1, t2)) { |
| t4 = base._queryStart; |
| delta = J.$sub$n(t4, t1); |
| return new P._SimpleUri(J.substring$2$s(base._uri, 0, t4) + J.substring$1$s(ref._uri, t1), base._schemeEnd, base._hostStart, base._portStart, base._pathStart, t3.$add(t1, delta), J.$add$ns(t2, delta), base._schemeCache, null); |
| } |
| t1 = ref._uri; |
| t3 = J.getInterceptor$asx(t1); |
| t4 = J.getInterceptor$n(t2); |
| if (t4.$lt(t2, t3.get$length(t1))) { |
| t5 = base._fragmentStart; |
| delta = J.$sub$n(t5, t2); |
| return new P._SimpleUri(J.substring$2$s(base._uri, 0, t5) + t3.substring$1(t1, t2), base._schemeEnd, base._hostStart, base._portStart, base._pathStart, base._queryStart, t4.$add(t2, delta), base._schemeCache, null); |
| } |
| return base.removeFragment$0(); |
| } |
| t2 = ref._uri; |
| t3 = J.getInterceptor$s(t2); |
| if (t3.startsWith$2(t2, "/", refStart)) { |
| t4 = base._pathStart; |
| delta = J.$sub$n(t4, refStart); |
| return new P._SimpleUri(J.substring$2$s(base._uri, 0, t4) + t3.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, t4, J.$add$ns(t1, delta), J.$add$ns(ref._fragmentStart, delta), base._schemeCache, null); |
| } |
| baseStart = base._pathStart; |
| baseEnd = base._queryStart; |
| if ((baseStart == null ? baseEnd == null : baseStart === baseEnd) && base._hostStart > 0) { |
| for (; t3.startsWith$2(t2, "../", refStart);) |
| refStart = J.$add$ns(refStart, 3); |
| delta = J.$sub$n(baseStart, refStart) + 1; |
| return new P._SimpleUri(J.substring$2$s(base._uri, 0, baseStart) + "/" + t3.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, baseStart, J.$add$ns(t1, delta), J.$add$ns(ref._fragmentStart, delta), base._schemeCache, null); |
| } |
| baseUri = base._uri; |
| for (t4 = J.getInterceptor$s(baseUri), baseStart0 = baseStart; t4.startsWith$2(baseUri, "../", baseStart0);) |
| baseStart0 = J.$add$ns(baseStart0, 3); |
| backCount = 0; |
| while (true) { |
| t5 = J.getInterceptor$ns(refStart); |
| t6 = t5.$add(refStart, 3); |
| if (typeof t1 !== "number") |
| return H.iae(t1); |
| if (!(t6 <= t1 && t3.startsWith$2(t2, "../", refStart))) |
| break; |
| refStart = t5.$add(refStart, 3); |
| ++backCount; |
| } |
| for (insert = ""; t6 = J.getInterceptor$n(baseEnd), t6.$gt(baseEnd, baseStart0);) { |
| baseEnd = t6.$sub(baseEnd, 1); |
| if (t4.codeUnitAt$1(baseUri, baseEnd) === 47) { |
| if (backCount === 0) { |
| insert = "/"; |
| break; |
| } |
| --backCount; |
| insert = "/"; |
| } |
| } |
| if ((baseEnd == null ? baseStart0 == null : baseEnd === baseStart0) && !J.$gt$n(base._schemeEnd, 0) && !t4.startsWith$2(baseUri, "/", baseStart)) { |
| refStart = t5.$sub(refStart, backCount * 3); |
| insert = ""; |
| } |
| delta = J.$sub$n(baseEnd, refStart) + insert.length; |
| return new P._SimpleUri(t4.substring$2(baseUri, 0, baseEnd) + insert + t3.substring$1(t2, refStart), base._schemeEnd, base._hostStart, base._portStart, baseStart, t1 + delta, J.$add$ns(ref._fragmentStart, delta), base._schemeCache, null); |
| }, |
| toFilePath$1$windows: function(windows) { |
| var t1, t2, t3, t4; |
| t1 = this._schemeEnd; |
| if (J.$ge$n(t1, 0)) { |
| t2 = !(t1 === 4 && J.startsWith$1$s(this._uri, "file")); |
| t1 = t2; |
| } else |
| t1 = false; |
| if (t1) |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a " + H.S(this.get$scheme()) + " URI")); |
| t1 = this._queryStart; |
| t2 = this._uri; |
| t3 = J.getInterceptor$asx(t2); |
| t4 = J.getInterceptor$n(t1); |
| if (t4.$lt(t1, t3.get$length(t2))) { |
| if (t4.$lt(t1, this._fragmentStart)) |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a URI with a query component")); |
| throw H.wrapException(new P.UnsupportedError("Cannot extract a file path from a URI with a fragment component")); |
| } |
| windows = $.$get$_Uri__isWindowsCached(); |
| if (windows === true) |
| t1 = P._Uri__toWindowsFilePath(this); |
| else { |
| t4 = this._portStart; |
| if (typeof t4 !== "number") |
| return H.iae(t4); |
| if (this._hostStart < t4) |
| H.throwExpression(new P.UnsupportedError("Cannot extract a non-Windows file path from a file URI with an authority")); |
| t1 = t3.substring$2(t2, this._pathStart, t1); |
| } |
| return t1; |
| }, |
| toFilePath$0: function() { |
| return this.toFilePath$1$windows(null); |
| }, |
| get$data: function(_) { |
| return; |
| }, |
| get$hashCode: function(_) { |
| var t1 = this._hashCodeCache; |
| if (t1 == null) { |
| t1 = J.get$hashCode$(this._uri); |
| this._hashCodeCache = t1; |
| } |
| return t1; |
| }, |
| $eq: function(_, other) { |
| var t1; |
| if (other == null) |
| return false; |
| if (this === other) |
| return true; |
| t1 = J.getInterceptor(other); |
| if (!!t1.$isUri) |
| return J.$eq$(this._uri, t1.toString$0(other)); |
| return false; |
| }, |
| _toNonSimple$0: function() { |
| var t1, t2, t3, t4, t5, t6, t7, t8, t9; |
| t1 = this.get$scheme(); |
| t2 = this.get$userInfo(); |
| t3 = this._hostStart; |
| if (t3 > 0) |
| t3 = J.substring$2$s(this._uri, t3, this._portStart); |
| else |
| t3 = null; |
| t4 = this.get$hasPort() ? this.get$port(this) : null; |
| t5 = this._uri; |
| t6 = this._queryStart; |
| t7 = J.getInterceptor$s(t5); |
| t8 = t7.substring$2(t5, this._pathStart, t6); |
| t9 = this._fragmentStart; |
| t6 = J.$lt$n(t6, t9) ? this.get$query(this) : null; |
| return new P._Uri(t1, t2, t3, t4, t8, t6, J.$lt$n(t9, t7.get$length(t5)) ? this.get$fragment() : null, null, null, null, null, null); |
| }, |
| toString$0: function(_) { |
| return this._uri; |
| }, |
| $isUri: 1 |
| }, |
| _DataUri: { |
| "^": "_Uri;_data,scheme,_userInfo,_host,_port,path,_query,_fragment,_pathSegments,_text,_hashCodeCache,_queryParameters,_queryParameterLists", |
| get$data: function(_) { |
| return this._data; |
| } |
| } |
| }], ["dart.dom.html", "dart:html",, W, { |
| "^": "", |
| window: function() { |
| return window; |
| }, |
| WebSocket_WebSocket: function(url, protocols) { |
| return new WebSocket(url); |
| }, |
| _JenkinsSmiHash_combine: function(hash, value) { |
| hash = 536870911 & hash + value; |
| hash = 536870911 & hash + ((524287 & hash) << 10); |
| return hash ^ hash >>> 6; |
| }, |
| _convertNativeToDart_Window: function(win) { |
| if (win == null) |
| return; |
| return W._DOMWindowCrossFrame__createSafe(win); |
| }, |
| _wrapZone: function(callback) { |
| if (J.$eq$($.Zone__current, C.C__RootZone)) |
| return callback; |
| return $.Zone__current.bindUnaryCallbackGuarded$1(callback); |
| }, |
| HtmlElement: { |
| "^": "Element;", |
| "%": "HTMLBRElement|HTMLBaseElement|HTMLButtonElement|HTMLCanvasElement|HTMLContentElement|HTMLDListElement|HTMLDataListElement|HTMLDetailsElement|HTMLDialogElement|HTMLDirectoryElement|HTMLDivElement|HTMLEmbedElement|HTMLFieldSetElement|HTMLFontElement|HTMLFrameElement|HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTMLMarqueeElement|HTMLMenuElement|HTMLMenuItemElement|HTMLMetaElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLOptGroupElement|HTMLOptionElement|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPictureElement|HTMLPreElement|HTMLProgressElement|HTMLQuoteElement|HTMLScriptElement|HTMLShadowElement|HTMLSlotElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement|HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement|HTMLTableRowElement|HTMLTableSectionElement|HTMLTemplateElement|HTMLTextAreaElement|HTMLTitleElement|HTMLTrackElement|HTMLUListElement|HTMLUnknownElement;HTMLElement" |
| }, |
| AnchorElement: { |
| "^": "HtmlElement;origin=", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| $isInterceptor: 1, |
| "%": "HTMLAnchorElement" |
| }, |
| ApplicationCacheErrorEvent: { |
| "^": "Event;message=", |
| "%": "ApplicationCacheErrorEvent" |
| }, |
| AreaElement: { |
| "^": "HtmlElement;origin=", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| $isInterceptor: 1, |
| "%": "HTMLAreaElement" |
| }, |
| Blob: { |
| "^": "Interceptor;", |
| $isBlob: 1, |
| "%": ";Blob" |
| }, |
| BlobEvent: { |
| "^": "Event;data=", |
| "%": "BlobEvent" |
| }, |
| BodyElement: { |
| "^": "HtmlElement;", |
| $isInterceptor: 1, |
| "%": "HTMLBodyElement" |
| }, |
| CharacterData: { |
| "^": "Node;data=,length=", |
| $isInterceptor: 1, |
| "%": "CDATASection|CharacterData|Comment|ProcessingInstruction|Text" |
| }, |
| Client: { |
| "^": "Interceptor;", |
| postMessage$2: function(receiver, message, transfer) { |
| receiver.postMessage(new P._StructuredCloneDart2Js([], []).walk$1(message), transfer); |
| return; |
| }, |
| "%": "Client|WindowClient" |
| }, |
| CompositionEvent: { |
| "^": "UIEvent;data=", |
| "%": "CompositionEvent" |
| }, |
| CssStyleDeclaration: { |
| "^": "Interceptor_CssStyleDeclarationBase;length=", |
| "%": "CSS2Properties|CSSStyleDeclaration|MSStyleCSSProperties" |
| }, |
| CssStyleDeclarationBase: { |
| "^": "Object;" |
| }, |
| Document: { |
| "^": "Node;origin=", |
| "%": "Document|HTMLDocument|XMLDocument" |
| }, |
| DocumentFragment: { |
| "^": "Node;", |
| $isInterceptor: 1, |
| "%": "DocumentFragment|ShadowRoot" |
| }, |
| DomError: { |
| "^": "Interceptor;message=", |
| "%": "DOMError|FileError" |
| }, |
| DomException: { |
| "^": "Interceptor;message=", |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| "%": "DOMException" |
| }, |
| DomTokenList: { |
| "^": "Interceptor;length=", |
| contains$1: function(receiver, token) { |
| return receiver.contains(token); |
| }, |
| "%": "DOMTokenList" |
| }, |
| Element: { |
| "^": "Node;", |
| toString$0: function(receiver) { |
| return receiver.localName; |
| }, |
| get$onClick: function(receiver) { |
| return new W._ElementEventStreamImpl(receiver, "click", false, [W.MouseEvent]); |
| }, |
| $isInterceptor: 1, |
| "%": ";Element" |
| }, |
| ErrorEvent: { |
| "^": "Event;error=,message=", |
| "%": "ErrorEvent" |
| }, |
| Event: { |
| "^": "Interceptor;", |
| stopPropagation$0: function(receiver) { |
| return receiver.stopPropagation(); |
| }, |
| "%": "AnimationEvent|AnimationPlayerEvent|AudioProcessingEvent|AutocompleteErrorEvent|BeforeInstallPromptEvent|BeforeUnloadEvent|ClipboardEvent|CloseEvent|CustomEvent|DeviceLightEvent|DeviceMotionEvent|DeviceOrientationEvent|FontFaceSetLoadEvent|GamepadEvent|GeofencingEvent|HashChangeEvent|IDBVersionChangeEvent|MIDIConnectionEvent|MediaEncryptedEvent|MediaQueryListEvent|MediaStreamEvent|MediaStreamTrackEvent|OfflineAudioCompletionEvent|PageTransitionEvent|PopStateEvent|PresentationConnectionAvailableEvent|ProgressEvent|PromiseRejectionEvent|RTCDTMFToneChangeEvent|RTCDataChannelEvent|RTCIceCandidateEvent|RTCPeerConnectionIceEvent|RelatedEvent|ResourceProgressEvent|SecurityPolicyViolationEvent|SpeechRecognitionEvent|SpeechSynthesisEvent|StorageEvent|TrackEvent|TransitionEvent|USBConnectionEvent|WebGLContextEvent|WebKitTransitionEvent;Event|InputEvent" |
| }, |
| EventTarget: { |
| "^": "Interceptor;", |
| _addEventListener$3: function(receiver, type, listener, options) { |
| return receiver.addEventListener(type, H.convertDartClosureToJS(listener, 1), false); |
| }, |
| _removeEventListener$3: function(receiver, type, listener, options) { |
| return receiver.removeEventListener(type, H.convertDartClosureToJS(listener, 1), false); |
| }, |
| "%": "MediaStream;EventTarget" |
| }, |
| ExtendableEvent: { |
| "^": "Event;", |
| "%": "FetchEvent|InstallEvent|NotificationEvent|SyncEvent;ExtendableEvent" |
| }, |
| ExtendableMessageEvent: { |
| "^": "ExtendableEvent;data=,origin=", |
| "%": "ExtendableMessageEvent" |
| }, |
| File: { |
| "^": "Blob;", |
| $isFile: 1, |
| "%": "File" |
| }, |
| FormElement: { |
| "^": "HtmlElement;length=", |
| "%": "HTMLFormElement" |
| }, |
| HtmlCollection: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin3;", |
| 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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| $isJSIndexable: 1, |
| $asJSIndexable: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isJavaScriptIndexingBehavior: 1, |
| $asJavaScriptIndexingBehavior: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| "%": "HTMLCollection|HTMLFormControlsCollection|HTMLOptionsCollection" |
| }, |
| IFrameElement: { |
| "^": "HtmlElement;", |
| $isObject: 1, |
| "%": "HTMLIFrameElement" |
| }, |
| ImageElement: { |
| "^": "HtmlElement;", |
| complete$1: function($receiver, arg0) { |
| return $receiver.complete.call$1(arg0); |
| }, |
| "%": "HTMLImageElement" |
| }, |
| InputElement: { |
| "^": "HtmlElement;", |
| $isInterceptor: 1, |
| "%": "HTMLInputElement" |
| }, |
| KeyboardEvent: { |
| "^": "UIEvent;location=", |
| "%": "KeyboardEvent" |
| }, |
| Location: { |
| "^": "Interceptor;", |
| get$origin: function(receiver) { |
| if ("origin" in receiver) |
| return receiver.origin; |
| return H.S(receiver.protocol) + "//" + H.S(receiver.host); |
| }, |
| toString$0: function(receiver) { |
| return String(receiver); |
| }, |
| "%": "Location" |
| }, |
| MediaElement: { |
| "^": "HtmlElement;error=", |
| "%": "HTMLAudioElement|HTMLMediaElement|HTMLVideoElement" |
| }, |
| MediaKeyMessageEvent: { |
| "^": "Event;message=", |
| "%": "MediaKeyMessageEvent" |
| }, |
| MessageEvent: { |
| "^": "Event;origin=", |
| get$data: function(receiver) { |
| var t1, t2; |
| t1 = receiver.data; |
| t2 = new P._AcceptStructuredCloneDart2Js([], [], false); |
| t2.mustCopy = true; |
| return t2.walk$1(t1); |
| }, |
| "%": "MessageEvent" |
| }, |
| MessagePort: { |
| "^": "EventTarget;", |
| postMessage$2: function(receiver, message, transfer) { |
| receiver.postMessage(new P._StructuredCloneDart2Js([], []).walk$1(message), transfer); |
| return; |
| }, |
| "%": "MessagePort" |
| }, |
| MidiMessageEvent: { |
| "^": "Event;data=", |
| "%": "MIDIMessageEvent" |
| }, |
| 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;", |
| "%": "MIDIInput;MIDIPort" |
| }, |
| Navigator: { |
| "^": "Interceptor;", |
| $isInterceptor: 1, |
| "%": "Navigator" |
| }, |
| NavigatorUserMediaError: { |
| "^": "Interceptor;message=", |
| "%": "NavigatorUserMediaError" |
| }, |
| Node: { |
| "^": "EventTarget;parent:parentElement=", |
| 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); |
| }, |
| $isObject: 1, |
| "%": "Attr;Node" |
| }, |
| NodeList: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin2;", |
| 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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| $isJSIndexable: 1, |
| $asJSIndexable: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isJavaScriptIndexingBehavior: 1, |
| $asJavaScriptIndexingBehavior: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| "%": "NodeList|RadioNodeList" |
| }, |
| ObjectElement: { |
| "^": "HtmlElement;data=", |
| "%": "HTMLObjectElement" |
| }, |
| PositionError: { |
| "^": "Interceptor;message=", |
| "%": "PositionError" |
| }, |
| PresentationConnectionCloseEvent: { |
| "^": "Event;message=", |
| "%": "PresentationConnectionCloseEvent" |
| }, |
| PushEvent: { |
| "^": "ExtendableEvent;data=", |
| "%": "PushEvent" |
| }, |
| SelectElement: { |
| "^": "HtmlElement;length=", |
| "%": "HTMLSelectElement" |
| }, |
| ServicePortConnectEvent: { |
| "^": "ExtendableEvent;origin=", |
| "%": "ServicePortConnectEvent" |
| }, |
| ServiceWorkerMessageEvent: { |
| "^": "Event;origin=", |
| get$data: function(receiver) { |
| var t1, t2; |
| t1 = receiver.data; |
| t2 = new P._AcceptStructuredCloneDart2Js([], [], false); |
| t2.mustCopy = true; |
| return t2.walk$1(t1); |
| }, |
| "%": "ServiceWorkerMessageEvent" |
| }, |
| SpeechRecognitionError: { |
| "^": "Event;error=,message=", |
| "%": "SpeechRecognitionError" |
| }, |
| TextEvent: { |
| "^": "UIEvent;data=", |
| "%": "TextEvent" |
| }, |
| UIEvent: { |
| "^": "Event;", |
| "%": "DragEvent|FocusEvent|MouseEvent|PointerEvent|SVGZoomEvent|TouchEvent|WheelEvent;UIEvent" |
| }, |
| WebSocket: { |
| "^": "EventTarget;", |
| send$1: function(receiver, data) { |
| return receiver.send(data); |
| }, |
| "%": "WebSocket" |
| }, |
| Window: { |
| "^": "EventTarget;", |
| get$location: function(receiver) { |
| return receiver.location; |
| }, |
| get$parent: function(receiver) { |
| return W._convertNativeToDart_Window(receiver.parent); |
| }, |
| postMessage$3: function(receiver, message, targetOrigin, transfer) { |
| receiver.postMessage(new P._StructuredCloneDart2Js([], []).walk$1(message), targetOrigin); |
| return; |
| }, |
| postMessage$2: function($receiver, message, targetOrigin) { |
| return this.postMessage$3($receiver, message, targetOrigin, null); |
| }, |
| $isInterceptor: 1, |
| "%": "DOMWindow|Window" |
| }, |
| _ClientRect: { |
| "^": "Interceptor;height=,left=,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, hash; |
| t1 = J.get$hashCode$(receiver.left); |
| t2 = J.get$hashCode$(receiver.top); |
| t3 = J.get$hashCode$(receiver.width); |
| t4 = J.get$hashCode$(receiver.height); |
| t4 = W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(W._JenkinsSmiHash_combine(0, t1), t2), t3), t4); |
| hash = 536870911 & t4 + ((67108863 & t4) << 3); |
| hash ^= hash >>> 11; |
| return 536870911 & hash + ((16383 & hash) << 15); |
| }, |
| $isRectangle: 1, |
| $asRectangle: Isolate.functionThatReturnsNull, |
| "%": "ClientRect" |
| }, |
| _DocumentType: { |
| "^": "Node;", |
| $isInterceptor: 1, |
| "%": "DocumentType" |
| }, |
| _HTMLFrameSetElement: { |
| "^": "HtmlElement;", |
| $isInterceptor: 1, |
| "%": "HTMLFrameSetElement" |
| }, |
| _NamedNodeMap: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin1;", |
| 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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| if (index >>> 0 !== index || index >= receiver.length) |
| return H.ioore(receiver, index); |
| return receiver[index]; |
| }, |
| $isJSIndexable: 1, |
| $asJSIndexable: function() { |
| return [W.Node]; |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isJavaScriptIndexingBehavior: 1, |
| $asJavaScriptIndexingBehavior: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| }, |
| "%": "MozNamedAttrMap|NamedNodeMap" |
| }, |
| _ServiceWorker: { |
| "^": "EventTarget;", |
| $isInterceptor: 1, |
| "%": "ServiceWorker" |
| }, |
| _EventStream: { |
| "^": "Stream;$ti", |
| listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone, onError) { |
| return W._EventStreamSubscription$(this._html$_target, this._eventType, onData, false); |
| }, |
| listen$1: function(onData) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, null, null); |
| }, |
| listen$3$onDone$onError: function(onData, onDone, onError) { |
| return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onError); |
| } |
| }, |
| _ElementEventStreamImpl: { |
| "^": "_EventStream;_html$_target,_eventType,_useCapture,$ti" |
| }, |
| _EventStreamSubscription: { |
| "^": "StreamSubscription;_pauseCount,_html$_target,_eventType,_onData,_useCapture", |
| _EventStreamSubscription$4: function(_target, _eventType, onData, _useCapture) { |
| this._tryResume$0(); |
| }, |
| cancel$0: function() { |
| if (this._html$_target == null) |
| return; |
| this._unlisten$0(); |
| this._html$_target = null; |
| this._onData = null; |
| return; |
| }, |
| pause$1: function(_, resumeSignal) { |
| if (this._html$_target == null) |
| return; |
| ++this._pauseCount; |
| this._unlisten$0(); |
| }, |
| pause$0: function($receiver) { |
| return this.pause$1($receiver, null); |
| }, |
| get$isPaused: function() { |
| return this._pauseCount > 0; |
| }, |
| resume$0: function(_) { |
| if (this._html$_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._html$_target; |
| t3.toString; |
| if (t2) |
| J._addEventListener$3$x(t3, this._eventType, t1, false); |
| } |
| }, |
| _unlisten$0: function() { |
| var t1, t2, t3; |
| t1 = this._onData; |
| t2 = t1 != null; |
| if (t2) { |
| t3 = this._html$_target; |
| t3.toString; |
| if (t2) |
| J._removeEventListener$3$x(t3, this._eventType, t1, false); |
| } |
| }, |
| static: { |
| _EventStreamSubscription$: function(_target, _eventType, onData, _useCapture) { |
| var t1 = new W._EventStreamSubscription(0, _target, _eventType, onData == null ? null : W._wrapZone(new W._EventStreamSubscription_closure(onData)), false); |
| t1._EventStreamSubscription$4(_target, _eventType, onData, false); |
| return t1; |
| } |
| } |
| }, |
| _EventStreamSubscription_closure: { |
| "^": "Closure:0;onData", |
| call$1: [function(e) { |
| return this.onData.call$1(e); |
| }, null, null, 2, 0, null, 19, "call"] |
| }, |
| ImmutableListMixin: { |
| "^": "Object;$ti", |
| get$iterator: function(receiver) { |
| return new W.FixedSizeListIterator(receiver, this.get$length(receiver), -1, null); |
| }, |
| setRange$4: function(receiver, start, end, iterable, skipCount) { |
| throw H.wrapException(new P.UnsupportedError("Cannot setRange on immutable List.")); |
| }, |
| setRange$3: function($receiver, start, end, iterable) { |
| return this.setRange$4($receiver, start, end, iterable, 0); |
| }, |
| replaceRange$3: function(receiver, start, end, iterable) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify an immutable List.")); |
| }, |
| fillRange$3: function(receiver, start, end, fillValue) { |
| throw H.wrapException(new P.UnsupportedError("Cannot modify an immutable List.")); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: null, |
| $isList: 1, |
| $asList: null |
| }, |
| FixedSizeListIterator: { |
| "^": "Object;_array,_html$_length,_position,_html$_current", |
| moveNext$0: function() { |
| var nextPosition, t1; |
| nextPosition = this._position + 1; |
| t1 = this._html$_length; |
| if (nextPosition < t1) { |
| this._html$_current = J.$index$asx(this._array, nextPosition); |
| this._position = nextPosition; |
| return true; |
| } |
| this._html$_current = null; |
| this._position = t1; |
| return false; |
| }, |
| get$current: function() { |
| return this._html$_current; |
| } |
| }, |
| _DOMWindowCrossFrame: { |
| "^": "Object;_window", |
| get$location: function(_) { |
| return W._LocationCrossFrame__createSafe(this._window.location); |
| }, |
| get$parent: function(_) { |
| return W._DOMWindowCrossFrame__createSafe(this._window.parent); |
| }, |
| postMessage$3: function(_, message, targetOrigin, messagePorts) { |
| this._window.postMessage(new P._StructuredCloneDart2Js([], []).walk$1(message), targetOrigin); |
| }, |
| postMessage$2: function($receiver, message, targetOrigin) { |
| return this.postMessage$3($receiver, message, targetOrigin, null); |
| }, |
| $isInterceptor: 1, |
| static: { |
| _DOMWindowCrossFrame__createSafe: function(w) { |
| if (w === window) |
| return w; |
| else |
| return new W._DOMWindowCrossFrame(w); |
| } |
| } |
| }, |
| _LocationCrossFrame: { |
| "^": "Object;_location", |
| static: { |
| _LocationCrossFrame__createSafe: function($location) { |
| if ($location === window.location) |
| return $location; |
| else |
| return new W._LocationCrossFrame($location); |
| } |
| } |
| }, |
| Interceptor_CssStyleDeclarationBase: { |
| "^": "Interceptor+CssStyleDeclarationBase;" |
| }, |
| Interceptor_ListMixin1: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Interceptor_ListMixin2: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Interceptor_ListMixin3: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin1: { |
| "^": "Interceptor_ListMixin1+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin2: { |
| "^": "Interceptor_ListMixin2+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin3: { |
| "^": "Interceptor_ListMixin3+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [W.Node]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [W.Node]; |
| } |
| } |
| }], ["html_common", "dart:html_common",, P, { |
| "^": "", |
| convertNativePromiseToDartFuture: function(promise) { |
| var t1, completer; |
| t1 = new P._Future(0, $.Zone__current, null, [null]); |
| completer = new P._AsyncCompleter(t1, [null]); |
| promise.then(H.convertDartClosureToJS(new P.convertNativePromiseToDartFuture_closure(completer), 1))["catch"](H.convertDartClosureToJS(new P.convertNativePromiseToDartFuture_closure0(completer), 1)); |
| return t1; |
| }, |
| _StructuredClone: { |
| "^": "Object;", |
| findSlot$1: function(value) { |
| var t1, $length, i; |
| t1 = this.values; |
| $length = t1.length; |
| for (i = 0; i < $length; ++i) |
| if (t1[i] === value) |
| return i; |
| t1.push(value); |
| this.copies.push(null); |
| return $length; |
| }, |
| walk$1: function(e) { |
| var t1, t2, slot, t3, t4, copy; |
| t1 = {}; |
| if (e == null) |
| return e; |
| if (typeof e === "boolean") |
| return e; |
| if (typeof e === "number") |
| return e; |
| if (typeof e === "string") |
| return e; |
| t2 = J.getInterceptor(e); |
| if (!!t2.$isDateTime) |
| return new Date(e._core$_value); |
| if (!!t2.$isRegExp) |
| throw H.wrapException(new P.UnimplementedError("structured clone of RegExp")); |
| if (!!t2.$isFile) |
| return e; |
| if (!!t2.$isBlob) |
| return e; |
| if (!!t2.$isNativeByteBuffer || !!t2.$isNativeTypedData) |
| return e; |
| if (!!t2.$isMap) { |
| slot = this.findSlot$1(e); |
| t3 = this.copies; |
| t4 = t3.length; |
| if (slot >= t4) |
| return H.ioore(t3, slot); |
| copy = t3[slot]; |
| t1.copy = copy; |
| if (copy != null) |
| return copy; |
| copy = {}; |
| t1.copy = copy; |
| if (slot >= t4) |
| return H.ioore(t3, slot); |
| t3[slot] = copy; |
| t2.forEach$1(e, new P._StructuredClone_walk_closure(t1, this)); |
| return t1.copy; |
| } |
| if (!!t2.$isList) { |
| slot = this.findSlot$1(e); |
| t1 = this.copies; |
| if (slot >= t1.length) |
| return H.ioore(t1, slot); |
| copy = t1[slot]; |
| if (copy != null) |
| return copy; |
| return this.copyList$2(e, slot); |
| } |
| throw H.wrapException(new P.UnimplementedError("structured clone of other type")); |
| }, |
| copyList$2: function(e, slot) { |
| var t1, $length, copy, t2, i; |
| t1 = J.getInterceptor$asx(e); |
| $length = t1.get$length(e); |
| copy = new Array($length); |
| t2 = this.copies; |
| if (slot >= t2.length) |
| return H.ioore(t2, slot); |
| t2[slot] = copy; |
| for (i = 0; i < $length; ++i) { |
| t2 = this.walk$1(t1.$index(e, i)); |
| if (i >= copy.length) |
| return H.ioore(copy, i); |
| copy[i] = t2; |
| } |
| return copy; |
| } |
| }, |
| _StructuredClone_walk_closure: { |
| "^": "Closure:3;_box_0,$this", |
| call$2: function(key, value) { |
| this._box_0.copy[key] = this.$this.walk$1(value); |
| } |
| }, |
| _AcceptStructuredClone: { |
| "^": "Object;", |
| findSlot$1: function(value) { |
| var t1, $length, i, t2; |
| t1 = this.values; |
| $length = t1.length; |
| for (i = 0; i < $length; ++i) { |
| t2 = t1[i]; |
| if (t2 == null ? value == null : t2 === value) |
| return i; |
| } |
| t1.push(value); |
| this.copies.push(null); |
| return $length; |
| }, |
| walk$1: function(e) { |
| var _box_0, millisSinceEpoch, t1, proto, slot, t2, copy, l, $length, i; |
| _box_0 = {}; |
| if (e == null) |
| return e; |
| if (typeof e === "boolean") |
| return e; |
| if (typeof e === "number") |
| return e; |
| if (typeof e === "string") |
| return e; |
| if (e instanceof Date) { |
| millisSinceEpoch = e.getTime(); |
| t1 = new P.DateTime(millisSinceEpoch, true); |
| t1.DateTime$_withValue$2$isUtc(millisSinceEpoch, true); |
| return t1; |
| } |
| if (e instanceof RegExp) |
| throw H.wrapException(new P.UnimplementedError("structured clone of RegExp")); |
| if (typeof Promise != "undefined" && e instanceof Promise) |
| return P.convertNativePromiseToDartFuture(e); |
| proto = Object.getPrototypeOf(e); |
| if (proto === Object.prototype || proto === null) { |
| slot = this.findSlot$1(e); |
| t1 = this.copies; |
| t2 = t1.length; |
| if (slot >= t2) |
| return H.ioore(t1, slot); |
| copy = t1[slot]; |
| _box_0.copy = copy; |
| if (copy != null) |
| return copy; |
| copy = P.LinkedHashMap__makeEmpty(); |
| _box_0.copy = copy; |
| if (slot >= t2) |
| return H.ioore(t1, slot); |
| t1[slot] = copy; |
| this.forEachJsField$2(e, new P._AcceptStructuredClone_walk_closure(_box_0, this)); |
| return _box_0.copy; |
| } |
| if (e instanceof Array) { |
| l = e; |
| slot = this.findSlot$1(l); |
| t1 = this.copies; |
| if (slot >= t1.length) |
| return H.ioore(t1, slot); |
| copy = t1[slot]; |
| if (copy != null) |
| return copy; |
| t2 = J.getInterceptor$asx(l); |
| $length = t2.get$length(l); |
| copy = this.mustCopy ? new Array($length) : l; |
| if (slot >= t1.length) |
| return H.ioore(t1, slot); |
| t1[slot] = copy; |
| for (t1 = J.getInterceptor$ax(copy), i = 0; i < $length; ++i) |
| t1.$indexSet(copy, i, this.walk$1(t2.$index(l, i))); |
| return copy; |
| } |
| return e; |
| } |
| }, |
| _AcceptStructuredClone_walk_closure: { |
| "^": "Closure:3;_box_0,$this", |
| call$2: function(key, value) { |
| var t1, t2; |
| t1 = this._box_0.copy; |
| t2 = this.$this.walk$1(value); |
| J.$indexSet$ax(t1, key, t2); |
| return t2; |
| } |
| }, |
| _StructuredCloneDart2Js: { |
| "^": "_StructuredClone;values,copies" |
| }, |
| _AcceptStructuredCloneDart2Js: { |
| "^": "_AcceptStructuredClone;values,copies,mustCopy", |
| forEachJsField$2: function(object, action) { |
| var t1, t2, _i, key; |
| for (t1 = Object.keys(object), t2 = t1.length, _i = 0; _i < t1.length; t1.length === t2 || (0, H.throwConcurrentModificationError)(t1), ++_i) { |
| key = t1[_i]; |
| action.call$2(key, object[key]); |
| } |
| } |
| }, |
| convertNativePromiseToDartFuture_closure: { |
| "^": "Closure:0;completer", |
| call$1: [function(result) { |
| return this.completer.complete$1(0, result); |
| }, null, null, 2, 0, null, 13, "call"] |
| }, |
| convertNativePromiseToDartFuture_closure0: { |
| "^": "Closure:0;completer", |
| call$1: [function(result) { |
| return this.completer.completeError$1(result); |
| }, null, null, 2, 0, null, 13, "call"] |
| } |
| }], ["dart.dom.indexed_db", "dart:indexed_db",, P, { |
| "^": "" |
| }], ["dart.js", "dart:js",, P, { |
| "^": "", |
| _convertDartFunctionFast: function(f) { |
| var existing, ret; |
| existing = f.$dart_jsFunction; |
| if (existing != null) |
| return existing; |
| ret = function(_call, f) { |
| return function() { |
| return _call(f, Array.prototype.slice.apply(arguments)); |
| }; |
| }(P._callDartFunctionFast, f); |
| ret[$.$get$DART_CLOSURE_PROPERTY_NAME()] = f; |
| f.$dart_jsFunction = ret; |
| return ret; |
| }, |
| _callDartFunctionFast: [function(callback, $arguments) { |
| var t1 = H.Primitives_applyFunctionWithPositionalArguments(callback, $arguments); |
| return t1; |
| }, null, null, 4, 0, null, 32, 26], |
| allowInterop: function(f) { |
| if (typeof f == "function") |
| return f; |
| else |
| return P._convertDartFunctionFast(f); |
| } |
| }], ["dart.math", "dart:math",, P, { |
| "^": "", |
| max: [function(a, b) { |
| return Math.max(H.checkNum(a), H.checkNum(b)); |
| }, "call$2", "math__max$closure", 4, 0, function() { |
| return {func: 1, args: [,,]}; |
| }] |
| }], ["dart.dom.svg", "dart:svg",, P, { |
| "^": "", |
| AElement: { |
| "^": "GraphicsElement;", |
| $isInterceptor: 1, |
| "%": "SVGAElement" |
| }, |
| AnimationElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGAnimateElement|SVGAnimateMotionElement|SVGAnimateTransformElement|SVGAnimationElement|SVGSetElement" |
| }, |
| FEBlendElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEBlendElement" |
| }, |
| FEColorMatrixElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEColorMatrixElement" |
| }, |
| FEComponentTransferElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEComponentTransferElement" |
| }, |
| FECompositeElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFECompositeElement" |
| }, |
| FEConvolveMatrixElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEConvolveMatrixElement" |
| }, |
| FEDiffuseLightingElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEDiffuseLightingElement" |
| }, |
| FEDisplacementMapElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEDisplacementMapElement" |
| }, |
| FEFloodElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEFloodElement" |
| }, |
| FEGaussianBlurElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEGaussianBlurElement" |
| }, |
| FEImageElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEImageElement" |
| }, |
| FEMergeElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEMergeElement" |
| }, |
| FEMorphologyElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEMorphologyElement" |
| }, |
| FEOffsetElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFEOffsetElement" |
| }, |
| FESpecularLightingElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFESpecularLightingElement" |
| }, |
| FETileElement: { |
| "^": "SvgElement;result=", |
| $isInterceptor: 1, |
| "%": "SVGFETileElement" |
| }, |
| FETurbulenceElement: { |
| "^": "SvgElement;result=", |
| $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" |
| }, |
| Length: { |
| "^": "Interceptor;", |
| $isObject: 1, |
| "%": "SVGLength" |
| }, |
| LengthList: { |
| "^": "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.getItem(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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| return this.$index(receiver, index); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Length]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Length]; |
| }, |
| "%": "SVGLengthList" |
| }, |
| MarkerElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMarkerElement" |
| }, |
| MaskElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMaskElement" |
| }, |
| Number: { |
| "^": "Interceptor;", |
| $isObject: 1, |
| "%": "SVGNumber" |
| }, |
| NumberList: { |
| "^": "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.getItem(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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| return this.$index(receiver, index); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Number]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Number]; |
| }, |
| "%": "SVGNumberList" |
| }, |
| PatternElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGPatternElement" |
| }, |
| ScriptElement0: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGScriptElement" |
| }, |
| SvgElement: { |
| "^": "Element;", |
| get$onClick: function(receiver) { |
| return new W._ElementEventStreamImpl(receiver, "click", false, [W.MouseEvent]); |
| }, |
| $isInterceptor: 1, |
| "%": "SVGComponentTransferFunctionElement|SVGDescElement|SVGDiscardElement|SVGFEDistantLightElement|SVGFEFuncAElement|SVGFEFuncBElement|SVGFEFuncGElement|SVGFEFuncRElement|SVGFEMergeNodeElement|SVGFEPointLightElement|SVGFESpotLightElement|SVGMetadataElement|SVGStopElement|SVGStyleElement|SVGTitleElement;SVGElement" |
| }, |
| SvgSvgElement: { |
| "^": "GraphicsElement;", |
| $isInterceptor: 1, |
| "%": "SVGSVGElement" |
| }, |
| SymbolElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGSymbolElement" |
| }, |
| TextContentElement: { |
| "^": "GraphicsElement;", |
| "%": "SVGTSpanElement|SVGTextElement|SVGTextPositioningElement;SVGTextContentElement" |
| }, |
| TextPathElement: { |
| "^": "TextContentElement;", |
| $isInterceptor: 1, |
| "%": "SVGTextPathElement" |
| }, |
| Transform: { |
| "^": "Interceptor;", |
| $isObject: 1, |
| "%": "SVGTransform" |
| }, |
| TransformList: { |
| "^": "Interceptor_ListMixin_ImmutableListMixin4;", |
| 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.getItem(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.")); |
| }, |
| elementAt$1: function(receiver, index) { |
| return this.$index(receiver, index); |
| }, |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Transform]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Transform]; |
| }, |
| "%": "SVGTransformList" |
| }, |
| 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" |
| }, |
| _SVGMPathElement: { |
| "^": "SvgElement;", |
| $isInterceptor: 1, |
| "%": "SVGMPathElement" |
| }, |
| Interceptor_ListMixin: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Length]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Length]; |
| } |
| }, |
| Interceptor_ListMixin0: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Number]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Number]; |
| } |
| }, |
| Interceptor_ListMixin4: { |
| "^": "Interceptor+ListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Transform]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Transform]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin: { |
| "^": "Interceptor_ListMixin+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Length]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Length]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin0: { |
| "^": "Interceptor_ListMixin0+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Number]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Number]; |
| } |
| }, |
| Interceptor_ListMixin_ImmutableListMixin4: { |
| "^": "Interceptor_ListMixin4+ImmutableListMixin;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.Transform]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.Transform]; |
| } |
| } |
| }], ["dart.typed_data", "dart:typed_data",, P, { |
| "^": "", |
| Uint8List: { |
| "^": "Object;", |
| $isEfficientLengthIterable: 1, |
| $asEfficientLengthIterable: function() { |
| return [P.int]; |
| }, |
| $isList: 1, |
| $asList: function() { |
| return [P.int]; |
| } |
| } |
| }], ["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" |
| } |
| }], ["", "package:async/src/null_stream_sink.dart",, S, { |
| "^": "", |
| NullStreamSink: { |
| "^": "Object;done,_null_stream_sink$_closed,_addingStream,$ti", |
| addStream$1: function(stream) { |
| var future; |
| this._checkEventAllowed$0(); |
| this._addingStream = true; |
| future = stream.listen$1(null).cancel$0(); |
| if (future == null) { |
| future = new P._Future(0, $.Zone__current, null, [null]); |
| future._asyncComplete$1(null); |
| } |
| return future.whenComplete$1(new S.NullStreamSink_addStream_closure(this)); |
| }, |
| _checkEventAllowed$0: function() { |
| if (this._null_stream_sink$_closed) |
| throw H.wrapException(new P.StateError("Cannot add to a closed sink.")); |
| if (this._addingStream) |
| throw H.wrapException(new P.StateError("Cannot add to a sink while adding a stream.")); |
| }, |
| close$0: function(_) { |
| this._null_stream_sink$_closed = true; |
| return this.done; |
| } |
| }, |
| NullStreamSink_addStream_closure: { |
| "^": "Closure:1;$this", |
| call$0: [function() { |
| this.$this._addingStream = false; |
| }, null, null, 0, 0, null, "call"] |
| } |
| }], ["", "package:path/path.dart",, D, { |
| "^": "", |
| current: function() { |
| var uri, t1, t2, path, lastIndex; |
| uri = P.Uri_base(); |
| if (J.$eq$(uri, $._currentUriBase)) |
| return $._current; |
| $._currentUriBase = uri; |
| t1 = $.$get$Style_platform(); |
| t2 = $.$get$Style_url(); |
| if (t1 == null ? t2 == null : t1 === t2) { |
| t1 = uri.resolve$1(".").toString$0(0); |
| $._current = t1; |
| return t1; |
| } else { |
| path = uri.toFilePath$0(); |
| lastIndex = path.length - 1; |
| t1 = lastIndex === 0 ? path : C.JSString_methods.substring$2(path, 0, lastIndex); |
| $._current = t1; |
| return t1; |
| } |
| } |
| }], ["", "package:path/src/context.dart",, M, { |
| "^": "", |
| _parseUri: function(uri) { |
| if (!!J.getInterceptor(uri).$isUri) |
| return uri; |
| throw H.wrapException(P.ArgumentError$value(uri, "uri", "Value must be a String or a Uri")); |
| }, |
| _validateArgList: function(method, args) { |
| var numArgs, i, numArgs0, message, t1, t2; |
| for (numArgs = args.length, i = 1; i < numArgs; ++i) { |
| if (args[i] == null || args[i - 1] != null) |
| continue; |
| for (; numArgs >= 1; numArgs = numArgs0) { |
| numArgs0 = numArgs - 1; |
| if (args[numArgs0] != null) |
| break; |
| } |
| message = new P.StringBuffer(""); |
| t1 = method + "("; |
| message._contents = t1; |
| t2 = 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)); |
| t1 += new H.MappedListIterable(new H.SubListIterable(args, 0, numArgs, [t2]), new M._validateArgList_closure(), [t2, null]).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", |
| absolute$7: function(_, part1, part2, part3, part4, part5, part6, part7) { |
| var t1; |
| M._validateArgList("absolute", [part1, part2, part3, part4, part5, part6, part7]); |
| t1 = this.style; |
| t1 = J.$gt$n(t1.rootLength$1(part1), 0) && !t1.isRootRelative$1(part1); |
| if (t1) |
| return part1; |
| t1 = this._context$_current; |
| return this.join$8(0, t1 != null ? t1 : D.current(), part1, part2, part3, part4, part5, part6, part7); |
| }, |
| absolute$1: function($receiver, part1) { |
| return this.absolute$7($receiver, part1, null, null, null, null, null, null); |
| }, |
| 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]); |
| M._validateArgList("join", parts); |
| return this.joinAll$1(new H.WhereIterable(parts, new M.Context_join_closure(), [H.getTypeArgumentByIndex(parts, 0)])); |
| }, |
| join$2: function($receiver, part1, part2) { |
| return this.join$8($receiver, part1, part2, null, null, null, null, null, null); |
| }, |
| joinAll$1: function(parts) { |
| var t1, t2, t3, needsSeparator, isAbsoluteAndNotRootRelative, t4, part, parsed, path, t5; |
| for (t1 = parts.get$iterator(parts), t2 = new H.WhereIterator(t1, new M.Context_joinAll_closure()), t3 = this.style, needsSeparator = false, isAbsoluteAndNotRootRelative = false, t4 = ""; t2.moveNext$0();) { |
| part = t1.get$current(); |
| if (t3.isRootRelative$1(part) && isAbsoluteAndNotRootRelative) { |
| parsed = X.ParsedPath_ParsedPath$parse(part, t3); |
| path = t4.charCodeAt(0) == 0 ? t4 : t4; |
| t4 = C.JSString_methods.substring$2(path, 0, t3.rootLength$2$withDrive(path, true)); |
| parsed.root = t4; |
| if (t3.needsSeparator$1(t4)) { |
| t4 = parsed.separators; |
| t5 = t3.get$separator(); |
| if (0 >= t4.length) |
| return H.ioore(t4, 0); |
| t4[0] = t5; |
| } |
| t4 = parsed.toString$0(0); |
| } else if (J.$gt$n(t3.rootLength$1(part), 0)) { |
| isAbsoluteAndNotRootRelative = !t3.isRootRelative$1(part); |
| t4 = H.S(part); |
| } else { |
| t5 = J.getInterceptor$asx(part); |
| if (!(J.$gt$n(t5.get$length(part), 0) && t3.containsSeparator$1(t5.$index(part, 0)) === true)) |
| if (needsSeparator) |
| t4 += t3.get$separator(); |
| t4 += H.S(part); |
| } |
| needsSeparator = t3.needsSeparator$1(part); |
| } |
| return t4.charCodeAt(0) == 0 ? t4 : t4; |
| }, |
| split$1: function(_, path) { |
| var parsed, t1, t2; |
| parsed = X.ParsedPath_ParsedPath$parse(path, this.style); |
| t1 = parsed.parts; |
| t2 = H.getTypeArgumentByIndex(t1, 0); |
| t2 = P.List_List$from(new H.WhereIterable(t1, new M.Context_split_closure(), [t2]), true, t2); |
| parsed.parts = t2; |
| t1 = parsed.root; |
| if (t1 != null) |
| C.JSArray_methods.insert$2(t2, 0, t1); |
| return parsed.parts; |
| }, |
| normalize$1: function(path) { |
| var parsed; |
| if (!this._needsNormalization$1(path)) |
| return path; |
| parsed = X.ParsedPath_ParsedPath$parse(path, this.style); |
| parsed.normalize$0(); |
| return parsed.toString$0(0); |
| }, |
| _needsNormalization$1: function(path) { |
| var codeUnits, t1, root, t2, i, start, previous, t3, previousPrevious, t4, codeUnit, t5; |
| codeUnits = J.get$codeUnits$s(path); |
| t1 = this.style; |
| root = t1.rootLength$1(path); |
| if (root !== 0) { |
| if (t1 === $.$get$Style_windows()) { |
| if (typeof root !== "number") |
| return H.iae(root); |
| t2 = codeUnits.__internal$_string; |
| i = 0; |
| for (; i < root; ++i) |
| if (C.JSString_methods._codeUnitAt$1(t2, i) === 47) |
| return true; |
| } |
| start = root; |
| previous = 47; |
| } else { |
| start = 0; |
| previous = null; |
| } |
| for (t2 = codeUnits.__internal$_string, t3 = t2.length, i = start, previousPrevious = null; t4 = J.getInterceptor$n(i), t4.$lt(i, t3); i = t4.$add(i, 1), previousPrevious = previous, previous = codeUnit) { |
| codeUnit = C.JSString_methods.codeUnitAt$1(t2, i); |
| if (t1.isSeparator$1(codeUnit)) { |
| if (t1 === $.$get$Style_windows() && codeUnit === 47) |
| return true; |
| if (previous != null && t1.isSeparator$1(previous)) |
| return true; |
| if (previous === 46) |
| t5 = previousPrevious == null || previousPrevious === 46 || t1.isSeparator$1(previousPrevious); |
| else |
| t5 = false; |
| if (t5) |
| return true; |
| } |
| } |
| if (previous == null) |
| return true; |
| if (t1.isSeparator$1(previous)) |
| return true; |
| if (previous === 46) |
| t1 = previousPrevious == null || t1.isSeparator$1(previousPrevious) || previousPrevious === 46; |
| else |
| t1 = false; |
| if (t1) |
| return true; |
| return false; |
| }, |
| relative$2$from: function(path, from) { |
| var t1, t2, fromParsed, pathParsed, t3; |
| t1 = this.style; |
| t2 = J.$gt$n(t1.rootLength$1(path), 0); |
| if (!t2) |
| return this.normalize$1(path); |
| t2 = this._context$_current; |
| from = t2 != null ? t2 : D.current(); |
| if (!J.$gt$n(t1.rootLength$1(from), 0) && J.$gt$n(t1.rootLength$1(path), 0)) |
| return this.normalize$1(path); |
| if (!J.$gt$n(t1.rootLength$1(path), 0) || t1.isRootRelative$1(path)) |
| path = this.absolute$1(0, path); |
| if (!J.$gt$n(t1.rootLength$1(path), 0) && J.$gt$n(t1.rootLength$1(from), 0)) |
| throw H.wrapException(new X.PathException('Unable to find a path to "' + H.S(path) + '" from "' + H.S(from) + '".')); |
| fromParsed = X.ParsedPath_ParsedPath$parse(from, t1); |
| fromParsed.normalize$0(); |
| pathParsed = X.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; |
| t2 = t2 == null || pathParsed.root == null || !t1.pathsEqual$2(t2, pathParsed.root); |
| } 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 && t1.pathsEqual$2(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 X.PathException('Unable to find a path to "' + H.S(path) + '" from "' + H.S(from) + '".')); |
| C.JSArray_methods.insertAll$2(pathParsed.parts, 0, P.List_List$filled(fromParsed.parts.length, "..", false, 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(), false, 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); |
| }, |
| toUri$1: function(path) { |
| var t1, t2; |
| t1 = this.style; |
| if (!J.$gt$n(t1.rootLength$1(path), 0)) |
| return t1.relativePathToUri$1(path); |
| else { |
| t2 = this._context$_current; |
| return t1.absolutePathToUri$1(this.join$2(0, t2 != null ? t2 : D.current(), path)); |
| } |
| }, |
| prettyUri$1: function(uri) { |
| var typedUri, t1, t2, path, rel; |
| typedUri = M._parseUri(uri); |
| if (typedUri.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 typedUri.toString$0(0); |
| else { |
| if (typedUri.get$scheme() !== "file") |
| if (typedUri.get$scheme() !== "") { |
| 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 typedUri.toString$0(0); |
| } |
| path = this.normalize$1(this.style.pathFromUri$1(M._parseUri(typedUri))); |
| rel = this.relative$1(path); |
| return this.split$1(0, rel).length > this.split$1(0, path).length ? path : rel; |
| }, |
| static: { |
| Context_Context: function(current, style) { |
| current = style == null ? D.current() : "."; |
| if (style == null) |
| style = $.$get$Style_platform(); |
| return new M.Context(style, current); |
| } |
| } |
| }, |
| 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) + '"'; |
| }, null, null, 2, 0, null, 12, "call"] |
| } |
| }], ["", "package:path/src/internal_style.dart",, B, { |
| "^": "", |
| InternalStyle: { |
| "^": "Style;", |
| getRoot$1: function(path) { |
| var $length = this.rootLength$1(path); |
| if (J.$gt$n($length, 0)) |
| return J.substring$2$s(path, 0, $length); |
| return this.isRootRelative$1(path) ? J.$index$asx(path, 0) : null; |
| }, |
| relativePathToUri$1: function(path) { |
| var segments, t1; |
| segments = M.Context_Context(null, this).split$1(0, path); |
| t1 = J.getInterceptor$asx(path); |
| if (this.isSeparator$1(t1.codeUnitAt$1(path, J.$sub$n(t1.get$length(path), 1)))) |
| C.JSArray_methods.add$1(segments, ""); |
| return P._Uri__Uri(null, null, null, segments, null, null, null, null, null); |
| }, |
| pathsEqual$2: function(path1, path2) { |
| return J.$eq$(path1, path2); |
| } |
| } |
| }], ["", "package:path/src/parsed_path.dart",, X, { |
| "^": "", |
| ParsedPath: { |
| "^": "Object;style,root,isRootRelative,parts,separators", |
| get$hasTrailingSeparator: function() { |
| var t1 = this.parts; |
| if (t1.length !== 0) |
| t1 = J.$eq$(C.JSArray_methods.get$last(t1), "") || !J.$eq$(C.JSArray_methods.get$last(this.separators), ""); |
| else |
| t1 = false; |
| return t1; |
| }, |
| 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$1$canonicalize: function(canonicalize) { |
| var t1, newParts, t2, t3, leadingDoubles, _i, part, t4, newSeparators; |
| t1 = P.String; |
| newParts = H.setRuntimeTypeInfo([], [t1]); |
| for (t2 = this.parts, t3 = t2.length, leadingDoubles = 0, _i = 0; _i < t2.length; t2.length === t3 || (0, H.throwConcurrentModificationError)(t2), ++_i) { |
| part = t2[_i]; |
| t4 = J.getInterceptor(part); |
| if (!(t4.$eq(part, ".") || t4.$eq(part, ""))) |
| if (t4.$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, "..", false, null)); |
| if (newParts.length === 0 && this.root == null) |
| newParts.push("."); |
| newSeparators = P.List_List$generate(newParts.length, new X.ParsedPath_normalize_closure(this), true, t1); |
| 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) { |
| t2 = this.style; |
| t3 = $.$get$Style_windows(); |
| t3 = t2 == null ? t3 == null : t2 === t3; |
| t2 = t3; |
| } else |
| t2 = false; |
| if (t2) |
| this.root = J.replaceAll$2$s(t1, "/", "\\"); |
| this.removeTrailingSeparators$0(); |
| }, |
| normalize$0: function() { |
| return this.normalize$1$canonicalize(false); |
| }, |
| toString$0: function(_) { |
| var t1, i, t2; |
| t1 = this.root; |
| t1 = t1 != null ? H.S(t1) : ""; |
| for (i = 0; i < this.parts.length; ++i) { |
| t2 = this.separators; |
| if (i >= t2.length) |
| return H.ioore(t2, i); |
| t2 = t1 + H.S(t2[i]); |
| t1 = this.parts; |
| if (i >= t1.length) |
| return H.ioore(t1, i); |
| t1 = t2 + H.S(t1[i]); |
| } |
| t1 += 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, t1, parts, separators, 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)); |
| t1 = [P.String]; |
| parts = H.setRuntimeTypeInfo([], t1); |
| separators = H.setRuntimeTypeInfo([], t1); |
| 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(t1.substring$2(path, start, i)); |
| separators.push(t1.$index(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 X.ParsedPath(style, root, isRootRelative, parts, separators); |
| } |
| } |
| }, |
| ParsedPath_normalize_closure: { |
| "^": "Closure:0;$this", |
| call$1: function(_) { |
| return this.$this.style.get$separator(); |
| } |
| } |
| }], ["", "package:path/src/path_exception.dart",, X, { |
| "^": "", |
| PathException: { |
| "^": "Object;message>", |
| toString$0: function(_) { |
| return "PathException: " + this.message; |
| } |
| } |
| }], ["", "package:path/src/style.dart",, O, { |
| "^": "", |
| Style__getPlatformStyle: function() { |
| if (P.Uri_base().get$scheme() !== "file") |
| return $.$get$Style_url(); |
| var t1 = P.Uri_base(); |
| if (!J.endsWith$1$s(t1.get$path(t1), "/")) |
| return $.$get$Style_url(); |
| if (P._Uri__Uri(null, null, "a/b", null, null, null, null, null, null).toFilePath$0() === "a\\b") |
| return $.$get$Style_windows(); |
| return $.$get$Style_posix(); |
| }, |
| Style: { |
| "^": "Object;", |
| toString$0: function(_) { |
| return this.get$name(this); |
| } |
| } |
| }], ["", "package:path/src/style/posix.dart",, E, { |
| "^": "", |
| 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$2$withDrive: function(path, withDrive) { |
| var t1 = J.getInterceptor$asx(path); |
| if (t1.get$isNotEmpty(path) && t1.codeUnitAt$1(path, 0) === 47) |
| return 1; |
| return 0; |
| }, |
| rootLength$1: function(path) { |
| return this.rootLength$2$withDrive(path, false); |
| }, |
| isRootRelative$1: function(path) { |
| return false; |
| }, |
| pathFromUri$1: function(uri) { |
| var t1; |
| if (uri.get$scheme() === "" || uri.get$scheme() === "file") { |
| t1 = uri.get$path(uri); |
| return P._Uri__uriDecode(t1, 0, J.get$length$asx(t1), C.Utf8Codec_false, false); |
| } |
| throw H.wrapException(P.ArgumentError$("Uri " + H.S(uri) + " must have scheme 'file:'.")); |
| }, |
| absolutePathToUri$1: function(path) { |
| var parsed, t1; |
| parsed = X.ParsedPath_ParsedPath$parse(path, this); |
| t1 = parsed.parts; |
| if (t1.length === 0) |
| C.JSArray_methods.addAll$1(t1, ["", ""]); |
| else if (parsed.get$hasTrailingSeparator()) |
| C.JSArray_methods.add$1(parsed.parts, ""); |
| return P._Uri__Uri(null, null, null, parsed.parts, null, null, null, "file", null); |
| } |
| } |
| }], ["", "package:path/src/style/url.dart",, F, { |
| "^": "", |
| 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, t2; |
| 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; |
| if (t1.endsWith$1(path, "://")) { |
| t2 = this.rootLength$1(path); |
| t1 = t1.get$length(path); |
| t1 = t2 == null ? t1 == null : t2 === t1; |
| } else |
| t1 = false; |
| return t1; |
| }, |
| rootLength$2$withDrive: function(path, withDrive) { |
| var t1, i, t2, codeUnit, index; |
| t1 = J.getInterceptor$asx(path); |
| if (t1.get$isEmpty(path) === true) |
| return 0; |
| if (t1.codeUnitAt$1(path, 0) === 47) |
| return 1; |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(path); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| codeUnit = t1.codeUnitAt$1(path, i); |
| if (codeUnit === 47) |
| return 0; |
| if (codeUnit === 58) { |
| if (i === 0) |
| return 0; |
| index = t1.indexOf$2(path, "/", t1.startsWith$2(path, "//", i + 1) ? i + 3 : i); |
| if (index <= 0) |
| return t1.get$length(path); |
| if (!withDrive || J.$lt$n(t1.get$length(path), index + 3)) |
| return index; |
| if (!t1.startsWith$1(path, "file://")) |
| return index; |
| if (!B.isDriveLetter(path, index + 1)) |
| return index; |
| t2 = index + 3; |
| return t1.get$length(path) === t2 ? t2 : index + 4; |
| } |
| ++i; |
| } |
| return 0; |
| }, |
| rootLength$1: function(path) { |
| return this.rootLength$2$withDrive(path, false); |
| }, |
| 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 J.toString$0$(uri); |
| }, |
| relativePathToUri$1: function(path) { |
| return P.Uri_parse(path, 0, null); |
| }, |
| absolutePathToUri$1: function(path) { |
| return P.Uri_parse(path, 0, null); |
| } |
| } |
| }], ["", "package:path/src/style/windows.dart",, L, { |
| "^": "", |
| 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$2$withDrive: function(path, withDrive) { |
| 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 (t1.codeUnitAt$1(path, 0) === 92) { |
| if (J.$lt$n(t1.get$length(path), 2) || t1.codeUnitAt$1(path, 1) !== 92) |
| return 1; |
| index = t1.indexOf$2(path, "\\", 2); |
| if (index > 0) { |
| index = t1.indexOf$2(path, "\\", index + 1); |
| if (index > 0) |
| return index; |
| } |
| return t1.get$length(path); |
| } |
| if (J.$lt$n(t1.get$length(path), 3)) |
| return 0; |
| if (!B.isAlphabetic(t1.codeUnitAt$1(path, 0))) |
| return 0; |
| if (t1.codeUnitAt$1(path, 1) !== 58) |
| return 0; |
| t1 = t1.codeUnitAt$1(path, 2); |
| if (!(t1 === 47 || t1 === 92)) |
| return 0; |
| return 3; |
| }, |
| rootLength$1: function(path) { |
| return this.rootLength$2$withDrive(path, false); |
| }, |
| isRootRelative$1: function(path) { |
| return this.rootLength$1(path) === 1; |
| }, |
| pathFromUri$1: function(uri) { |
| var path, t1; |
| if (uri.get$scheme() !== "" && uri.get$scheme() !== "file") |
| throw H.wrapException(P.ArgumentError$("Uri " + H.S(uri) + " must have scheme 'file:'.")); |
| path = uri.get$path(uri); |
| if (uri.get$host(uri) === "") { |
| t1 = J.getInterceptor$asx(path); |
| if (J.$ge$n(t1.get$length(path), 3) && t1.startsWith$1(path, "/") && B.isDriveLetter(path, 1)) |
| path = t1.replaceFirst$2(path, "/", ""); |
| } else |
| path = "\\\\" + H.S(uri.get$host(uri)) + H.S(path); |
| t1 = J.replaceAll$2$s(path, "/", "\\"); |
| return P._Uri__uriDecode(t1, 0, t1.length, C.Utf8Codec_false, false); |
| }, |
| absolutePathToUri$1: function(path) { |
| var parsed, t1, rootParts; |
| parsed = X.ParsedPath_ParsedPath$parse(path, this); |
| if (J.startsWith$1$s(parsed.root, "\\\\")) { |
| t1 = J.split$1$s(parsed.root, "\\"); |
| rootParts = new H.WhereIterable(t1, new L.WindowsStyle_absolutePathToUri_closure(), [H.getTypeArgumentByIndex(t1, 0)]); |
| C.JSArray_methods.insert$2(parsed.parts, 0, rootParts.get$last(rootParts)); |
| if (parsed.get$hasTrailingSeparator()) |
| C.JSArray_methods.add$1(parsed.parts, ""); |
| return P._Uri__Uri(null, rootParts.get$first(rootParts), null, parsed.parts, null, null, null, "file", null); |
| } else { |
| if (parsed.parts.length === 0 || parsed.get$hasTrailingSeparator()) |
| C.JSArray_methods.add$1(parsed.parts, ""); |
| C.JSArray_methods.insert$2(parsed.parts, 0, H.stringReplaceAllUnchecked(J.replaceAll$2$s(parsed.root, "/", ""), "\\", "")); |
| return P._Uri__Uri(null, null, null, parsed.parts, null, null, null, "file", null); |
| } |
| }, |
| codeUnitsEqual$2: function(codeUnit1, codeUnit2) { |
| var upperCase1; |
| if (codeUnit1 === codeUnit2) |
| return true; |
| if (codeUnit1 === 47) |
| return codeUnit2 === 92; |
| if (codeUnit1 === 92) |
| return codeUnit2 === 47; |
| if ((codeUnit1 ^ codeUnit2) !== 32) |
| return false; |
| upperCase1 = codeUnit1 | 32; |
| return upperCase1 >= 97 && upperCase1 <= 122; |
| }, |
| pathsEqual$2: function(path1, path2) { |
| var t1, t2, t3, t4, i; |
| if (path1 == null ? path2 == null : path1 === path2) |
| return true; |
| t1 = J.getInterceptor$asx(path1); |
| t2 = t1.get$length(path1); |
| t3 = J.getInterceptor$asx(path2); |
| t4 = t3.get$length(path2); |
| if (t2 == null ? t4 != null : t2 !== t4) |
| return false; |
| i = 0; |
| while (true) { |
| t2 = t1.get$length(path1); |
| if (typeof t2 !== "number") |
| return H.iae(t2); |
| if (!(i < t2)) |
| break; |
| if (!this.codeUnitsEqual$2(t1.codeUnitAt$1(path1, i), t3.codeUnitAt$1(path2, i))) |
| return false; |
| ++i; |
| } |
| return true; |
| } |
| }, |
| WindowsStyle_absolutePathToUri_closure: { |
| "^": "Closure:0;", |
| call$1: function(part) { |
| return !J.$eq$(part, ""); |
| } |
| } |
| }], ["", "package:path/src/utils.dart",, B, { |
| "^": "", |
| isAlphabetic: function(char) { |
| var t1; |
| if (!(char >= 65 && char <= 90)) |
| t1 = char >= 97 && char <= 122; |
| else |
| t1 = true; |
| return t1; |
| }, |
| isDriveLetter: function(path, index) { |
| var t1, t2; |
| t1 = J.getInterceptor$asx(path); |
| t2 = index + 2; |
| if (J.$lt$n(t1.get$length(path), t2)) |
| return false; |
| if (!B.isAlphabetic(t1.codeUnitAt$1(path, index))) |
| return false; |
| if (t1.codeUnitAt$1(path, index + 1) !== 58) |
| return false; |
| if (t1.get$length(path) === t2) |
| return true; |
| return t1.codeUnitAt$1(path, t2) === 47; |
| } |
| }], ["", "package:stack_trace/src/chain.dart",, U, { |
| "^": "", |
| Chain: { |
| "^": "Object;traces", |
| get$terse: function() { |
| return this.foldFrames$2$terse(new U.Chain_terse_closure(), true); |
| }, |
| foldFrames$2$terse: function(predicate, terse) { |
| var t1, foldedTraces, nonEmptyTraces; |
| t1 = this.traces; |
| foldedTraces = new H.MappedListIterable(t1, new U.Chain_foldFrames_closure(predicate, true), [H.getTypeArgumentByIndex(t1, 0), null]); |
| nonEmptyTraces = foldedTraces.super$Iterable$where(0, new U.Chain_foldFrames_closure0(true)); |
| if (!nonEmptyTraces.get$iterator(nonEmptyTraces).moveNext$0() && !foldedTraces.get$isEmpty(foldedTraces)) |
| return new U.Chain(P.List_List$unmodifiable([foldedTraces.get$last(foldedTraces)], Y.Trace)); |
| return new U.Chain(P.List_List$unmodifiable(nonEmptyTraces, Y.Trace)); |
| }, |
| toTrace$0: function() { |
| var t1 = this.traces; |
| return Y.Trace$(new H.ExpandIterable(t1, new U.Chain_toTrace_closure(), [H.getTypeArgumentByIndex(t1, 0), null]), null); |
| }, |
| toString$0: function(_) { |
| var t1, t2; |
| t1 = this.traces; |
| t2 = [H.getTypeArgumentByIndex(t1, 0), null]; |
| return new H.MappedListIterable(t1, new U.Chain_toString_closure(new H.MappedListIterable(t1, new U.Chain_toString_closure0(), t2).fold$2(0, 0, P.math__max$closure())), t2).join$1(0, "===== asynchronous gap ===========================\n"); |
| }, |
| static: { |
| Chain_Chain$parse: function(chain) { |
| var t1 = J.getInterceptor$asx(chain); |
| if (t1.get$isEmpty(chain) === true) |
| return new U.Chain(P.List_List$unmodifiable([], Y.Trace)); |
| if (t1.contains$1(chain, "<asynchronous suspension>\n") === true) { |
| t1 = t1.split$1(chain, "<asynchronous suspension>\n"); |
| return new U.Chain(P.List_List$unmodifiable(new H.MappedListIterable(t1, new U.closure3(), [H.getTypeArgumentByIndex(t1, 0), null]), Y.Trace)); |
| } |
| if (t1.contains$1(chain, "===== asynchronous gap ===========================\n") !== true) |
| return new U.Chain(P.List_List$unmodifiable([Y.Trace_Trace$parse(chain)], Y.Trace)); |
| t1 = t1.split$1(chain, "===== asynchronous gap ===========================\n"); |
| return new U.Chain(P.List_List$unmodifiable(new H.MappedListIterable(t1, new U.closure4(), [H.getTypeArgumentByIndex(t1, 0), null]), Y.Trace)); |
| } |
| } |
| }, |
| closure3: { |
| "^": "Closure:0;", |
| call$1: [function(trace) { |
| return new Y.Trace(P.List_List$unmodifiable(Y.Trace__parseVM(trace), A.Frame), new P._StringStackTrace(trace)); |
| }, null, null, 2, 0, null, 5, "call"] |
| }, |
| closure4: { |
| "^": "Closure:0;", |
| call$1: [function(trace) { |
| return Y.Trace$parseFriendly(trace); |
| }, null, null, 2, 0, null, 5, "call"] |
| }, |
| Chain_terse_closure: { |
| "^": "Closure:0;", |
| call$1: function(_) { |
| return false; |
| } |
| }, |
| Chain_foldFrames_closure: { |
| "^": "Closure:0;predicate,terse", |
| call$1: [function(trace) { |
| return trace.foldFrames$2$terse(this.predicate, this.terse); |
| }, null, null, 2, 0, null, 5, "call"] |
| }, |
| Chain_foldFrames_closure0: { |
| "^": "Closure:0;terse", |
| call$1: function(trace) { |
| if (trace.get$frames().length > 1) |
| return true; |
| if (trace.get$frames().length === 0) |
| return false; |
| if (!this.terse) |
| return false; |
| return C.JSArray_methods.get$single(trace.get$frames()).get$line() != null; |
| } |
| }, |
| Chain_toTrace_closure: { |
| "^": "Closure:0;", |
| call$1: function(trace) { |
| return trace.get$frames(); |
| } |
| }, |
| Chain_toString_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(trace) { |
| var t1 = trace.get$frames(); |
| return new H.MappedListIterable(t1, new U.Chain_toString__closure0(), [H.getTypeArgumentByIndex(t1, 0), null]).fold$2(0, 0, P.math__max$closure()); |
| }, null, null, 2, 0, null, 5, "call"] |
| }, |
| Chain_toString__closure0: { |
| "^": "Closure:0;", |
| call$1: [function(frame) { |
| return J.get$length$asx(J.get$location$x(frame)); |
| }, null, null, 2, 0, null, 6, "call"] |
| }, |
| Chain_toString_closure: { |
| "^": "Closure:0;longest", |
| call$1: [function(trace) { |
| var t1 = trace.get$frames(); |
| return new H.MappedListIterable(t1, new U.Chain_toString__closure(this.longest), [H.getTypeArgumentByIndex(t1, 0), null]).join$0(0); |
| }, null, null, 2, 0, null, 5, "call"] |
| }, |
| Chain_toString__closure: { |
| "^": "Closure:0;longest", |
| call$1: [function(frame) { |
| return J.padRight$1$s(J.get$location$x(frame), this.longest) + " " + H.S(frame.get$member()) + "\n"; |
| }, null, null, 2, 0, null, 6, "call"] |
| } |
| }], ["", "package:stack_trace/src/frame.dart",, A, { |
| "^": "", |
| Frame: { |
| "^": "Object;uri<,line<,column<,member<", |
| get$isCore: function() { |
| return this.uri.get$scheme() === "dart"; |
| }, |
| get$library: function() { |
| var t1 = this.uri; |
| if (t1.get$scheme() === "data") |
| return "data:..."; |
| return $.$get$context().prettyUri$1(t1); |
| }, |
| get$$package: function() { |
| var t1 = this.uri; |
| if (t1.get$scheme() !== "package") |
| return; |
| return C.JSArray_methods.get$first(J.split$1$s(t1.get$path(t1), "/")); |
| }, |
| get$location: function(_) { |
| var t1, t2; |
| t1 = this.line; |
| if (t1 == null) |
| return this.get$library(); |
| t2 = this.column; |
| if (t2 == null) |
| return H.S(this.get$library()) + " " + H.S(t1); |
| return H.S(this.get$library()) + " " + H.S(t1) + ":" + H.S(t2); |
| }, |
| toString$0: function(_) { |
| return H.S(this.get$location(this)) + " in " + H.S(this.member); |
| }, |
| static: { |
| Frame_Frame$parseVM: function(frame) { |
| return A.Frame__catchFormatException(frame, new A.closure1(frame)); |
| }, |
| Frame_Frame$parseV8: function(frame) { |
| return A.Frame__catchFormatException(frame, new A.closure6(frame)); |
| }, |
| Frame_Frame$parseFirefox: function(frame) { |
| return A.Frame__catchFormatException(frame, new A.closure5(frame)); |
| }, |
| Frame_Frame$parseFriendly: function(frame) { |
| return A.Frame__catchFormatException(frame, new A.closure2(frame)); |
| }, |
| Frame__uriOrPathToUri: function(uriOrPath) { |
| var t1 = J.getInterceptor$asx(uriOrPath); |
| if (t1.contains$1(uriOrPath, $.$get$Frame__uriRegExp()) === true) |
| return P.Uri_parse(uriOrPath, 0, null); |
| else if (t1.contains$1(uriOrPath, $.$get$Frame__windowsRegExp()) === true) |
| return P._Uri__Uri$file(uriOrPath, true); |
| else if (t1.startsWith$1(uriOrPath, "/")) |
| return P._Uri__Uri$file(uriOrPath, false); |
| if (t1.contains$1(uriOrPath, "\\") === true) |
| return $.$get$windows().toUri$1(uriOrPath); |
| return P.Uri_parse(uriOrPath, 0, null); |
| }, |
| Frame__catchFormatException: function(text, body) { |
| var t1, exception; |
| try { |
| t1 = body.call$0(); |
| return t1; |
| } catch (exception) { |
| if (H.unwrapException(exception) instanceof P.FormatException) |
| return new N.UnparsedFrame(P._Uri__Uri(null, null, "unparsed", null, null, null, null, null, null), null, null, false, "unparsed", null, "unparsed", text); |
| else |
| throw exception; |
| } |
| } |
| } |
| }, |
| closure1: { |
| "^": "Closure:1;frame", |
| call$0: function() { |
| var t1, match, member, uri, lineAndColumn, line; |
| t1 = this.frame; |
| if (J.$eq$(t1, "...")) |
| return new A.Frame(P._Uri__Uri(null, null, null, null, null, null, null, null, null), null, null, "..."); |
| match = $.$get$_vmFrame().firstMatch$1(t1); |
| if (match == null) |
| return new N.UnparsedFrame(P._Uri__Uri(null, null, "unparsed", null, null, null, null, null, null), null, null, false, "unparsed", null, "unparsed", t1); |
| t1 = match._match; |
| if (1 >= t1.length) |
| return H.ioore(t1, 1); |
| member = H.stringReplaceAllUnchecked(J.replaceAll$2$s(t1[1], $.$get$_asyncBody(), "<async>"), "<anonymous closure>", "<fn>"); |
| if (2 >= t1.length) |
| return H.ioore(t1, 2); |
| uri = P.Uri_parse(t1[2], 0, null); |
| if (3 >= t1.length) |
| return H.ioore(t1, 3); |
| lineAndColumn = J.split$1$s(t1[3], ":"); |
| line = lineAndColumn.length > 1 ? H.Primitives_parseInt(lineAndColumn[1], null, null) : null; |
| return new A.Frame(uri, line, lineAndColumn.length > 2 ? H.Primitives_parseInt(lineAndColumn[2], null, null) : null, member); |
| } |
| }, |
| closure6: { |
| "^": "Closure:1;frame", |
| call$0: function() { |
| var t1, match, t2, t3, t4; |
| t1 = this.frame; |
| match = $.$get$_v8Frame().firstMatch$1(t1); |
| if (match == null) |
| return new N.UnparsedFrame(P._Uri__Uri(null, null, "unparsed", null, null, null, null, null, null), null, null, false, "unparsed", null, "unparsed", t1); |
| t1 = new A._parseLocation(t1); |
| t2 = match._match; |
| t3 = t2.length; |
| if (2 >= t3) |
| return H.ioore(t2, 2); |
| t4 = t2[2]; |
| if (t4 != null) |
| return t1.call$2(t4, H.stringReplaceAllUnchecked(H.stringReplaceAllUnchecked(J.replaceAll$2$s(t2[1], "<anonymous>", "<fn>"), "Anonymous function", "<fn>"), "(anonymous function)", "<fn>")); |
| else { |
| if (3 >= t3) |
| return H.ioore(t2, 3); |
| return t1.call$2(t2[3], "<fn>"); |
| } |
| } |
| }, |
| _parseLocation: { |
| "^": "Closure:3;frame", |
| call$2: function($location, member) { |
| var t1, evalMatch, t2, urlMatch, t3; |
| t1 = $.$get$_v8EvalLocation(); |
| evalMatch = t1.firstMatch$1($location); |
| for (; evalMatch != null;) { |
| t2 = evalMatch._match; |
| if (1 >= t2.length) |
| return H.ioore(t2, 1); |
| $location = t2[1]; |
| evalMatch = t1.firstMatch$1($location); |
| } |
| if (J.$eq$($location, "native")) |
| return new A.Frame(P.Uri_parse("native", 0, null), null, null, member); |
| urlMatch = $.$get$_v8UrlLocation().firstMatch$1($location); |
| if (urlMatch == null) |
| return new N.UnparsedFrame(P._Uri__Uri(null, null, "unparsed", null, null, null, null, null, null), null, null, false, "unparsed", null, "unparsed", this.frame); |
| t1 = urlMatch._match; |
| if (1 >= t1.length) |
| return H.ioore(t1, 1); |
| t2 = A.Frame__uriOrPathToUri(t1[1]); |
| if (2 >= t1.length) |
| return H.ioore(t1, 2); |
| t3 = H.Primitives_parseInt(t1[2], null, null); |
| if (3 >= t1.length) |
| return H.ioore(t1, 3); |
| return new A.Frame(t2, t3, H.Primitives_parseInt(t1[3], null, null), member); |
| } |
| }, |
| closure5: { |
| "^": "Closure:1;frame", |
| call$0: function() { |
| var t1, match, uri, t2, t3, member, line, column; |
| t1 = this.frame; |
| match = $.$get$_firefoxSafariFrame().firstMatch$1(t1); |
| if (match == null) |
| return new N.UnparsedFrame(P._Uri__Uri(null, null, "unparsed", null, null, null, null, null, null), null, null, false, "unparsed", null, "unparsed", t1); |
| t1 = match._match; |
| if (3 >= t1.length) |
| return H.ioore(t1, 3); |
| uri = A.Frame__uriOrPathToUri(t1[3]); |
| t2 = t1.length; |
| if (1 >= t2) |
| return H.ioore(t1, 1); |
| t3 = t1[1]; |
| if (t3 != null) { |
| if (2 >= t2) |
| return H.ioore(t1, 2); |
| t2 = C.JSString_methods.allMatches$1("/", t1[2]); |
| member = J.$add$ns(t3, C.JSArray_methods.join$0(P.List_List$filled(t2.get$length(t2), ".<fn>", false, null))); |
| if (J.$eq$(member, "")) |
| member = "<fn>"; |
| member = J.replaceFirst$2$s(member, $.$get$_initialDot(), ""); |
| } else |
| member = "<fn>"; |
| if (4 >= t1.length) |
| return H.ioore(t1, 4); |
| if (J.$eq$(t1[4], "")) |
| line = null; |
| else { |
| if (4 >= t1.length) |
| return H.ioore(t1, 4); |
| line = H.Primitives_parseInt(t1[4], null, null); |
| } |
| if (5 >= t1.length) |
| return H.ioore(t1, 5); |
| t2 = t1[5]; |
| if (t2 == null || J.$eq$(t2, "")) |
| column = null; |
| else { |
| if (5 >= t1.length) |
| return H.ioore(t1, 5); |
| column = H.Primitives_parseInt(t1[5], null, null); |
| } |
| return new A.Frame(uri, line, column, member); |
| } |
| }, |
| closure2: { |
| "^": "Closure:1;frame", |
| call$0: function() { |
| var t1, match, buffer, indices, t2, uri, line, column; |
| t1 = this.frame; |
| match = $.$get$_friendlyFrame().firstMatch$1(t1); |
| if (match == null) |
| throw H.wrapException(new P.FormatException("Couldn't parse package:stack_trace stack trace line '" + H.S(t1) + "'.", null, null)); |
| t1 = match._match; |
| if (1 >= t1.length) |
| return H.ioore(t1, 1); |
| if (J.$eq$(t1[1], "data:...")) { |
| buffer = new P.StringBuffer(""); |
| indices = [-1]; |
| P.UriData__writeUri(null, null, null, buffer, indices); |
| indices.push(buffer._contents.length); |
| buffer._contents += ","; |
| P.UriData__uriEncodeBytes(C.List_CVk, C.AsciiCodec_false.get$encoder().convert$1(""), buffer); |
| t2 = buffer._contents; |
| uri = new P.UriData(t2.charCodeAt(0) == 0 ? t2 : t2, indices, null).get$uri(); |
| } else { |
| if (1 >= t1.length) |
| return H.ioore(t1, 1); |
| uri = P.Uri_parse(t1[1], 0, null); |
| } |
| if (uri.get$scheme() === "") { |
| t2 = $.$get$context(); |
| uri = t2.toUri$1(t2.absolute$7(0, t2.style.pathFromUri$1(M._parseUri(uri)), null, null, null, null, null, null)); |
| } |
| if (2 >= t1.length) |
| return H.ioore(t1, 2); |
| t2 = t1[2]; |
| line = t2 == null ? null : H.Primitives_parseInt(t2, null, null); |
| if (3 >= t1.length) |
| return H.ioore(t1, 3); |
| t2 = t1[3]; |
| column = t2 == null ? null : H.Primitives_parseInt(t2, null, null); |
| if (4 >= t1.length) |
| return H.ioore(t1, 4); |
| return new A.Frame(uri, line, column, t1[4]); |
| } |
| } |
| }], ["", "package:stack_trace/src/lazy_trace.dart",, T, { |
| "^": "", |
| LazyTrace: { |
| "^": "Object;_thunk,_inner", |
| get$_lazy_trace$_trace: function() { |
| var t1 = this._inner; |
| if (t1 == null) { |
| t1 = this._thunk.call$0(); |
| this._inner = t1; |
| } |
| return t1; |
| }, |
| get$frames: function() { |
| return this.get$_lazy_trace$_trace().get$frames(); |
| }, |
| get$terse: function() { |
| return new T.LazyTrace(new T.LazyTrace_terse_closure(this), null); |
| }, |
| foldFrames$2$terse: function(predicate, terse) { |
| return new T.LazyTrace(new T.LazyTrace_foldFrames_closure(this, predicate, true), null); |
| }, |
| toString$0: function(_) { |
| return J.toString$0$(this.get$_lazy_trace$_trace()); |
| }, |
| $isTrace: 1 |
| }, |
| LazyTrace_terse_closure: { |
| "^": "Closure:1;$this", |
| call$0: function() { |
| return this.$this.get$_lazy_trace$_trace().get$terse(); |
| } |
| }, |
| LazyTrace_foldFrames_closure: { |
| "^": "Closure:1;$this,predicate,terse", |
| call$0: function() { |
| return this.$this.get$_lazy_trace$_trace().foldFrames$2$terse(this.predicate, this.terse); |
| } |
| } |
| }], ["", "package:stack_trace/src/trace.dart",, Y, { |
| "^": "", |
| Trace: { |
| "^": "Object;frames<,original", |
| get$terse: function() { |
| return this.foldFrames$2$terse(new Y.Trace_terse_closure(), true); |
| }, |
| foldFrames$2$terse: function(predicate, terse) { |
| var _box_0, newFrames, t1, frame; |
| _box_0 = {}; |
| _box_0.predicate = predicate; |
| _box_0.predicate = new Y.Trace_foldFrames_closure(predicate); |
| newFrames = H.setRuntimeTypeInfo([], [A.Frame]); |
| for (t1 = this.frames, t1 = new H.ReversedListIterable(t1, [H.getTypeArgumentByIndex(t1, 0)]), t1 = new H.ListIterator(t1, t1.get$length(t1), 0, null); t1.moveNext$0();) { |
| frame = t1.__internal$_current; |
| if (frame instanceof N.UnparsedFrame || _box_0.predicate.call$1(frame) !== true) |
| newFrames.push(frame); |
| else if (newFrames.length === 0 || _box_0.predicate.call$1(C.JSArray_methods.get$last(newFrames)) !== true) |
| newFrames.push(new A.Frame(frame.get$uri(), frame.get$line(), frame.get$column(), frame.get$member())); |
| } |
| newFrames = new H.MappedListIterable(newFrames, new Y.Trace_foldFrames_closure0(_box_0), [H.getTypeArgumentByIndex(newFrames, 0), null]).toList$0(0); |
| if (newFrames.length > 1 && _box_0.predicate.call$1(C.JSArray_methods.get$first(newFrames)) === true) |
| C.JSArray_methods.removeAt$1(newFrames, 0); |
| return Y.Trace$(new H.ReversedListIterable(newFrames, [H.getTypeArgumentByIndex(newFrames, 0)]), this.original._stackTrace); |
| }, |
| toString$0: function(_) { |
| var t1, t2; |
| t1 = this.frames; |
| t2 = [H.getTypeArgumentByIndex(t1, 0), null]; |
| return new H.MappedListIterable(t1, new Y.Trace_toString_closure(new H.MappedListIterable(t1, new Y.Trace_toString_closure0(), t2).fold$2(0, 0, P.math__max$closure())), t2).join$0(0); |
| }, |
| $isStackTrace: 1, |
| static: { |
| Trace_Trace$from: function(trace) { |
| var t1; |
| if (trace == null) |
| throw H.wrapException(P.ArgumentError$("Cannot create a Trace from null.")); |
| t1 = J.getInterceptor(trace); |
| if (!!t1.$isTrace) |
| return trace; |
| if (!!t1.$isChain) |
| return trace.toTrace$0(); |
| return new T.LazyTrace(new Y.closure0(trace), null); |
| }, |
| Trace_Trace$parse: function(trace) { |
| var error, t1, exception; |
| try { |
| t1 = J.getInterceptor$asx(trace); |
| if (t1.get$isEmpty(trace) === true) { |
| t1 = Y.Trace$(H.setRuntimeTypeInfo([], [A.Frame]), null); |
| return t1; |
| } |
| if (t1.contains$1(trace, $.$get$_v8Trace()) === true) { |
| t1 = Y.Trace$parseV8(trace); |
| return t1; |
| } |
| if (t1.contains$1(trace, "\tat ") === true) { |
| t1 = Y.Trace$parseJSCore(trace); |
| return t1; |
| } |
| if (t1.contains$1(trace, $.$get$_firefoxSafariTrace()) === true) { |
| t1 = Y.Trace$parseFirefox(trace); |
| return t1; |
| } |
| if (t1.contains$1(trace, "===== asynchronous gap ===========================\n") === true) { |
| t1 = U.Chain_Chain$parse(trace).toTrace$0(); |
| return t1; |
| } |
| if (t1.contains$1(trace, $.$get$_friendlyTrace()) === true) { |
| t1 = Y.Trace$parseFriendly(trace); |
| return t1; |
| } |
| t1 = P.List_List$unmodifiable(Y.Trace__parseVM(trace), A.Frame); |
| return new Y.Trace(t1, new P._StringStackTrace(trace)); |
| } catch (exception) { |
| t1 = H.unwrapException(exception); |
| if (t1 instanceof P.FormatException) { |
| error = t1; |
| throw H.wrapException(new P.FormatException(H.S(J.get$message$x(error)) + "\nStack trace:\n" + H.S(trace), null, null)); |
| } else |
| throw exception; |
| } |
| }, |
| Trace__parseVM: function(trace) { |
| var lines, t1, $frames; |
| lines = H.setRuntimeTypeInfo(H.stringReplaceAllUnchecked(J.trim$0$s(trace), "<asynchronous suspension>\n", "").split("\n"), [P.String]); |
| t1 = H.SubListIterable$(lines, 0, lines.length - 1, H.getTypeArgumentByIndex(lines, 0)); |
| $frames = new H.MappedListIterable(t1, new Y.Trace__parseVM_closure(), [H.getTypeArgumentByIndex(t1, 0), null]).toList$0(0); |
| if (!J.endsWith$1$s(C.JSArray_methods.get$last(lines), ".da")) |
| C.JSArray_methods.add$1($frames, A.Frame_Frame$parseVM(C.JSArray_methods.get$last(lines))); |
| return $frames; |
| }, |
| Trace$parseV8: function(trace) { |
| var t1 = J.split$1$s(trace, "\n"); |
| t1 = H.SubListIterable$(t1, 1, null, H.getTypeArgumentByIndex(t1, 0)).super$Iterable$skipWhile(0, new Y.Trace$parseV8_closure()); |
| return new Y.Trace(P.List_List$unmodifiable(H.MappedIterable_MappedIterable(t1, new Y.Trace$parseV8_closure0(), H.getTypeArgumentByIndex(t1, 0), null), A.Frame), new P._StringStackTrace(trace)); |
| }, |
| Trace$parseJSCore: function(trace) { |
| var t1, t2; |
| t1 = J.split$1$s(trace, "\n"); |
| t2 = H.getTypeArgumentByIndex(t1, 0); |
| return new Y.Trace(P.List_List$unmodifiable(new H.MappedIterable(new H.WhereIterable(t1, new Y.Trace$parseJSCore_closure(), [t2]), new Y.Trace$parseJSCore_closure0(), [t2, null]), A.Frame), new P._StringStackTrace(trace)); |
| }, |
| Trace$parseFirefox: function(trace) { |
| var t1, t2; |
| t1 = H.setRuntimeTypeInfo(J.trim$0$s(trace).split("\n"), [P.String]); |
| t2 = H.getTypeArgumentByIndex(t1, 0); |
| return new Y.Trace(P.List_List$unmodifiable(new H.MappedIterable(new H.WhereIterable(t1, new Y.Trace$parseFirefox_closure(), [t2]), new Y.Trace$parseFirefox_closure0(), [t2, null]), A.Frame), new P._StringStackTrace(trace)); |
| }, |
| Trace$parseFriendly: function(trace) { |
| var t1, t2; |
| t1 = J.getInterceptor$asx(trace); |
| if (t1.get$isEmpty(trace) === true) |
| t1 = []; |
| else { |
| t1 = H.setRuntimeTypeInfo(t1.trim$0(trace).split("\n"), [P.String]); |
| t2 = H.getTypeArgumentByIndex(t1, 0); |
| t2 = new H.MappedIterable(new H.WhereIterable(t1, new Y.Trace$parseFriendly_closure(), [t2]), new Y.Trace$parseFriendly_closure0(), [t2, null]); |
| t1 = t2; |
| } |
| return new Y.Trace(P.List_List$unmodifiable(t1, A.Frame), new P._StringStackTrace(trace)); |
| }, |
| Trace$: function($frames, original) { |
| return new Y.Trace(P.List_List$unmodifiable($frames, A.Frame), new P._StringStackTrace(original)); |
| } |
| } |
| }, |
| closure0: { |
| "^": "Closure:1;trace", |
| call$0: function() { |
| return Y.Trace_Trace$parse(J.toString$0$(this.trace)); |
| } |
| }, |
| Trace__parseVM_closure: { |
| "^": "Closure:0;", |
| call$1: [function(line) { |
| return A.Frame_Frame$parseVM(line); |
| }, null, null, 2, 0, null, 7, "call"] |
| }, |
| Trace$parseV8_closure: { |
| "^": "Closure:0;", |
| call$1: function(line) { |
| return !J.startsWith$1$s(line, $.$get$_v8TraceLine()); |
| } |
| }, |
| Trace$parseV8_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(line) { |
| return A.Frame_Frame$parseV8(line); |
| }, null, null, 2, 0, null, 7, "call"] |
| }, |
| Trace$parseJSCore_closure: { |
| "^": "Closure:0;", |
| call$1: function(line) { |
| return !J.$eq$(line, "\tat "); |
| } |
| }, |
| Trace$parseJSCore_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(line) { |
| return A.Frame_Frame$parseV8(line); |
| }, null, null, 2, 0, null, 7, "call"] |
| }, |
| Trace$parseFirefox_closure: { |
| "^": "Closure:0;", |
| call$1: function(line) { |
| var t1 = J.getInterceptor$asx(line); |
| return t1.get$isNotEmpty(line) && !t1.$eq(line, "[native code]"); |
| } |
| }, |
| Trace$parseFirefox_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(line) { |
| return A.Frame_Frame$parseFirefox(line); |
| }, null, null, 2, 0, null, 7, "call"] |
| }, |
| Trace$parseFriendly_closure: { |
| "^": "Closure:0;", |
| call$1: function(line) { |
| return !J.startsWith$1$s(line, "====="); |
| } |
| }, |
| Trace$parseFriendly_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(line) { |
| return A.Frame_Frame$parseFriendly(line); |
| }, null, null, 2, 0, null, 7, "call"] |
| }, |
| Trace_terse_closure: { |
| "^": "Closure:0;", |
| call$1: function(_) { |
| return false; |
| } |
| }, |
| Trace_foldFrames_closure: { |
| "^": "Closure:0;oldPredicate", |
| call$1: function(frame) { |
| if (this.oldPredicate.call$1(frame) === true) |
| return true; |
| if (frame.get$isCore()) |
| return true; |
| if (J.$eq$(frame.get$$package(), "stack_trace")) |
| return true; |
| if (J.contains$1$asx(frame.get$member(), "<async>") !== true) |
| return false; |
| return frame.get$line() == null; |
| } |
| }, |
| Trace_foldFrames_closure0: { |
| "^": "Closure:0;_box_0", |
| call$1: [function(frame) { |
| if (frame instanceof N.UnparsedFrame || this._box_0.predicate.call$1(frame) !== true) |
| return frame; |
| return new A.Frame(P.Uri_parse(J.replaceAll$2$s(frame.get$library(), $.$get$_terseRegExp(), ""), 0, null), null, null, frame.get$member()); |
| }, null, null, 2, 0, null, 6, "call"] |
| }, |
| Trace_toString_closure0: { |
| "^": "Closure:0;", |
| call$1: [function(frame) { |
| return J.get$length$asx(J.get$location$x(frame)); |
| }, null, null, 2, 0, null, 6, "call"] |
| }, |
| Trace_toString_closure: { |
| "^": "Closure:0;longest", |
| call$1: [function(frame) { |
| var t1 = J.getInterceptor(frame); |
| if (!!t1.$isUnparsedFrame) |
| return H.S(frame) + "\n"; |
| return J.padRight$1$s(t1.get$location(frame), this.longest) + " " + H.S(frame.get$member()) + "\n"; |
| }, null, null, 2, 0, null, 6, "call"] |
| } |
| }], ["", "package:stack_trace/src/unparsed_frame.dart",, N, { |
| "^": "", |
| UnparsedFrame: { |
| "^": "Object;uri<,line<,column<,isCore<,library<,$package<,location>,member<", |
| toString$0: function(_) { |
| return this.member; |
| } |
| } |
| }], ["", "package:stream_channel/src/guarantee_channel.dart",, K, { |
| "^": "", |
| GuaranteeChannel: { |
| "^": "StreamChannelMixin;_sink,_streamController,_guarantee_channel$_subscription,_disconnected,$ti", |
| GuaranteeChannel$3$allowSinkErrors: function(innerSink, allowSinkErrors, _box_0, $T) { |
| this._sink = new K._GuaranteeSink(innerSink, this, new P._AsyncCompleter(new P._Future(0, $.Zone__current, null, [null]), [null]), false, false, null, null, true, [$T]); |
| this._streamController = new P._SyncStreamController(null, 0, null, new K.GuaranteeChannel_closure(_box_0, this), null, null, null, [$T]); |
| }, |
| _onSinkDisconnected$0: function() { |
| this._disconnected = true; |
| var t1 = this._guarantee_channel$_subscription; |
| if (t1 != null) |
| t1.cancel$0(); |
| this._streamController.close$0(0); |
| }, |
| static: { |
| GuaranteeChannel$: function(innerStream, innerSink, allowSinkErrors, $T) { |
| var t1, t2; |
| t1 = {}; |
| t1.innerStream = innerStream; |
| t2 = new K.GuaranteeChannel(null, null, null, false, [$T]); |
| t2.GuaranteeChannel$3$allowSinkErrors(innerSink, true, t1, $T); |
| return t2; |
| } |
| } |
| }, |
| GuaranteeChannel_closure: { |
| "^": "Closure:1;_box_0,$this", |
| call$0: function() { |
| var t1, t2, t3; |
| t1 = this.$this; |
| if (t1._disconnected) |
| return; |
| t2 = this._box_0.innerStream; |
| t3 = t1._streamController; |
| t1._guarantee_channel$_subscription = t2.listen$3$onDone$onError(t3.get$add(t3), new K.GuaranteeChannel__closure(t1), t3.get$addError()); |
| } |
| }, |
| GuaranteeChannel__closure: { |
| "^": "Closure:1;$this", |
| call$0: [function() { |
| var t1 = this.$this; |
| t1._sink._onStreamDisconnected$0(); |
| t1._streamController.close$0(0); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _GuaranteeSink: { |
| "^": "Object;_guarantee_channel$_inner,_channel,_doneCompleter,_disconnected,_closed,_addStreamSubscription,_addStreamCompleter,_allowErrors,$ti", |
| add$1: function(_, data) { |
| var t1; |
| if (this._closed) |
| throw H.wrapException(new P.StateError("Cannot add event after closing.")); |
| if (this._addStreamSubscription != null) |
| throw H.wrapException(new P.StateError("Cannot add event while adding stream.")); |
| if (this._disconnected) |
| return; |
| t1 = this._guarantee_channel$_inner._async$_target; |
| if (t1._state >= 4) |
| H.throwExpression(t1._badEventState$0()); |
| t1._async$_add$1(data); |
| }, |
| addError$2: [function(error, stackTrace) { |
| if (this._closed) |
| throw H.wrapException(new P.StateError("Cannot add event after closing.")); |
| if (this._addStreamSubscription != null) |
| throw H.wrapException(new P.StateError("Cannot add event while adding stream.")); |
| if (this._disconnected) |
| return; |
| this._guarantee_channel$_addError$2(error, stackTrace); |
| }, function(error) { |
| return this.addError$2(error, null); |
| }, "addError$1", "call$2", "call$1", "get$addError", 2, 2, 9, 3, 0, 1], |
| _guarantee_channel$_addError$2: [function(error, stackTrace) { |
| this._guarantee_channel$_inner._async$_target.addError$2(error, stackTrace); |
| return; |
| }, function(error) { |
| return this._guarantee_channel$_addError$2(error, null); |
| }, "_guarantee_channel$_addError$1", "call$2", "call$1", "get$_guarantee_channel$_addError", 2, 2, 9, 3, 0, 1], |
| addStream$1: function(stream) { |
| var t1, t2; |
| if (this._closed) |
| throw H.wrapException(new P.StateError("Cannot add stream after closing.")); |
| if (this._addStreamSubscription != null) |
| throw H.wrapException(new P.StateError("Cannot add stream while adding stream.")); |
| if (this._disconnected) { |
| t1 = new P._Future(0, $.Zone__current, null, [null]); |
| t1._asyncComplete$1(null); |
| return t1; |
| } |
| t1 = new P._SyncCompleter(new P._Future(0, $.Zone__current, null, [null]), [null]); |
| this._addStreamCompleter = t1; |
| t2 = this._guarantee_channel$_inner; |
| this._addStreamSubscription = stream.listen$3$onDone$onError(t2.get$add(t2), t1.get$complete(t1), this.get$_guarantee_channel$_addError()); |
| return this._addStreamCompleter.future.then$1(new K._GuaranteeSink_addStream_closure(this)); |
| }, |
| close$0: function(_) { |
| if (this._addStreamSubscription != null) |
| throw H.wrapException(new P.StateError("Cannot close sink while adding stream.")); |
| if (this._closed) |
| return this._doneCompleter.future; |
| this._closed = true; |
| if (!this._disconnected) { |
| this._channel._onSinkDisconnected$0(); |
| this._doneCompleter.complete$1(0, this._guarantee_channel$_inner._async$_target.close$0(0)); |
| } |
| return this._doneCompleter.future; |
| }, |
| _onStreamDisconnected$0: function() { |
| this._disconnected = true; |
| var t1 = this._doneCompleter; |
| if (t1.future._state === 0) |
| t1.complete$0(0); |
| t1 = this._addStreamSubscription; |
| if (t1 == null) |
| return; |
| this._addStreamCompleter.complete$1(0, t1.cancel$0()); |
| this._addStreamCompleter = null; |
| this._addStreamSubscription = null; |
| } |
| }, |
| _GuaranteeSink_addStream_closure: { |
| "^": "Closure:0;$this", |
| call$1: [function(_) { |
| var t1 = this.$this; |
| t1._addStreamCompleter = null; |
| t1._addStreamSubscription = null; |
| }, null, null, 2, 0, null, 2, "call"] |
| } |
| }], ["", "package:stream_channel/src/multi_channel.dart",, D, { |
| "^": "", |
| _MultiChannel: { |
| "^": "StreamChannelMixin;_multi_channel$_inner,_innerStreamSubscription,_mainController,_controllers,_nextId", |
| _MultiChannel$1: function(_inner) { |
| var t1, t2; |
| t1 = this._mainController; |
| this._controllers.$indexSet(0, 0, t1); |
| t2 = t1._local._streamController; |
| t2.toString; |
| new P._ControllerStream(t2, [H.getTypeArgumentByIndex(t2, 0)]).listen$2$onDone(new D._MultiChannel_closure(this), new D._MultiChannel_closure0(this)); |
| t2 = this._multi_channel$_inner._streamController; |
| t2.toString; |
| this._innerStreamSubscription = new P._ControllerStream(t2, [H.getTypeArgumentByIndex(t2, 0)]).listen$3$onDone$onError(new D._MultiChannel_closure1(this), this.get$_closeInnerChannel(), t1._local._sink.get$addError()); |
| }, |
| virtualChannel$1: function(id) { |
| var t1, t2, inputId, t3, controller; |
| t1 = {}; |
| t1.inputId = null; |
| t1.outputId = null; |
| if (id != null) { |
| t1.inputId = id; |
| H.intTypeCast(id); |
| t1.outputId = id + 1; |
| t2 = id; |
| } else { |
| t2 = this._nextId; |
| inputId = t2 + 1; |
| t1.inputId = inputId; |
| t1.outputId = t2; |
| this._nextId = t2 + 2; |
| t2 = inputId; |
| } |
| if (this._multi_channel$_inner == null) { |
| t1 = new P._Future(0, $.Zone__current, null, [null]); |
| t1._asyncComplete$1(null); |
| return new D.VirtualChannel(this, t2, new P._EmptyStream([null]), new S.NullStreamSink(t1, false, false, [null])); |
| } |
| t3 = this._controllers; |
| if (t3.containsKey$1(t2)) |
| throw H.wrapException(P.ArgumentError$("A virtual channel with id " + H.S(id) + " already exists.")); |
| controller = B.StreamChannelController$(true, true, null); |
| t3.$indexSet(0, t2, controller); |
| t2 = controller._local._streamController; |
| t2.toString; |
| new P._ControllerStream(t2, [H.getTypeArgumentByIndex(t2, 0)]).listen$2$onDone(new D._MultiChannel_virtualChannel_closure(t1, this), new D._MultiChannel_virtualChannel_closure0(t1, this)); |
| t1 = t1.outputId; |
| t2 = controller._foreign; |
| t3 = t2._streamController; |
| t3.toString; |
| return new D.VirtualChannel(this, t1, new P._ControllerStream(t3, [H.getTypeArgumentByIndex(t3, 0)]), t2._sink); |
| }, |
| _closeChannel$2: function(inputId, outputId) { |
| var t1, t2; |
| t1 = this._controllers; |
| t1.remove$1(0, inputId).get$local()._sink.close$0(0); |
| t2 = this._multi_channel$_inner; |
| if (t2 == null) |
| return; |
| t2._sink.add$1(0, [outputId]); |
| if (t1.get$isEmpty(t1)) |
| this._closeInnerChannel$0(); |
| }, |
| _closeInnerChannel$0: [function() { |
| var t1, t2, t3, _i; |
| this._multi_channel$_inner._sink.close$0(0); |
| this._innerStreamSubscription.cancel$0(); |
| this._multi_channel$_inner = null; |
| for (t1 = this._controllers, t2 = P.List_List$from(t1.get$values(t1), true, null), t3 = t2.length, _i = 0; _i < t2.length; t2.length === t3 || (0, H.throwConcurrentModificationError)(t2), ++_i) |
| t2[_i].get$local()._sink.close$0(0); |
| t1.clear$0(0); |
| }, "call$0", "get$_closeInnerChannel", 0, 0, 2], |
| static: { |
| _MultiChannel$: function(_inner) { |
| var t1 = new D._MultiChannel(_inner, null, B.StreamChannelController$(true, true, null), P.LinkedHashMap_LinkedHashMap$_empty(P.int, B.StreamChannelController), 1); |
| t1._MultiChannel$1(_inner); |
| return t1; |
| } |
| } |
| }, |
| _MultiChannel_closure: { |
| "^": "Closure:0;$this", |
| call$1: [function(message) { |
| return this.$this._multi_channel$_inner._sink.add$1(0, [0, message]); |
| }, null, null, 2, 0, null, 4, "call"] |
| }, |
| _MultiChannel_closure0: { |
| "^": "Closure:1;$this", |
| call$0: [function() { |
| return this.$this._closeChannel$2(0, 0); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| _MultiChannel_closure1: { |
| "^": "Closure:0;$this", |
| call$1: [function(message) { |
| var t1, controller; |
| t1 = J.getInterceptor$asx(message); |
| controller = this.$this._controllers.$index(0, t1.$index(message, 0)); |
| if (controller == null) |
| return; |
| if (J.$gt$n(t1.get$length(message), 1)) { |
| controller._local._sink.add$1(0, t1.$index(message, 1)); |
| return; |
| } |
| controller._local._sink.close$0(0); |
| }, null, null, 2, 0, null, 4, "call"] |
| }, |
| _MultiChannel_virtualChannel_closure: { |
| "^": "Closure:0;_box_0,$this", |
| call$1: [function(message) { |
| return this.$this._multi_channel$_inner._sink.add$1(0, [this._box_0.outputId, message]); |
| }, null, null, 2, 0, null, 4, "call"] |
| }, |
| _MultiChannel_virtualChannel_closure0: { |
| "^": "Closure:1;_box_0,$this", |
| call$0: [function() { |
| var t1 = this._box_0; |
| return this.$this._closeChannel$2(t1.inputId, t1.outputId); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| VirtualChannel: { |
| "^": "StreamChannelMixin;_parent,id,stream,sink" |
| } |
| }], ["", "package:stream_channel/src/stream_channel_controller.dart",, B, { |
| "^": "", |
| StreamChannelController: { |
| "^": "Object;_local,_foreign,$ti", |
| get$local: function() { |
| return this._local; |
| }, |
| StreamChannelController$2$allowForeignErrors$sync: function(allowForeignErrors, sync, $T) { |
| var t1, localToForeignController, foreignToLocalController; |
| t1 = [$T]; |
| localToForeignController = new P._SyncStreamController(null, 0, null, null, null, null, null, t1); |
| foreignToLocalController = new P._SyncStreamController(null, 0, null, null, null, null, null, t1); |
| this._local = K.GuaranteeChannel$(new P._ControllerStream(foreignToLocalController, [$T]), new P._StreamSinkWrapper(localToForeignController, [$T]), true, null); |
| this._foreign = K.GuaranteeChannel$(new P._ControllerStream(localToForeignController, [$T]), new P._StreamSinkWrapper(foreignToLocalController, [$T]), true, null); |
| }, |
| static: { |
| StreamChannelController$: function(allowForeignErrors, sync, $T) { |
| var t1 = new B.StreamChannelController(null, null, [$T]); |
| t1.StreamChannelController$2$allowForeignErrors$sync(true, true, $T); |
| return t1; |
| } |
| } |
| } |
| }], ["", "package:stream_channel/stream_channel.dart",, R, { |
| "^": "", |
| StreamChannelMixin: { |
| "^": "Object;" |
| } |
| }], ["test.host", "../../../../../tool/host.dart",, K, { |
| "^": "", |
| main: [function() { |
| var t1 = self.testRunner; |
| if (!(t1 == null)) |
| J.waitUntilDone$0$x(t1); |
| if (J.$eq$($.$get$_currentUrl().get$queryParameters().$index(0, "debug"), "true")) |
| document.body.classList.add("debug"); |
| P.runZoned(new K.main_closure(), new K.main_closure0(), null, null); |
| }, "call$0", "host__main$closure", 0, 0, 2], |
| _connectToServer: function() { |
| var webSocket, controller, t1; |
| webSocket = W.WebSocket_WebSocket($.$get$_currentUrl().get$queryParameters().$index(0, "managerUrl"), null); |
| controller = B.StreamChannelController$(true, true, null); |
| W._EventStreamSubscription$(webSocket, "message", new K._connectToServer_closure(controller), false); |
| t1 = controller._local._streamController; |
| t1.toString; |
| new P._ControllerStream(t1, [H.getTypeArgumentByIndex(t1, 0)]).listen$1(new K._connectToServer_closure0(webSocket)); |
| return D._MultiChannel$(controller._foreign); |
| }, |
| _connectToIframe: function(url, id) { |
| var t1, iframe, controller, readyCompleter, subscriptions; |
| t1 = document; |
| iframe = t1.createElement("iframe"); |
| $.$get$_iframes().$indexSet(0, id, iframe); |
| iframe.src = url; |
| t1.body.appendChild(iframe); |
| controller = B.StreamChannelController$(true, true, null); |
| readyCompleter = new P._AsyncCompleter(new P._Future(0, $.Zone__current, null, [null]), [null]); |
| subscriptions = H.setRuntimeTypeInfo([], [P.StreamSubscription]); |
| $.$get$_subscriptions().$indexSet(0, id, subscriptions); |
| subscriptions.push(W._EventStreamSubscription$(window, "message", new K._connectToIframe_closure(iframe, controller, readyCompleter), false)); |
| t1 = controller._local._streamController; |
| t1.toString; |
| subscriptions.push(new P._ControllerStream(t1, [H.getTypeArgumentByIndex(t1, 0)]).listen$1(new K._connectToIframe_closure0(iframe, readyCompleter))); |
| return controller._foreign; |
| }, |
| _TestRunner: { |
| "^": "JavaScriptObject;", |
| "%": "" |
| }, |
| _JSApi: { |
| "^": "JavaScriptObject;", |
| "%": "" |
| }, |
| main_closure: { |
| "^": "Closure:1;", |
| call$0: [function() { |
| var serverChannel, t1; |
| serverChannel = K._connectToServer(); |
| t1 = serverChannel._mainController._foreign._streamController; |
| t1.toString; |
| new P._ControllerStream(t1, [H.getTypeArgumentByIndex(t1, 0)]).listen$1(new K.main__closure(serverChannel)); |
| P.Timer_Timer$periodic(P.Duration$(0, 0, 0, 0, 0, 1), new K.main__closure0(serverChannel)); |
| t1 = J.get$onClick$x(document.querySelector("#play")); |
| W._EventStreamSubscription$(t1._html$_target, t1._eventType, new K.main__closure1(serverChannel), false); |
| t1 = P.allowInterop(new K.main__closure2(serverChannel)); |
| t1 = {restartCurrent: P.allowInterop(new K.main__closure3(serverChannel)), resume: t1}; |
| self.dartTest = t1; |
| }, null, null, 0, 0, null, "call"] |
| }, |
| main__closure: { |
| "^": "Closure:0;serverChannel", |
| call$1: [function(message) { |
| var t1, suiteChannel, iframeChannel; |
| t1 = J.getInterceptor$asx(message); |
| if (J.$eq$(t1.$index(message, "command"), "loadSuite")) { |
| suiteChannel = this.serverChannel.virtualChannel$1(t1.$index(message, "channel")); |
| iframeChannel = K._connectToIframe(t1.$index(message, "url"), t1.$index(message, "id")); |
| suiteChannel.stream.pipe$1(iframeChannel._sink); |
| t1 = iframeChannel._streamController; |
| t1.toString; |
| new P._ControllerStream(t1, [H.getTypeArgumentByIndex(t1, 0)]).pipe$1(suiteChannel.sink); |
| } else if (J.$eq$(t1.$index(message, "command"), "displayPause")) |
| document.body.classList.add("paused"); |
| else if (J.$eq$(t1.$index(message, "command"), "resume")) |
| document.body.classList.remove("paused"); |
| else { |
| J.remove$0$ax($.$get$_iframes().remove$1(0, t1.$index(message, "id"))); |
| for (t1 = J.get$iterator$ax($.$get$_subscriptions().remove$1(0, t1.$index(message, "id"))); t1.moveNext$0();) |
| t1.get$current().cancel$0(); |
| } |
| }, null, null, 2, 0, null, 4, "call"] |
| }, |
| main__closure0: { |
| "^": "Closure:0;serverChannel", |
| call$1: [function(_) { |
| return this.serverChannel._mainController._foreign._sink.add$1(0, P.LinkedHashMap__makeLiteral(["command", "ping"])); |
| }, null, null, 2, 0, null, 2, "call"] |
| }, |
| main__closure1: { |
| "^": "Closure:0;serverChannel", |
| call$1: function(_) { |
| var list, removed; |
| list = document.body.classList; |
| removed = list.contains("paused"); |
| list.remove("paused"); |
| if (!removed) |
| return; |
| this.serverChannel._mainController._foreign._sink.add$1(0, P.LinkedHashMap__makeLiteral(["command", "resume"])); |
| } |
| }, |
| main__closure2: { |
| "^": "Closure:1;serverChannel", |
| call$0: [function() { |
| var list, removed; |
| list = document.body.classList; |
| removed = list.contains("paused"); |
| list.remove("paused"); |
| if (!removed) |
| return; |
| this.serverChannel._mainController._foreign._sink.add$1(0, P.LinkedHashMap__makeLiteral(["command", "resume"])); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| main__closure3: { |
| "^": "Closure:1;serverChannel", |
| call$0: [function() { |
| this.serverChannel._mainController._foreign._sink.add$1(0, P.LinkedHashMap__makeLiteral(["command", "restart"])); |
| }, null, null, 0, 0, null, "call"] |
| }, |
| main_closure0: { |
| "^": "Closure:3;", |
| call$2: [function(error, stackTrace) { |
| P.print(H.S(error) + "\n" + H.S(Y.Trace_Trace$from(stackTrace).get$terse())); |
| }, null, null, 4, 0, null, 0, 1, "call"] |
| }, |
| _connectToServer_closure: { |
| "^": "Closure:0;controller", |
| call$1: function(message) { |
| this.controller._local._sink.add$1(0, C.JsonCodec_null_null.decode$1(J.get$data$x(message))); |
| } |
| }, |
| _connectToServer_closure0: { |
| "^": "Closure:0;webSocket", |
| call$1: [function(message) { |
| return this.webSocket.send(C.JsonCodec_null_null.encode$1(message)); |
| }, null, null, 2, 0, null, 4, "call"] |
| }, |
| _connectToIframe_closure: { |
| "^": "Closure:0;iframe,controller,readyCompleter", |
| call$1: function(message) { |
| var t1, t2, t3; |
| t1 = J.getInterceptor$x(message); |
| t2 = t1.get$origin(message); |
| t3 = window.location; |
| if (t2 !== (t3 && C.Location_methods).get$origin(t3)) |
| return; |
| if (!J.$eq$(J.$index$asx(t1.get$data(message), "href"), this.iframe.src)) |
| return; |
| t1.stopPropagation$0(message); |
| if (J.$eq$(J.$index$asx(t1.get$data(message), "ready"), true)) |
| this.readyCompleter.complete$0(0); |
| else |
| this.controller._local._sink.add$1(0, J.$index$asx(t1.get$data(message), "data")); |
| } |
| }, |
| _connectToIframe_closure0: { |
| "^": "Closure:26;iframe,readyCompleter", |
| call$1: [function(message) { |
| var $async$goto = 0, $async$completer = P.Completer_Completer$sync(), $async$self = this, t1, t2; |
| var $async$call$1 = P._wrapJsFunctionForAsync(function($async$errorCode, $async$result) { |
| if ($async$errorCode === 1) |
| return P._asyncRethrow($async$result, $async$completer); |
| while (true) |
| switch ($async$goto) { |
| case 0: |
| // Function start |
| $async$goto = 2; |
| return P._asyncAwait($async$self.readyCompleter.future, $async$call$1); |
| case 2: |
| // returning from await. |
| t1 = W._convertNativeToDart_Window($async$self.iframe.contentWindow); |
| t2 = window.location; |
| J.postMessage$2$x(t1, message, (t2 && C.Location_methods).get$origin(t2)); |
| // implicit return |
| return P._asyncReturn(null, $async$completer); |
| } |
| }); |
| return P._asyncStart($async$call$1, $async$completer); |
| }, null, null, 2, 0, null, 4, "call"] |
| } |
| }, 1]]; |
| setupProgram(dart, 0, 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") { |
| if (typeof receiver == "function") |
| return J.JavaScriptFunction.prototype; |
| 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") { |
| if (typeof receiver == "function") |
| return J.JavaScriptFunction.prototype; |
| 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") { |
| if (typeof receiver == "function") |
| return J.JavaScriptFunction.prototype; |
| 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") { |
| if (typeof receiver == "function") |
| return J.JavaScriptFunction.prototype; |
| return receiver; |
| } |
| if (receiver instanceof P.Object) |
| return receiver; |
| return J.getNativeInterceptor(receiver); |
| }; |
| J.get$codeUnits$s = function(receiver) { |
| return J.getInterceptor$s(receiver).get$codeUnits(receiver); |
| }; |
| J.get$data$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$data(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$isNotEmpty$asx = function(receiver) { |
| return J.getInterceptor$asx(receiver).get$isNotEmpty(receiver); |
| }; |
| J.get$iterator$ax = function(receiver) { |
| return J.getInterceptor$ax(receiver).get$iterator(receiver); |
| }; |
| J.get$length$asx = function(receiver) { |
| return J.getInterceptor$asx(receiver).get$length(receiver); |
| }; |
| J.get$location$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$location(receiver); |
| }; |
| J.get$message$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$message(receiver); |
| }; |
| J.get$onClick$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$onClick(receiver); |
| }; |
| J.get$parent$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$parent(receiver); |
| }; |
| J.get$result$x = function(receiver) { |
| return J.getInterceptor$x(receiver).get$result(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.$and$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return (receiver & a0) >>> 0; |
| return J.getInterceptor$n(receiver).$and(receiver, a0); |
| }; |
| J.$ge$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver >= a0; |
| return J.getInterceptor$n(receiver).$ge(receiver, a0); |
| }; |
| J.$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 (typeof a0 === "number") |
| if (receiver.constructor == Array || typeof receiver == "string" || H.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) |
| if (a0 >>> 0 === a0 && a0 < receiver.length) |
| return receiver[a0]; |
| return J.getInterceptor$asx(receiver).$index(receiver, a0); |
| }; |
| J.$indexSet$ax = function(receiver, a0, a1) { |
| if (typeof a0 === "number") |
| if ((receiver.constructor == Array || H.isJsIndexable(receiver, receiver[init.dispatchPropertyName])) && !receiver.immutable$list && a0 >>> 0 === a0 && a0 < receiver.length) |
| return receiver[a0] = a1; |
| return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); |
| }; |
| J.$le$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver <= a0; |
| return J.getInterceptor$n(receiver).$le(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.$mul$ns = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return receiver * a0; |
| return J.getInterceptor$ns(receiver).$mul(receiver, a0); |
| }; |
| J.$shl$n = function(receiver, a0) { |
| return J.getInterceptor$n(receiver).$shl(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.$xor$n = function(receiver, a0) { |
| if (typeof receiver == "number" && typeof a0 == "number") |
| return (receiver ^ a0) >>> 0; |
| return J.getInterceptor$n(receiver).$xor(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.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.elementAt$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); |
| }; |
| J.endsWith$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).endsWith$1(receiver, a0); |
| }; |
| J.fillRange$3$ax = function(receiver, a0, a1, a2) { |
| return J.getInterceptor$ax(receiver).fillRange$3(receiver, a0, a1, a2); |
| }; |
| 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.matchAsPrefix$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).matchAsPrefix$2(receiver, a0, a1); |
| }; |
| J.padRight$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).padRight$1(receiver, a0); |
| }; |
| J.postMessage$2$x = function(receiver, a0, a1) { |
| return J.getInterceptor$x(receiver).postMessage$2(receiver, a0, a1); |
| }; |
| J.print$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).print$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.replaceFirst$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).replaceFirst$2(receiver, a0, a1); |
| }; |
| J.send$1$x = function(receiver, a0) { |
| return J.getInterceptor$x(receiver).send$1(receiver, a0); |
| }; |
| J.skip$1$ax = function(receiver, a0) { |
| return J.getInterceptor$ax(receiver).skip$1(receiver, a0); |
| }; |
| J.split$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).split$1(receiver, a0); |
| }; |
| J.startsWith$1$s = function(receiver, a0) { |
| return J.getInterceptor$s(receiver).startsWith$1(receiver, a0); |
| }; |
| J.startsWith$2$s = function(receiver, a0, a1) { |
| return J.getInterceptor$s(receiver).startsWith$2(receiver, a0, a1); |
| }; |
| 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.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.waitUntilDone$0$x = function(receiver) { |
| return J.getInterceptor$x(receiver).waitUntilDone$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.noSuchMethod$1$ = function(receiver, a0) { |
| return J.getInterceptor(receiver).noSuchMethod$1(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.Interceptor_methods = J.Interceptor.prototype; |
| C.JSArray_methods = J.JSArray.prototype; |
| C.JSInt_methods = J.JSInt.prototype; |
| C.JSNumber_methods = J.JSNumber.prototype; |
| C.JSString_methods = J.JSString.prototype; |
| C.JavaScriptFunction_methods = J.JavaScriptFunction.prototype; |
| C.Location_methods = W.Location.prototype; |
| C.NativeUint8List_methods = H.NativeUint8List.prototype; |
| C.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype; |
| C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; |
| C.Window_methods = W.Window.prototype; |
| C.AsciiCodec_false = new P.AsciiCodec(false); |
| C.AsciiEncoder_127 = new P.AsciiEncoder(127); |
| C.Base64Encoder_false = new P.Base64Encoder(false); |
| C.Base64Codec_Base64Encoder_false = new P.Base64Codec(C.Base64Encoder_false); |
| C.C_EmptyIterator = new H.EmptyIterator(); |
| 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.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_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_bDt = function() { |
| var toStringFunction = Object.prototype.toString; |
| function getTag(o) { |
| var s = toStringFunction.call(o); |
| return s.substring(8, s.length - 1); |
| } |
| function getUnknownTag(object, tag) { |
| if (/^HTML[A-Z].*Element$/.test(tag)) { |
| var name = toStringFunction.call(object); |
| if (name == "[object Object]") return null; |
| return "HTMLElement"; |
| } |
| } |
| function getUnknownTagGenericBrowser(object, tag) { |
| if (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: getTag, |
| getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, |
| prototypeForTag: prototypeForTag, |
| discriminator: discriminator }; |
| }; |
| C.JS_CONST_gkc = 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.JS_CONST_u2C = function getTagFallback(o) { |
| var s = Object.prototype.toString.call(o); |
| return s.substring(8, s.length - 1); |
| }; |
| C.JsonCodec_null_null = new P.JsonCodec(null, null); |
| C.JsonDecoder_null = new P.JsonDecoder(null); |
| C.JsonEncoder_null_null = new P.JsonEncoder(null, null); |
| C.List_127_2047_65535_1114111 = H.setRuntimeTypeInfo(Isolate.makeConstantList([127, 2047, 65535, 1114111]), [P.int]); |
| C.List_2Vk = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 32776, 33792, 1, 10240, 0, 0]), [P.int]); |
| C.List_CVk = Isolate.makeConstantList([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]); |
| C.List_JYB = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 26624, 1023, 65534, 2047, 65534, 2047]), [P.int]); |
| C.List_WnV = Isolate.makeConstantList(["/", "\\"]); |
| C.List_cSk = Isolate.makeConstantList(["/"]); |
| C.List_empty = H.setRuntimeTypeInfo(Isolate.makeConstantList([]), [P.String]); |
| C.List_empty0 = Isolate.makeConstantList([]); |
| C.List_gRj = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]), [P.int]); |
| C.List_nxB = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 24576, 1023, 65534, 34815, 65534, 18431]), [P.int]); |
| C.List_qFt = Isolate.makeConstantList([0, 0, 27858, 1023, 65534, 51199, 65535, 32767]); |
| C.List_qNA = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]), [P.int]); |
| C.List_qg40 = H.setRuntimeTypeInfo(Isolate.makeConstantList([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]), [P.int]); |
| C.List_qg4 = Isolate.makeConstantList([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]); |
| C.Map_empty = new H.ConstantStringMap(0, {}, C.List_empty, [P.String, P.String]); |
| C.List_empty1 = H.setRuntimeTypeInfo(Isolate.makeConstantList([]), [P.Symbol0]); |
| C.Map_empty0 = new H.ConstantStringMap(0, {}, C.List_empty1, [P.Symbol0, null]); |
| C.Symbol_call = new H.Symbol("call"); |
| C.Utf8Codec_false = new P.Utf8Codec(false); |
| C._ZoneFunction_3bB = new P._ZoneFunction(C.C__RootZone, P.async___rootCreatePeriodicTimer$closure()); |
| C._ZoneFunction_7G2 = new P._ZoneFunction(C.C__RootZone, P.async___rootRegisterBinaryCallback$closure()); |
| C._ZoneFunction_Eeh = new P._ZoneFunction(C.C__RootZone, P.async___rootRegisterUnaryCallback$closure()); |
| C._ZoneFunction_NMc = new P._ZoneFunction(C.C__RootZone, P.async___rootHandleUncaughtError$closure()); |
| C._ZoneFunction__RootZone__rootCreateTimer = new P._ZoneFunction(C.C__RootZone, P.async___rootCreateTimer$closure()); |
| C._ZoneFunction__RootZone__rootErrorCallback = new P._ZoneFunction(C.C__RootZone, P.async___rootErrorCallback$closure()); |
| C._ZoneFunction__RootZone__rootFork = new P._ZoneFunction(C.C__RootZone, P.async___rootFork$closure()); |
| C._ZoneFunction__RootZone__rootPrint = new P._ZoneFunction(C.C__RootZone, P.async___rootPrint$closure()); |
| C._ZoneFunction__RootZone__rootRegisterCallback = new P._ZoneFunction(C.C__RootZone, P.async___rootRegisterCallback$closure()); |
| C._ZoneFunction__RootZone__rootRun = new P._ZoneFunction(C.C__RootZone, P.async___rootRun$closure()); |
| C._ZoneFunction__RootZone__rootRunBinary = new P._ZoneFunction(C.C__RootZone, P.async___rootRunBinary$closure()); |
| C._ZoneFunction__RootZone__rootRunUnary = new P._ZoneFunction(C.C__RootZone, P.async___rootRunUnary$closure()); |
| C._ZoneFunction__RootZone__rootScheduleMicrotask = new P._ZoneFunction(C.C__RootZone, P.async___rootScheduleMicrotask$closure()); |
| C._ZoneSpecification_ALf = new P._ZoneSpecification(null, null, null, null, null, null, null, null, null, null, null, null, null); |
| $.printToZone = null; |
| $.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; |
| $._RootZone__rootDelegate = null; |
| $.Expando__keyCount = 0; |
| $._currentUriBase = null; |
| $._current = 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) { |
| var hunk = $dart_deferred_initializers$[hunkHash]; |
| if (hunk == null) |
| throw "DeferredLoading state error: code with hash '" + hunkHash + "' was not loaded"; |
| hunk($globals$, $); |
| init.deferredInitialized[hunkHash] = true; |
| }; |
| init.deferredLibraryParts = {}; |
| init.deferredPartUris = []; |
| init.deferredPartHashes = []; |
| // Empty type-to-interceptor map. |
| (function(lazies) { |
| for (var i = 0; i < lazies.length;) { |
| var fieldName = lazies[i++]; |
| var getterName = lazies[i++]; |
| var lazyValue = lazies[i++]; |
| var staticName = lazies[i++]; |
| Isolate.$lazy(fieldName, getterName, lazyValue, staticName); |
| } |
| })(["DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", function() { |
| return H.getIsolateAffinityTag("_$dart_dartClosure"); |
| }, "DART_CLOSURE_PROPERTY_NAME", "JS_INTEROP_INTERCEPTOR_TAG", "$get$JS_INTEROP_INTERCEPTOR_TAG", function() { |
| return H.getIsolateAffinityTag("_$dart_js"); |
| }, "JS_INTEROP_INTERCEPTOR_TAG", "IsolateNatives_thisScript", "$get$IsolateNatives_thisScript", function() { |
| return H.IsolateNatives_computeThisScript(); |
| }, "IsolateNatives_thisScript", "IsolateNatives_workerIds", "$get$IsolateNatives_workerIds", function() { |
| if (typeof WeakMap == "function") |
| var t1 = new WeakMap(); |
| else { |
| t1 = $.Expando__keyCount; |
| $.Expando__keyCount = t1 + 1; |
| t1 = "expando$key$" + t1; |
| } |
| return new P.Expando(null, t1); |
| }, "IsolateNatives_workerIds", "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({ |
| toString: function() { |
| return "$receiver$"; |
| } |
| })); |
| }, "TypeErrorDecoder_noSuchMethodPattern", "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({$method$: null, |
| toString: function() { |
| return "$receiver$"; |
| } |
| })); |
| }, "TypeErrorDecoder_notClosurePattern", "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null)); |
| }, "TypeErrorDecoder_nullCallPattern", "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| null.$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_nullLiteralCallPattern", "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0)); |
| }, "TypeErrorDecoder_undefinedCallPattern", "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| var $argumentsExpr$ = '$arguments$'; |
| try { |
| (void 0).$method$($argumentsExpr$); |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_undefinedLiteralCallPattern", "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null)); |
| }, "TypeErrorDecoder_nullPropertyPattern", "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| null.$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_nullLiteralPropertyPattern", "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0)); |
| }, "TypeErrorDecoder_undefinedPropertyPattern", "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", function() { |
| return H.TypeErrorDecoder_extractPattern(function() { |
| try { |
| (void 0).$method$; |
| } catch (e) { |
| return e.message; |
| } |
| }()); |
| }, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", function() { |
| return P._AsyncRun__initializeScheduleImmediate(); |
| }, "_AsyncRun__scheduleImmediateClosure", "Future__nullFuture", "$get$Future__nullFuture", function() { |
| return P._Future$value(null, P.Null); |
| }, "Future__nullFuture", "_RootZone__rootMap", "$get$_RootZone__rootMap", function() { |
| return P.HashMap_HashMap(null, null, null, null, null); |
| }, "_RootZone__rootMap", "_toStringVisiting", "$get$_toStringVisiting", function() { |
| return []; |
| }, "_toStringVisiting", "Utf8Decoder__decoder", "$get$Utf8Decoder__decoder", function() { |
| return P.Utf8Decoder__makeDecoder(); |
| }, "Utf8Decoder__decoder", "_Base64Decoder__inverseAlphabet", "$get$_Base64Decoder__inverseAlphabet", function() { |
| return H.NativeInt8List_NativeInt8List$fromList([-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -1, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2]); |
| }, "_Base64Decoder__inverseAlphabet", "_Uri__isWindowsCached", "$get$_Uri__isWindowsCached", function() { |
| return typeof process != "undefined" && Object.prototype.toString.call(process) == "[object process]" && process.platform == "win32"; |
| }, "_Uri__isWindowsCached", "_Uri__needsNoEncoding", "$get$_Uri__needsNoEncoding", function() { |
| return P.RegExp_RegExp("^[\\-\\.0-9A-Z_a-z~]*$", true, false); |
| }, "_Uri__needsNoEncoding", "_scannerTables", "$get$_scannerTables", function() { |
| return P._createTables(); |
| }, "_scannerTables", "windows", "$get$windows", function() { |
| return M.Context_Context(null, $.$get$Style_windows()); |
| }, "windows", "context", "$get$context", function() { |
| return new M.Context($.$get$Style_platform(), null); |
| }, "context", "Style_posix", "$get$Style_posix", function() { |
| return new E.PosixStyle("posix", "/", C.List_cSk, P.RegExp_RegExp("/", true, false), P.RegExp_RegExp("[^/]$", true, false), P.RegExp_RegExp("^/", true, false), null); |
| }, "Style_posix", "Style_windows", "$get$Style_windows", function() { |
| return new L.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_windows", "Style_url", "$get$Style_url", function() { |
| return new F.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_url", "Style_platform", "$get$Style_platform", function() { |
| return O.Style__getPlatformStyle(); |
| }, "Style_platform", "_vmFrame", "$get$_vmFrame", function() { |
| return P.RegExp_RegExp("^#\\d+\\s+(\\S.*) \\((.+?)((?::\\d+){0,2})\\)$", true, false); |
| }, "_vmFrame", "_v8Frame", "$get$_v8Frame", function() { |
| return P.RegExp_RegExp("^\\s*at (?:(\\S.*?)(?: \\[as [^\\]]+\\])? \\((.*)\\)|(.*))$", true, false); |
| }, "_v8Frame", "_v8UrlLocation", "$get$_v8UrlLocation", function() { |
| return P.RegExp_RegExp("^(.*):(\\d+):(\\d+)|native$", true, false); |
| }, "_v8UrlLocation", "_v8EvalLocation", "$get$_v8EvalLocation", function() { |
| return P.RegExp_RegExp("^eval at (?:\\S.*?) \\((.*)\\)(?:, .*?:\\d+:\\d+)?$", true, false); |
| }, "_v8EvalLocation", "_firefoxSafariFrame", "$get$_firefoxSafariFrame", function() { |
| return P.RegExp_RegExp("^(?:([^@(/]*)(?:\\(.*\\))?((?:/[^/]*)*)(?:\\(.*\\))?@)?(.*?):(\\d*)(?::(\\d*))?$", true, false); |
| }, "_firefoxSafariFrame", "_friendlyFrame", "$get$_friendlyFrame", function() { |
| return P.RegExp_RegExp("^(\\S+)(?: (\\d+)(?::(\\d+))?)?\\s+([^\\d].*)$", true, false); |
| }, "_friendlyFrame", "_asyncBody", "$get$_asyncBody", function() { |
| return P.RegExp_RegExp("<(<anonymous closure>|[^>]+)_async_body>", true, false); |
| }, "_asyncBody", "_initialDot", "$get$_initialDot", function() { |
| return P.RegExp_RegExp("^\\.", true, false); |
| }, "_initialDot", "Frame__uriRegExp", "$get$Frame__uriRegExp", function() { |
| return P.RegExp_RegExp("^[a-zA-Z][-+.a-zA-Z\\d]*://", true, false); |
| }, "Frame__uriRegExp", "Frame__windowsRegExp", "$get$Frame__windowsRegExp", function() { |
| return P.RegExp_RegExp("^([a-zA-Z]:[\\\\/]|\\\\\\\\)", true, false); |
| }, "Frame__windowsRegExp", "_terseRegExp", "$get$_terseRegExp", function() { |
| return P.RegExp_RegExp("(-patch)?([/\\\\].*)?$", true, false); |
| }, "_terseRegExp", "_v8Trace", "$get$_v8Trace", function() { |
| return P.RegExp_RegExp("\\n ?at ", true, false); |
| }, "_v8Trace", "_v8TraceLine", "$get$_v8TraceLine", function() { |
| return P.RegExp_RegExp(" ?at ", true, false); |
| }, "_v8TraceLine", "_firefoxSafariTrace", "$get$_firefoxSafariTrace", function() { |
| return P.RegExp_RegExp("^(([.0-9A-Za-z_$/<]|\\(.*\\))*@)?[^\\s]*:\\d*$", true, true); |
| }, "_firefoxSafariTrace", "_friendlyTrace", "$get$_friendlyTrace", function() { |
| return P.RegExp_RegExp("^[^\\s<][^\\s]*( \\d+(:\\d+)?)?[ \\t]+[^\\s]+$", true, true); |
| }, "_friendlyTrace", "_iframes", "$get$_iframes", function() { |
| return H.JsLinkedHashMap_JsLinkedHashMap$es6(P.int, W.IFrameElement); |
| }, "_iframes", "_subscriptions", "$get$_subscriptions", function() { |
| return H.JsLinkedHashMap_JsLinkedHashMap$es6(P.int, [P.List, P.StreamSubscription]); |
| }, "_subscriptions", "_currentUrl", "$get$_currentUrl", function() { |
| return P.Uri_parse(C.Window_methods.get$location(W.window()).href, 0, null); |
| }, "_currentUrl"]); |
| Isolate = Isolate.$finishIsolateConstructor(Isolate); |
| $ = new Isolate(); |
| init.metadata = ["error", "stackTrace", "_", null, "message", "trace", "frame", "line", "value", "self", "parent", "zone", "arg", "result", "f", "data", "arg1", "arg2", "object", "e", "x", "element", "numberOfArguments", "arg3", "arg4", "closure", "arguments", "errorCode", "encodedComponent", "s", "each", "sender", "callback", "isolate"]; |
| init.types = [{func: 1, args: [,]}, {func: 1}, {func: 1, v: true}, {func: 1, args: [,,]}, {func: 1, v: true, args: [{func: 1, v: true}]}, {func: 1, v: true, args: [P.Object], opt: [P.StackTrace]}, {func: 1, v: true, args: [P.Uint8List, P.String, P.int]}, {func: 1, args: [, P.StackTrace]}, {func: 1, ret: P.String, args: [P.int]}, {func: 1, v: true, args: [,], opt: [P.StackTrace]}, {func: 1, args: [P.bool]}, {func: 1, args: [,], opt: [,]}, {func: 1, args: [P.String,,]}, {func: 1, v: true, args: [, P.StackTrace]}, {func: 1, args: [P.Zone, P.ZoneDelegate, P.Zone,, P.StackTrace]}, {func: 1, args: [, P.String]}, {func: 1, ret: P.int, args: [[P.List, P.int], P.int]}, {func: 1, v: true, args: [P.int, P.int]}, {func: 1, args: [P.Symbol0,,]}, {func: 1, args: [P.int,,]}, {func: 1, v: true, args: [P.String, P.int]}, {func: 1, v: true, args: [P.String], opt: [,]}, {func: 1, ret: P.int, args: [P.int, P.int]}, {func: 1, ret: P.Uint8List, args: [,,]}, {func: 1, ret: P.String, args: [P.String]}, {func: 1, v: true, opt: [,]}, {func: 1, ret: P.Future, args: [,]}, {func: 1, args: [P.String]}, {func: 1, v: true, args: [P.Object]}, {func: 1, v: true, args: [P.Zone, P.ZoneDelegate, P.Zone,, P.StackTrace]}, {func: 1, ret: P.AsyncError, args: [P.Zone, P.ZoneDelegate, P.Zone, P.Object, P.StackTrace]}, {func: 1, v: true, args: [P.Zone, P.ZoneDelegate, P.Zone, {func: 1, v: true}]}, {func: 1, ret: P.Timer, args: [P.Zone, P.ZoneDelegate, P.Zone, P.Duration, {func: 1, v: true}]}, {func: 1, ret: P.Timer, args: [P.Zone, P.ZoneDelegate, P.Zone, P.Duration, {func: 1, v: true, args: [P.Timer]}]}, {func: 1, v: true, args: [P.Zone, P.ZoneDelegate, P.Zone, P.String]}, {func: 1, v: true, args: [P.String]}, {func: 1, ret: P.Zone, args: [P.Zone, P.ZoneDelegate, P.Zone, P.ZoneSpecification, P.Map]}, {func: 1, args: [{func: 1, v: true}]}]; |
| 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]; |
| if (result == sentinelInProgress) |
| H.throwCyclicInit(staticName || fieldName); |
| try { |
| if (result === sentinelUndefined) { |
| this[fieldName] = sentinelInProgress; |
| try { |
| result = this[fieldName] = lazyValue(); |
| } finally { |
| if (result === sentinelUndefined) |
| this[fieldName] = null; |
| } |
| } |
| 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.host__main$closure(), a); |
| }, []); |
| else |
| (function(a) { |
| H.startRootIsolate(K.host__main$closure(), a); |
| })([]); |
| }); |
| // END invoke [main]. |
| })(); |
| |
| //# sourceMappingURL=host.dart.js.map |