| OLD | NEW |
| (Empty) |
| 1 // Generated by dart2js, the Dart to JavaScript compiler. | |
| 2 // The code supports the following hooks: | |
| 3 // dartPrint(message) - if this function is defined it is called | |
| 4 // instead of the Dart [print] method. | |
| 5 // dartMainRunner(main) - if this function is defined, the Dart [main] | |
| 6 // method will not be invoked directly. | |
| 7 // Instead, a closure that will invoke [main] is | |
| 8 // passed to [dartMainRunner]. | |
| 9 (function($) { | |
| 10 var A = {}; | |
| 11 delete A.x; | |
| 12 var B = {}; | |
| 13 delete B.x; | |
| 14 var C = {}; | |
| 15 delete C.x; | |
| 16 var D = {}; | |
| 17 delete D.x; | |
| 18 var E = {}; | |
| 19 delete E.x; | |
| 20 var F = {}; | |
| 21 delete F.x; | |
| 22 var G = {}; | |
| 23 delete G.x; | |
| 24 var H = {}; | |
| 25 delete H.x; | |
| 26 var J = {}; | |
| 27 delete J.x; | |
| 28 var K = {}; | |
| 29 delete K.x; | |
| 30 var L = {}; | |
| 31 delete L.x; | |
| 32 var M = {}; | |
| 33 delete M.x; | |
| 34 var N = {}; | |
| 35 delete N.x; | |
| 36 var O = {}; | |
| 37 delete O.x; | |
| 38 var P = {}; | |
| 39 delete P.x; | |
| 40 var Q = {}; | |
| 41 delete Q.x; | |
| 42 var R = {}; | |
| 43 delete R.x; | |
| 44 var S = {}; | |
| 45 delete S.x; | |
| 46 var T = {}; | |
| 47 delete T.x; | |
| 48 var U = {}; | |
| 49 delete U.x; | |
| 50 var V = {}; | |
| 51 delete V.x; | |
| 52 var W = {}; | |
| 53 delete W.x; | |
| 54 var X = {}; | |
| 55 delete X.x; | |
| 56 var Y = {}; | |
| 57 delete Y.x; | |
| 58 var Z = {}; | |
| 59 delete Z.x; | |
| 60 function Isolate() {} | |
| 61 init(); | |
| 62 | |
| 63 $ = Isolate.$isolateProperties; | |
| 64 var $$ = {}; | |
| 65 | |
| 66 // Native classes | |
| 67 // Method closures | |
| 68 $$.BoundClosure$i0 = [H, {"": "BoundClosure;_self,__js_helper$_target,_receiver,
__js_helper$_name", | |
| 69 call$0: function() { | |
| 70 return this.__js_helper$_target.call(this._self, this._receiver); | |
| 71 } | |
| 72 }]; | |
| 73 | |
| 74 $$.BoundClosure$1 = [H, {"": "BoundClosure;_self,__js_helper$_target,_receiver,_
_js_helper$_name", | |
| 75 call$1: function(p0) { | |
| 76 return this.__js_helper$_target.call(this._self, p0); | |
| 77 }, | |
| 78 $is_args1: true | |
| 79 }]; | |
| 80 | |
| 81 $$.BoundClosure$i1 = [P, {"": "BoundClosure;_self,__js_helper$_target,_receiver,
__js_helper$_name", | |
| 82 call$1: function(p0) { | |
| 83 return this.__js_helper$_target.call(this._self, this._receiver, p0); | |
| 84 }, | |
| 85 call$0: function() { | |
| 86 return this.call$1(null); | |
| 87 }, | |
| 88 "+call:0:0": 0, | |
| 89 $is_args1: true | |
| 90 }]; | |
| 91 | |
| 92 $$.BoundClosure$2 = [P, {"": "BoundClosure;_self,__js_helper$_target,_receiver,_
_js_helper$_name", | |
| 93 call$2: function(p0, p1) { | |
| 94 return this.__js_helper$_target.call(this._self, p0, p1); | |
| 95 }, | |
| 96 call$1: function(p0) { | |
| 97 return this.call$2(p0, null); | |
| 98 }, | |
| 99 "+call:1:0": 0, | |
| 100 $is_args2: true, | |
| 101 $is_args1: true | |
| 102 }]; | |
| 103 | |
| 104 $$.BoundClosure$0 = [P, {"": "BoundClosure;_self,__js_helper$_target,_receiver,_
_js_helper$_name", | |
| 105 call$0: function() { | |
| 106 return this.__js_helper$_target.call(this._self); | |
| 107 } | |
| 108 }]; | |
| 109 | |
| 110 $$.BoundClosure$20 = [P, {"": "BoundClosure;_self,__js_helper$_target,_receiver,
__js_helper$_name", | |
| 111 call$2: function(p0, p1) { | |
| 112 return this.__js_helper$_target.call(this._self, p0, p1); | |
| 113 }, | |
| 114 $is_args2: true | |
| 115 }]; | |
| 116 | |
| 117 $$.Closure$2 = [H, {"": "Closure;call$2,$name", $is_args2: true}]; | |
| 118 | |
| 119 $$.Closure$1 = [H, {"": "Closure;call$1,$name", $is_args1: true}]; | |
| 120 | |
| 121 $$.Closure$0 = [H, {"": "Closure;call$0,$name"}]; | |
| 122 | |
| 123 $$.Closure$7 = [H, {"": "Closure;call$7,$name"}]; | |
| 124 | |
| 125 $$.Closure$20 = [P, {"": "Closure;call$2,$name", | |
| 126 call$1: function(p0) { | |
| 127 return this.call$2(p0, null); | |
| 128 }, | |
| 129 "+call:1:0": 0, | |
| 130 $is_args2: true, | |
| 131 $is_args1: true | |
| 132 }]; | |
| 133 | |
| 134 $$.Closure$4 = [P, {"": "Closure;call$4,$name"}]; | |
| 135 | |
| 136 (function (reflectionData) { | |
| 137 function map(x){x={x:x};delete x.x;return x} | |
| 138 if (!init.libraries) init.libraries = []; | |
| 139 if (!init.mangledNames) init.mangledNames = map(); | |
| 140 if (!init.mangledGlobalNames) init.mangledGlobalNames = map(); | |
| 141 if (!init.statics) init.statics = map(); | |
| 142 if (!init.typeInformation) init.typeInformation = map(); | |
| 143 if (!init.globalFunctions) init.globalFunctions = map(); | |
| 144 var libraries = init.libraries; | |
| 145 var mangledNames = init.mangledNames; | |
| 146 var mangledGlobalNames = init.mangledGlobalNames; | |
| 147 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| 148 var length = reflectionData.length; | |
| 149 for (var i = 0; i < length; i++) { | |
| 150 var data = reflectionData[i]; | |
| 151 var name = data[0]; | |
| 152 var uri = data[1]; | |
| 153 var metadata = data[2]; | |
| 154 var globalObject = data[3]; | |
| 155 var descriptor = data[4]; | |
| 156 var isRoot = !!data[5]; | |
| 157 var fields = descriptor && descriptor[""]; | |
| 158 var classes = []; | |
| 159 var functions = []; | |
| 160 function processStatics(descriptor) { | |
| 161 for (var property in descriptor) { | |
| 162 if (!hasOwnProperty.call(descriptor, property)) continue; | |
| 163 if (property === "") continue; | |
| 164 var element = descriptor[property]; | |
| 165 var firstChar = property.substring(0, 1); | |
| 166 var previousProperty; | |
| 167 if (firstChar === "+") { | |
| 168 mangledGlobalNames[previousProperty] = property.substring(1); | |
| 169 if (descriptor[property] == 1) descriptor[previousProperty].$reflectab
le = 1; | |
| 170 if (element && element.length) init.typeInformation[previousProperty]
= element; | |
| 171 } else if (firstChar === "@") { | |
| 172 property = property.substring(1); | |
| 173 $[property]["@"] = element; | |
| 174 } else if (firstChar === "*") { | |
| 175 globalObject[previousProperty].$defaultValues = element; | |
| 176 var optionalMethods = descriptor.$methodsWithOptionalArguments; | |
| 177 if (!optionalMethods) { | |
| 178 descriptor.$methodsWithOptionalArguments = optionalMethods = {} | |
| 179 } | |
| 180 optionalMethods[property] = previousProperty; | |
| 181 } else if (typeof element === "function") { | |
| 182 globalObject[previousProperty = property] = element; | |
| 183 functions.push(property); | |
| 184 init.globalFunctions[property] = element; | |
| 185 } else { | |
| 186 previousProperty = property; | |
| 187 var newDesc = {}; | |
| 188 var previousProp; | |
| 189 for (var prop in element) { | |
| 190 if (!hasOwnProperty.call(element, prop)) continue; | |
| 191 firstChar = prop.substring(0, 1); | |
| 192 if (prop === "static") { | |
| 193 processStatics(init.statics[property] = element[prop]); | |
| 194 } else if (firstChar === "+") { | |
| 195 mangledNames[previousProp] = prop.substring(1); | |
| 196 if (element[prop] == 1) element[previousProp].$reflectable = 1; | |
| 197 } else if (firstChar === "@" && prop !== "@") { | |
| 198 newDesc[prop.substring(1)]["@"] = element[prop]; | |
| 199 } else if (firstChar === "*") { | |
| 200 newDesc[previousProp].$defaultValues = element[prop]; | |
| 201 var optionalMethods = newDesc.$methodsWithOptionalArguments; | |
| 202 if (!optionalMethods) { | |
| 203 newDesc.$methodsWithOptionalArguments = optionalMethods={} | |
| 204 } | |
| 205 optionalMethods[prop] = previousProp; | |
| 206 } else { | |
| 207 newDesc[previousProp = prop] = element[prop]; | |
| 208 } | |
| 209 } | |
| 210 $$[property] = [globalObject, newDesc]; | |
| 211 classes.push(property); | |
| 212 } | |
| 213 } | |
| 214 } | |
| 215 processStatics(descriptor); | |
| 216 libraries.push([name, uri, classes, functions, metadata, fields, isRoot, | |
| 217 globalObject]); | |
| 218 } | |
| 219 })([ | |
| 220 ["_foreign_helper", "dart:_foreign_helper", , H, { | |
| 221 JS_CONST: {"": "Object;code"}}], | |
| 222 ["_interceptors", "dart:_interceptors", , J, { | |
| 223 getInterceptor: function(object) { | |
| 224 return void 0; | |
| 225 }, | |
| 226 | |
| 227 makeDispatchRecord: function(interceptor, proto, extension, indexability) { | |
| 228 return {i: interceptor, p: proto, e: extension, x: indexability}; | |
| 229 }, | |
| 230 | |
| 231 getNativeInterceptor: function(object) { | |
| 232 var record, proto, objectProto, interceptor; | |
| 233 record = object[init.dispatchPropertyName]; | |
| 234 if (record == null) | |
| 235 if ($.initNativeDispatchFlag == null) { | |
| 236 H.initNativeDispatch(); | |
| 237 record = object[init.dispatchPropertyName]; | |
| 238 } | |
| 239 if (record != null) { | |
| 240 proto = record.p; | |
| 241 if (false === proto) | |
| 242 return record.i; | |
| 243 if (true === proto) | |
| 244 return object; | |
| 245 objectProto = Object.getPrototypeOf(object); | |
| 246 if (proto === objectProto) | |
| 247 return record.i; | |
| 248 if (record.e === objectProto) | |
| 249 throw H.wrapException(P.UnimplementedError$("Return interceptor for " + H.
S(proto(object, record)))); | |
| 250 } | |
| 251 interceptor = H.lookupAndCacheInterceptor(object); | |
| 252 if (interceptor == null) | |
| 253 return C.UnknownJavaScriptObject_methods; | |
| 254 return interceptor; | |
| 255 }, | |
| 256 | |
| 257 Interceptor: {"": "Object;", | |
| 258 $eq: function(receiver, other) { | |
| 259 return receiver === other; | |
| 260 }, | |
| 261 get$hashCode: function(receiver) { | |
| 262 return H.Primitives_objectHashCode(receiver); | |
| 263 }, | |
| 264 toString$0: function(receiver) { | |
| 265 return H.Primitives_objectToString(receiver); | |
| 266 }, | |
| 267 noSuchMethod$1: function(receiver, invocation) { | |
| 268 throw H.wrapException(P.NoSuchMethodError$(receiver, invocation.get$memberNa
me(), invocation.get$positionalArguments(), invocation.get$namedArguments(), nul
l)); | |
| 269 }, | |
| 270 "%": "DOMError|FileError|MediaError|MediaKeyError|Navigator|NavigatorUserMedia
Error|PositionError|SQLError|SVGAnimatedNumberList" | |
| 271 }, | |
| 272 | |
| 273 JSBool: {"": "bool/Interceptor;", | |
| 274 toString$0: function(receiver) { | |
| 275 return String(receiver); | |
| 276 }, | |
| 277 get$hashCode: function(receiver) { | |
| 278 return receiver ? 519018 : 218159; | |
| 279 }, | |
| 280 $isbool: true | |
| 281 }, | |
| 282 | |
| 283 JSNull: {"": "Interceptor;", | |
| 284 $eq: function(receiver, other) { | |
| 285 return null == other; | |
| 286 }, | |
| 287 toString$0: function(receiver) { | |
| 288 return "null"; | |
| 289 }, | |
| 290 get$hashCode: function(receiver) { | |
| 291 return 0; | |
| 292 } | |
| 293 }, | |
| 294 | |
| 295 JavaScriptObject: {"": "Interceptor;", | |
| 296 get$hashCode: function(_) { | |
| 297 return 0; | |
| 298 } | |
| 299 }, | |
| 300 | |
| 301 PlainJavaScriptObject: {"": "JavaScriptObject;"}, | |
| 302 | |
| 303 UnknownJavaScriptObject: {"": "JavaScriptObject;"}, | |
| 304 | |
| 305 JSArray: {"": "List/Interceptor;", | |
| 306 add$1: function(receiver, value) { | |
| 307 if (!!receiver.fixed$length) | |
| 308 H.throwExpression(P.UnsupportedError$("add")); | |
| 309 receiver.push(value); | |
| 310 }, | |
| 311 addAll$1: function(receiver, collection) { | |
| 312 var t1; | |
| 313 for (t1 = J.get$iterator$ax(collection); t1.moveNext$0();) | |
| 314 this.add$1(receiver, t1.get$current()); | |
| 315 }, | |
| 316 forEach$1: function(receiver, f) { | |
| 317 return H.IterableMixinWorkaround_forEach(receiver, f); | |
| 318 }, | |
| 319 map$1: function(receiver, f) { | |
| 320 var t1 = new H.MappedListIterable(receiver, f); | |
| 321 H.setRuntimeTypeInfo(t1, [null, null]); | |
| 322 return t1; | |
| 323 }, | |
| 324 elementAt$1: function(receiver, index) { | |
| 325 if (index >>> 0 !== index || index >= receiver.length) | |
| 326 throw H.ioore(receiver, index); | |
| 327 return receiver[index]; | |
| 328 }, | |
| 329 toString$0: function(receiver) { | |
| 330 return H.IterableMixinWorkaround_toStringIterable(receiver, "[", "]"); | |
| 331 }, | |
| 332 get$iterator: function(receiver) { | |
| 333 return new H.ListIterator(receiver, receiver.length, 0, null); | |
| 334 }, | |
| 335 get$hashCode: function(receiver) { | |
| 336 return H.Primitives_objectHashCode(receiver); | |
| 337 }, | |
| 338 get$length: function(receiver) { | |
| 339 return receiver.length; | |
| 340 }, | |
| 341 $index: function(receiver, index) { | |
| 342 if (typeof index !== "number" || Math.floor(index) !== index) | |
| 343 throw H.wrapException(new P.ArgumentError(index)); | |
| 344 if (index >= receiver.length || index < 0) | |
| 345 throw H.wrapException(P.RangeError$value(index)); | |
| 346 return receiver[index]; | |
| 347 }, | |
| 348 $indexSet: function(receiver, index, value) { | |
| 349 if (!!receiver.immutable$list) | |
| 350 H.throwExpression(P.UnsupportedError$("indexed set")); | |
| 351 if (typeof index !== "number" || Math.floor(index) !== index) | |
| 352 throw H.wrapException(new P.ArgumentError(index)); | |
| 353 if (index >= receiver.length || index < 0) | |
| 354 throw H.wrapException(P.RangeError$value(index)); | |
| 355 receiver[index] = value; | |
| 356 }, | |
| 357 $isList: true, | |
| 358 $asList: null, | |
| 359 $asIterable: null, | |
| 360 $isList: true, | |
| 361 $isEfficientLength: true, | |
| 362 $isIterable: true | |
| 363 }, | |
| 364 | |
| 365 JSMutableArray: {"": "JSArray;", $isJSMutableArray: true, | |
| 366 $asJSArray: function() { | |
| 367 return [null]; | |
| 368 }, | |
| 369 $asList: function() { | |
| 370 return [null]; | |
| 371 }, | |
| 372 $asIterable: function() { | |
| 373 return [null]; | |
| 374 } | |
| 375 }, | |
| 376 | |
| 377 JSFixedArray: {"": "JSMutableArray;"}, | |
| 378 | |
| 379 JSExtendableArray: {"": "JSMutableArray;", $isJSExtendableArray: true}, | |
| 380 | |
| 381 JSNumber: {"": "num/Interceptor;", | |
| 382 remainder$1: function(receiver, b) { | |
| 383 return receiver % b; | |
| 384 }, | |
| 385 abs$0: function(receiver) { | |
| 386 return Math.abs(receiver); | |
| 387 }, | |
| 388 toInt$0: function(receiver) { | |
| 389 var t1; | |
| 390 if (receiver >= -2147483648 && receiver <= 2147483647) | |
| 391 return receiver | 0; | |
| 392 if (isFinite(receiver)) { | |
| 393 t1 = receiver < 0 ? Math.ceil(receiver) : Math.floor(receiver); | |
| 394 return t1 + 0; | |
| 395 } | |
| 396 throw H.wrapException(P.UnsupportedError$('' + receiver)); | |
| 397 }, | |
| 398 toString$0: function(receiver) { | |
| 399 if (receiver === 0 && 1 / receiver < 0) | |
| 400 return "-0.0"; | |
| 401 else | |
| 402 return "" + receiver; | |
| 403 }, | |
| 404 get$hashCode: function(receiver) { | |
| 405 return receiver & 0x1FFFFFFF; | |
| 406 }, | |
| 407 $sub: function(receiver, other) { | |
| 408 return receiver - other; | |
| 409 }, | |
| 410 $tdiv: function(receiver, other) { | |
| 411 if ((receiver | 0) === receiver && (other | 0) === other && 0 !== other && -
1 !== other) | |
| 412 return receiver / other | 0; | |
| 413 else | |
| 414 return this._slowTdiv$1(receiver, other); | |
| 415 }, | |
| 416 _slowTdiv$1: function(receiver, other) { | |
| 417 return this.toInt$0(receiver / other); | |
| 418 }, | |
| 419 $shl: function(receiver, other) { | |
| 420 if (other < 0) | |
| 421 throw H.wrapException(new P.ArgumentError(other)); | |
| 422 if (other > 31) | |
| 423 return 0; | |
| 424 return receiver << other >>> 0; | |
| 425 }, | |
| 426 $shr: function(receiver, other) { | |
| 427 if (other < 0) | |
| 428 throw H.wrapException(new P.ArgumentError(other)); | |
| 429 if (receiver > 0) { | |
| 430 if (other > 31) | |
| 431 return 0; | |
| 432 return receiver >>> other; | |
| 433 } | |
| 434 if (other > 31) | |
| 435 other = 31; | |
| 436 return receiver >> other >>> 0; | |
| 437 }, | |
| 438 $lt: function(receiver, other) { | |
| 439 if (typeof other !== "number") | |
| 440 throw H.wrapException(P.ArgumentError$(other)); | |
| 441 return receiver < other; | |
| 442 }, | |
| 443 $gt: function(receiver, other) { | |
| 444 if (typeof other !== "number") | |
| 445 throw H.wrapException(P.ArgumentError$(other)); | |
| 446 return receiver > other; | |
| 447 }, | |
| 448 $ge: function(receiver, other) { | |
| 449 if (typeof other !== "number") | |
| 450 throw H.wrapException(new P.ArgumentError(other)); | |
| 451 return receiver >= other; | |
| 452 }, | |
| 453 $isnum: true, | |
| 454 static: { | |
| 455 "": "JSNumber__MIN_INT32,JSNumber__MAX_INT32", | |
| 456 } | |
| 457 | |
| 458 }, | |
| 459 | |
| 460 JSInt: {"": "int/JSNumber;", $isnum: true, $isint: true}, | |
| 461 | |
| 462 JSDouble: {"": "double/JSNumber;", $isnum: true}, | |
| 463 | |
| 464 JSString: {"": "String/Interceptor;", | |
| 465 codeUnitAt$1: function(receiver, index) { | |
| 466 if (typeof index !== "number" || Math.floor(index) !== index) | |
| 467 throw H.wrapException(P.ArgumentError$(index)); | |
| 468 if (index < 0) | |
| 469 throw H.wrapException(P.RangeError$value(index)); | |
| 470 if (index >= receiver.length) | |
| 471 throw H.wrapException(P.RangeError$value(index)); | |
| 472 return receiver.charCodeAt(index); | |
| 473 }, | |
| 474 substring$2: function(receiver, startIndex, endIndex) { | |
| 475 var t1; | |
| 476 if (typeof startIndex !== "number" || Math.floor(startIndex) !== startIndex) | |
| 477 H.throwExpression(P.ArgumentError$(startIndex)); | |
| 478 if (endIndex == null) | |
| 479 endIndex = receiver.length; | |
| 480 if (typeof endIndex !== "number" || Math.floor(endIndex) !== endIndex) | |
| 481 H.throwExpression(P.ArgumentError$(endIndex)); | |
| 482 t1 = J.getInterceptor$n(startIndex); | |
| 483 if (t1.$lt(startIndex, 0)) | |
| 484 throw H.wrapException(P.RangeError$value(startIndex)); | |
| 485 if (t1.$gt(startIndex, endIndex)) | |
| 486 throw H.wrapException(P.RangeError$value(startIndex)); | |
| 487 if (J.$gt$n(endIndex, receiver.length)) | |
| 488 throw H.wrapException(P.RangeError$value(endIndex)); | |
| 489 return receiver.substring(startIndex, endIndex); | |
| 490 }, | |
| 491 substring$1: function($receiver, startIndex) { | |
| 492 return this.substring$2($receiver, startIndex, null); | |
| 493 }, | |
| 494 get$isEmpty: function(receiver) { | |
| 495 return receiver.length === 0; | |
| 496 }, | |
| 497 toString$0: function(receiver) { | |
| 498 return receiver; | |
| 499 }, | |
| 500 get$hashCode: function(receiver) { | |
| 501 var t1, hash, i; | |
| 502 for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) { | |
| 503 hash = 536870911 & hash + receiver.charCodeAt(i); | |
| 504 hash = 536870911 & hash + ((524287 & hash) << 10 >>> 0); | |
| 505 hash ^= hash >> 6; | |
| 506 } | |
| 507 hash = 536870911 & hash + ((67108863 & hash) << 3 >>> 0); | |
| 508 hash ^= hash >> 11; | |
| 509 return 536870911 & hash + ((16383 & hash) << 15 >>> 0); | |
| 510 }, | |
| 511 get$length: function(receiver) { | |
| 512 return receiver.length; | |
| 513 }, | |
| 514 $index: function(receiver, index) { | |
| 515 if (typeof index !== "number" || Math.floor(index) !== index) | |
| 516 throw H.wrapException(new P.ArgumentError(index)); | |
| 517 if (index >= receiver.length || index < 0) | |
| 518 throw H.wrapException(P.RangeError$value(index)); | |
| 519 return receiver[index]; | |
| 520 }, | |
| 521 $isString: true | |
| 522 }}], | |
| 523 ["_isolate_helper", "dart:_isolate_helper", , H, { | |
| 524 _callInIsolate: function(isolate, $function) { | |
| 525 var result = isolate.eval$1($function); | |
| 526 $globalState.topEventLoop.run$0(); | |
| 527 return result; | |
| 528 }, | |
| 529 | |
| 530 startRootIsolate: function(entry) { | |
| 531 var rootContext; | |
| 532 $globalState = H._Manager$(entry); | |
| 533 if ($globalState.isWorker === true) | |
| 534 return; | |
| 535 rootContext = H._IsolateContext$(); | |
| 536 $globalState.rootContext = rootContext; | |
| 537 $globalState.currentContext = rootContext; | |
| 538 if (!!entry.$is_args1) | |
| 539 rootContext.eval$1(new H.startRootIsolate_closure(entry)); | |
| 540 else if (!!entry.$is_args2) | |
| 541 rootContext.eval$1(new H.startRootIsolate_closure0(entry)); | |
| 542 else | |
| 543 rootContext.eval$1(entry); | |
| 544 $globalState.topEventLoop.run$0(); | |
| 545 }, | |
| 546 | |
| 547 IsolateNatives_computeThisScript: function() { | |
| 548 var currentScript = init.currentScript; | |
| 549 if (currentScript != null) | |
| 550 return String(currentScript.src); | |
| 551 if (typeof version == "function" && typeof os == "object" && "system" in os) | |
| 552 return H.IsolateNatives_computeThisScriptD8(); | |
| 553 if (typeof version == "function" && typeof system == "function") | |
| 554 return thisFilename(); | |
| 555 return; | |
| 556 }, | |
| 557 | |
| 558 IsolateNatives_computeThisScriptD8: function() { | |
| 559 var stack, matches; | |
| 560 stack = new Error().stack; | |
| 561 if (stack == null) { | |
| 562 stack = (function() {try { throw new Error() } catch(e) { return e.stack }})
(); | |
| 563 if (stack == null) | |
| 564 throw H.wrapException(P.UnsupportedError$("No stack trace")); | |
| 565 } | |
| 566 matches = stack.match(new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m"))
; | |
| 567 if (matches != null) | |
| 568 return matches[1]; | |
| 569 matches = stack.match(new RegExp("^[^@]*@(.*):[0-9]*$", "m")); | |
| 570 if (matches != null) | |
| 571 return matches[1]; | |
| 572 throw H.wrapException(P.UnsupportedError$("Cannot extract URI from \"" + stack
+ "\"")); | |
| 573 }, | |
| 574 | |
| 575 IsolateNatives__processWorkerMessage: function(sender, e) { | |
| 576 var msg, t1, functionName, entryPoint, args, message, isSpawnUri, replyTo, con
text, t2; | |
| 577 msg = H._deserializeMessage(e.data); | |
| 578 t1 = J.getInterceptor$asx(msg); | |
| 579 switch (t1.$index(msg, "command")) { | |
| 580 case "start": | |
| 581 $globalState.currentManagerId = t1.$index(msg, "id"); | |
| 582 functionName = t1.$index(msg, "functionName"); | |
| 583 entryPoint = functionName == null ? $globalState.entry : init.globalFuncti
ons[functionName]; | |
| 584 args = t1.$index(msg, "args"); | |
| 585 message = H._deserializeMessage(t1.$index(msg, "msg")); | |
| 586 isSpawnUri = t1.$index(msg, "isSpawnUri"); | |
| 587 replyTo = H._deserializeMessage(t1.$index(msg, "replyTo")); | |
| 588 context = H._IsolateContext$(); | |
| 589 $globalState.topEventLoop.events._add$1(new H._IsolateEvent(context, new H
.IsolateNatives__processWorkerMessage_closure(entryPoint, args, message, isSpawn
Uri, replyTo), "worker-start")); | |
| 590 $globalState.currentContext = context; | |
| 591 $globalState.topEventLoop.run$0(); | |
| 592 break; | |
| 593 case "spawn-worker": | |
| 594 H.IsolateNatives__spawnWorker(t1.$index(msg, "functionName"), t1.$index(ms
g, "uri"), t1.$index(msg, "args"), t1.$index(msg, "msg"), t1.$index(msg, "isSpaw
nUri"), t1.$index(msg, "replyPort")); | |
| 595 break; | |
| 596 case "message": | |
| 597 if (t1.$index(msg, "port") != null) | |
| 598 t1.$index(msg, "port").send$1(t1.$index(msg, "msg")); | |
| 599 $globalState.topEventLoop.run$0(); | |
| 600 break; | |
| 601 case "close": | |
| 602 t1 = $globalState.managers; | |
| 603 t2 = $.get$IsolateNatives_workerIds(); | |
| 604 t1.remove$1(t1, t2.$index(t2, sender)); | |
| 605 sender.terminate(); | |
| 606 $globalState.topEventLoop.run$0(); | |
| 607 break; | |
| 608 case "log": | |
| 609 H.IsolateNatives__log(t1.$index(msg, "msg")); | |
| 610 break; | |
| 611 case "print": | |
| 612 if ($globalState.isWorker === true) { | |
| 613 t1 = $globalState.mainManager; | |
| 614 t2 = H._serializeMessage(H.fillLiteralMap(["command", "print", "msg", ms
g], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| 615 t1.toString; | |
| 616 self.postMessage(t2); | |
| 617 } else | |
| 618 P.print(t1.$index(msg, "msg")); | |
| 619 break; | |
| 620 case "error": | |
| 621 throw H.wrapException(t1.$index(msg, "msg")); | |
| 622 default: | |
| 623 } | |
| 624 }, | |
| 625 | |
| 626 IsolateNatives__log: function(msg) { | |
| 627 var trace, t1, t2, exception; | |
| 628 if ($globalState.isWorker === true) { | |
| 629 t1 = $globalState.mainManager; | |
| 630 t2 = H._serializeMessage(H.fillLiteralMap(["command", "log", "msg", msg], P.
LinkedHashMap_LinkedHashMap(null, null, null, null, null))); | |
| 631 t1.toString; | |
| 632 self.postMessage(t2); | |
| 633 } else | |
| 634 try { | |
| 635 $.get$globalThis().console.log(msg); | |
| 636 } catch (exception) { | |
| 637 H.unwrapException(exception); | |
| 638 trace = new H._StackTrace(exception, null); | |
| 639 throw H.wrapException(P.Exception_Exception(trace)); | |
| 640 } | |
| 641 | |
| 642 }, | |
| 643 | |
| 644 IsolateNatives__startIsolate: function(topLevel, args, message, isSpawnUri, repl
yTo) { | |
| 645 var t1; | |
| 646 H.Primitives_initializeStatics($globalState.currentContext.id); | |
| 647 $.lazyPort = H.ReceivePortImpl$(); | |
| 648 t1 = $.lazyPort; | |
| 649 t1.toString; | |
| 650 replyTo.send$1(["spawned", new H._NativeJsSendPort(t1, $globalState.currentCon
text.id)]); | |
| 651 if (isSpawnUri !== true) | |
| 652 topLevel.call$1(message); | |
| 653 else { | |
| 654 t1 = J.getInterceptor(topLevel); | |
| 655 if (!!t1.$is_args2) | |
| 656 topLevel.call$2(args, message); | |
| 657 else if (!!t1.$is_args1) | |
| 658 topLevel.call$1(args); | |
| 659 else | |
| 660 topLevel.call$0(); | |
| 661 } | |
| 662 }, | |
| 663 | |
| 664 IsolateNatives__spawnWorker: function(functionName, uri, args, message, isSpawnU
ri, replyPort) { | |
| 665 var worker, t1, workerId; | |
| 666 if (uri == null) | |
| 667 uri = $.get$IsolateNatives_thisScript(); | |
| 668 worker = new Worker(uri); | |
| 669 worker.onmessage = function(e) { H.IsolateNatives__processWorkerMessage$closur
e.call$2(worker, e); }; | |
| 670 t1 = $globalState; | |
| 671 workerId = t1.nextManagerId; | |
| 672 t1.nextManagerId = workerId + 1; | |
| 673 t1 = $.get$IsolateNatives_workerIds(); | |
| 674 t1.$indexSet(t1, worker, workerId); | |
| 675 t1 = $globalState.managers; | |
| 676 t1.$indexSet(t1, workerId, worker); | |
| 677 worker.postMessage(H._serializeMessage(H.fillLiteralMap(["command", "start", "
id", workerId, "replyTo", H._serializeMessage(replyPort), "args", args, "msg", H
._serializeMessage(message), "isSpawnUri", isSpawnUri, "functionName", functionN
ame], P.LinkedHashMap_LinkedHashMap(null, null, null, null, null)))); | |
| 678 }, | |
| 679 | |
| 680 _waitForPendingPorts: function(message, callback) { | |
| 681 var finder = H._PendingSendPortFinder$(); | |
| 682 finder.traverse$1(message); | |
| 683 P.Future_wait(finder.ports).then$1(new H._waitForPendingPorts_closure(callback
)); | |
| 684 }, | |
| 685 | |
| 686 _serializeMessage: function(message) { | |
| 687 var t1; | |
| 688 if ($globalState.supportsWorkers === true) { | |
| 689 t1 = new H._JsSerializer(0, new H._MessageTraverserVisitedMap()); | |
| 690 t1._visited = new H._JsVisitedMap(null); | |
| 691 return t1.traverse$1(message); | |
| 692 } else { | |
| 693 t1 = new H._JsCopier(new H._MessageTraverserVisitedMap()); | |
| 694 t1._visited = new H._JsVisitedMap(null); | |
| 695 return t1.traverse$1(message); | |
| 696 } | |
| 697 }, | |
| 698 | |
| 699 _deserializeMessage: function(message) { | |
| 700 if ($globalState.supportsWorkers === true) | |
| 701 return new H._JsDeserializer(null).deserialize$1(message); | |
| 702 else | |
| 703 return message; | |
| 704 }, | |
| 705 | |
| 706 _MessageTraverser_isPrimitive: function(x) { | |
| 707 return x == null || typeof x === "string" || typeof x === "number" || typeof x
=== "boolean"; | |
| 708 }, | |
| 709 | |
| 710 _Deserializer_isPrimitive: function(x) { | |
| 711 return x == null || typeof x === "string" || typeof x === "number" || typeof x
=== "boolean"; | |
| 712 }, | |
| 713 | |
| 714 startRootIsolate_closure: {"": "Closure;entry_0", | |
| 715 call$0: function() { | |
| 716 this.entry_0.call$1([]); | |
| 717 }, | |
| 718 "+call:0:0": 0, | |
| 719 $isFunction: true | |
| 720 }, | |
| 721 | |
| 722 startRootIsolate_closure0: {"": "Closure;entry_1", | |
| 723 call$0: function() { | |
| 724 this.entry_1.call$2([], null); | |
| 725 }, | |
| 726 "+call:0:0": 0, | |
| 727 $isFunction: true | |
| 728 }, | |
| 729 | |
| 730 _Manager: {"": "Object;nextIsolateId,currentManagerId,nextManagerId,currentConte
xt,rootContext,topEventLoop,fromCommandLine,isWorker,supportsWorkers,isolates,ma
inManager,managers,entry", | |
| 731 _nativeDetectEnvironment$0: function() { | |
| 732 var t1, t2; | |
| 733 t1 = $.get$globalWindow() == null; | |
| 734 t2 = $.get$globalWorker(); | |
| 735 this.isWorker = t1 && $.get$globalPostMessageDefined() === true; | |
| 736 if (this.isWorker !== true) | |
| 737 t2 = t2 != null && $.get$IsolateNatives_thisScript() != null; | |
| 738 else | |
| 739 t2 = true; | |
| 740 this.supportsWorkers = t2; | |
| 741 this.fromCommandLine = t1 && this.isWorker !== true; | |
| 742 }, | |
| 743 _nativeInitWorkerMessageHandler$0: function() { | |
| 744 var $function = function (e) { H.IsolateNatives__processWorkerMessage$closur
e.call$2(this.mainManager, e); }; | |
| 745 $.get$globalThis().onmessage = $function; | |
| 746 $.get$globalThis().dartPrint = function (object) {}; | |
| 747 }, | |
| 748 _Manager$1: function(entry) { | |
| 749 this._nativeDetectEnvironment$0(); | |
| 750 this.topEventLoop = new H._EventLoop(P.ListQueue$(null, H._IsolateEvent), 0)
; | |
| 751 this.isolates = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, H._
IsolateContext); | |
| 752 this.managers = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, nul
l); | |
| 753 if (this.isWorker === true) { | |
| 754 this.mainManager = new H._MainManagerStub(); | |
| 755 this._nativeInitWorkerMessageHandler$0(); | |
| 756 } | |
| 757 }, | |
| 758 static: { | |
| 759 _Manager$: function(entry) { | |
| 760 var t1 = new H._Manager(0, 0, 1, null, null, null, null, null, null, null, nul
l, null, entry); | |
| 761 t1._Manager$1(entry); | |
| 762 return t1; | |
| 763 }} | |
| 764 | |
| 765 }, | |
| 766 | |
| 767 _IsolateContext: {"": "Object;id,ports,isolateStatics<", | |
| 768 eval$1: function(code) { | |
| 769 var old, result; | |
| 770 old = $globalState.currentContext; | |
| 771 $globalState.currentContext = this; | |
| 772 $ = this.isolateStatics; | |
| 773 result = null; | |
| 774 try { | |
| 775 result = code.call$0(); | |
| 776 } finally { | |
| 777 $globalState.currentContext = old; | |
| 778 if (old != null) | |
| 779 $ = old.get$isolateStatics(); | |
| 780 } | |
| 781 return result; | |
| 782 }, | |
| 783 lookup$1: function(portId) { | |
| 784 var t1 = this.ports; | |
| 785 return t1.$index(t1, portId); | |
| 786 }, | |
| 787 register$2: function(_, portId, port) { | |
| 788 var t1; | |
| 789 if (this.ports.containsKey$1(portId)) | |
| 790 throw H.wrapException(P.Exception_Exception("Registry: ports must be regis
tered only once.")); | |
| 791 t1 = this.ports; | |
| 792 t1.$indexSet(t1, portId, port); | |
| 793 t1 = $globalState.isolates; | |
| 794 t1.$indexSet(t1, this.id, this); | |
| 795 }, | |
| 796 unregister$1: function(portId) { | |
| 797 var t1 = this.ports; | |
| 798 t1.remove$1(t1, portId); | |
| 799 if (this.ports._collection$_length === 0) { | |
| 800 t1 = $globalState.isolates; | |
| 801 t1.remove$1(t1, this.id); | |
| 802 } | |
| 803 }, | |
| 804 _IsolateContext$0: function() { | |
| 805 var t1, t2; | |
| 806 t1 = $globalState; | |
| 807 t2 = t1.nextIsolateId; | |
| 808 t1.nextIsolateId = t2 + 1; | |
| 809 this.id = t2; | |
| 810 this.ports = P.LinkedHashMap_LinkedHashMap(null, null, null, J.JSInt, P.Rece
ivePort); | |
| 811 this.isolateStatics = new Isolate(); | |
| 812 }, | |
| 813 static: { | |
| 814 _IsolateContext$: function() { | |
| 815 var t1 = new H._IsolateContext(null, null, null); | |
| 816 t1._IsolateContext$0(); | |
| 817 return t1; | |
| 818 }} | |
| 819 | |
| 820 }, | |
| 821 | |
| 822 _EventLoop: {"": "Object;events,activeTimerCount", | |
| 823 dequeue$0: function() { | |
| 824 var t1 = this.events; | |
| 825 if (t1._head === t1._tail) | |
| 826 return; | |
| 827 return t1.removeFirst$0(); | |
| 828 }, | |
| 829 checkOpenReceivePortsFromCommandLine$0: function() { | |
| 830 if ($globalState.rootContext != null && $globalState.isolates.containsKey$1(
$globalState.rootContext.id) && $globalState.fromCommandLine === true && $global
State.rootContext.ports._collection$_length === 0) | |
| 831 throw H.wrapException(P.Exception_Exception("Program exited with open Rece
ivePorts.")); | |
| 832 }, | |
| 833 runIteration$0: function() { | |
| 834 var $event, t1, t2; | |
| 835 $event = this.dequeue$0(); | |
| 836 if ($event == null) { | |
| 837 this.checkOpenReceivePortsFromCommandLine$0(); | |
| 838 t1 = $globalState; | |
| 839 if (t1.isWorker === true && t1.isolates._collection$_length === 0 && t1.to
pEventLoop.activeTimerCount === 0) { | |
| 840 t1 = t1.mainManager; | |
| 841 t2 = H._serializeMessage(H.fillLiteralMap(["command", "close"], P.Linked
HashMap_LinkedHashMap(null, null, null, null, null))); | |
| 842 t1.toString; | |
| 843 self.postMessage(t2); | |
| 844 } | |
| 845 return false; | |
| 846 } | |
| 847 $event.process$0(); | |
| 848 return true; | |
| 849 }, | |
| 850 _runHelper$0: function() { | |
| 851 if ($.get$globalWindow() != null) | |
| 852 new H._EventLoop__runHelper_next(this).call$0(); | |
| 853 else | |
| 854 for (; this.runIteration$0();) | |
| 855 ; | |
| 856 }, | |
| 857 run$0: function() { | |
| 858 var e, trace, exception, t1, t2; | |
| 859 if ($globalState.isWorker !== true) | |
| 860 this._runHelper$0(); | |
| 861 else | |
| 862 try { | |
| 863 this._runHelper$0(); | |
| 864 } catch (exception) { | |
| 865 t1 = H.unwrapException(exception); | |
| 866 e = t1; | |
| 867 trace = new H._StackTrace(exception, null); | |
| 868 t1 = $globalState.mainManager; | |
| 869 t2 = H._serializeMessage(H.fillLiteralMap(["command", "error", "msg", H.
S(e) + "\n" + H.S(trace)], P.LinkedHashMap_LinkedHashMap(null, null, null, null,
null))); | |
| 870 t1.toString; | |
| 871 self.postMessage(t2); | |
| 872 } | |
| 873 | |
| 874 } | |
| 875 }, | |
| 876 | |
| 877 _EventLoop__runHelper_next: {"": "Closure;this_0", | |
| 878 call$0: function() { | |
| 879 if (!this.this_0.runIteration$0()) | |
| 880 return; | |
| 881 P.Timer_Timer(C.Duration_0, this); | |
| 882 }, | |
| 883 "+call:0:0": 0, | |
| 884 $isFunction: true | |
| 885 }, | |
| 886 | |
| 887 _IsolateEvent: {"": "Object;isolate,fn,message", | |
| 888 process$0: function() { | |
| 889 this.isolate.eval$1(this.fn); | |
| 890 } | |
| 891 }, | |
| 892 | |
| 893 _MainManagerStub: {"": "Object;"}, | |
| 894 | |
| 895 IsolateNatives__processWorkerMessage_closure: {"": "Closure;entryPoint_0,args_1,
message_2,isSpawnUri_3,replyTo_4", | |
| 896 call$0: function() { | |
| 897 H.IsolateNatives__startIsolate(this.entryPoint_0, this.args_1, this.message_
2, this.isSpawnUri_3, this.replyTo_4); | |
| 898 }, | |
| 899 "+call:0:0": 0, | |
| 900 $isFunction: true | |
| 901 }, | |
| 902 | |
| 903 _BaseSendPort: {"": "Object;", $isSendPort: true}, | |
| 904 | |
| 905 _NativeJsSendPort: {"": "_BaseSendPort;_receivePort,_isolateId", | |
| 906 send$1: function(message) { | |
| 907 H._waitForPendingPorts(message, new H._NativeJsSendPort_send_closure(this, m
essage)); | |
| 908 }, | |
| 909 $eq: function(_, other) { | |
| 910 var t1; | |
| 911 if (other == null) | |
| 912 return false; | |
| 913 t1 = J.getInterceptor(other); | |
| 914 return typeof other === "object" && other !== null && !!t1.$is_NativeJsSendP
ort && J.$eq(this._receivePort, other._receivePort); | |
| 915 }, | |
| 916 get$hashCode: function(_) { | |
| 917 return this._receivePort.get$_id(); | |
| 918 }, | |
| 919 $is_NativeJsSendPort: true, | |
| 920 $isSendPort: true | |
| 921 }, | |
| 922 | |
| 923 _NativeJsSendPort_send_closure: {"": "Closure;this_1,message_2", | |
| 924 call$0: function() { | |
| 925 var t1, t2, t3, t4, isolate, shouldSerialize, msg; | |
| 926 t1 = {}; | |
| 927 t2 = $globalState.isolates; | |
| 928 t3 = this.this_1; | |
| 929 t4 = t3._isolateId; | |
| 930 isolate = t2.$index(t2, t4); | |
| 931 if (isolate == null) | |
| 932 return; | |
| 933 if ((t3._receivePort.get$_controller()._state & 4) !== 0) | |
| 934 return; | |
| 935 shouldSerialize = $globalState.currentContext != null && $globalState.curren
tContext.id !== t4; | |
| 936 msg = this.message_2; | |
| 937 t1.msg_0 = msg; | |
| 938 if (shouldSerialize) | |
| 939 t1.msg_0 = H._serializeMessage(t1.msg_0); | |
| 940 t2 = $globalState.topEventLoop; | |
| 941 t4 = "receive " + H.S(msg); | |
| 942 t2.events._add$1(new H._IsolateEvent(isolate, new H._NativeJsSendPort_send__
closure(t1, t3, shouldSerialize), t4)); | |
| 943 }, | |
| 944 "+call:0:0": 0, | |
| 945 $isFunction: true | |
| 946 }, | |
| 947 | |
| 948 _NativeJsSendPort_send__closure: {"": "Closure;box_0,this_3,shouldSerialize_4", | |
| 949 call$0: function() { | |
| 950 var t1, t2; | |
| 951 t1 = this.this_3._receivePort; | |
| 952 if ((t1.get$_controller()._state & 4) === 0) { | |
| 953 if (this.shouldSerialize_4) { | |
| 954 t2 = this.box_0; | |
| 955 t2.msg_0 = H._deserializeMessage(t2.msg_0); | |
| 956 } | |
| 957 t1 = t1.get$_controller(); | |
| 958 t2 = this.box_0.msg_0; | |
| 959 if (t1._state >= 4) | |
| 960 H.throwExpression(t1._badEventState$0()); | |
| 961 t1._async$_add$1(t2); | |
| 962 } | |
| 963 }, | |
| 964 "+call:0:0": 0, | |
| 965 $isFunction: true | |
| 966 }, | |
| 967 | |
| 968 _WorkerSendPort: {"": "_BaseSendPort;_workerId,_receivePortId,_isolateId", | |
| 969 send$1: function(message) { | |
| 970 H._waitForPendingPorts(message, new H._WorkerSendPort_send_closure(this, mes
sage)); | |
| 971 }, | |
| 972 $eq: function(_, other) { | |
| 973 var t1; | |
| 974 if (other == null) | |
| 975 return false; | |
| 976 t1 = J.getInterceptor(other); | |
| 977 return typeof other === "object" && other !== null && !!t1.$is_WorkerSendPor
t && J.$eq(this._workerId, other._workerId) && J.$eq(this._isolateId, other._iso
lateId) && J.$eq(this._receivePortId, other._receivePortId); | |
| 978 }, | |
| 979 get$hashCode: function(_) { | |
| 980 var t1, t2, t3; | |
| 981 t1 = J.$shl$n(this._workerId, 16); | |
| 982 t2 = J.$shl$n(this._isolateId, 8); | |
| 983 t3 = this._receivePortId; | |
| 984 if (typeof t3 !== "number") | |
| 985 throw H.iae(t3); | |
| 986 return (t1 ^ t2 ^ t3) >>> 0; | |
| 987 }, | |
| 988 $is_WorkerSendPort: true, | |
| 989 $isSendPort: true | |
| 990 }, | |
| 991 | |
| 992 _WorkerSendPort_send_closure: {"": "Closure;this_0,message_1", | |
| 993 call$0: function() { | |
| 994 var t1, workerMessage, t2, manager; | |
| 995 t1 = this.this_0; | |
| 996 workerMessage = H._serializeMessage(H.fillLiteralMap(["command", "message",
"port", t1, "msg", this.message_1], P.LinkedHashMap_LinkedHashMap(null, null, nu
ll, null, null))); | |
| 997 if ($globalState.isWorker === true) { | |
| 998 $globalState.mainManager.toString; | |
| 999 self.postMessage(workerMessage); | |
| 1000 } else { | |
| 1001 t2 = $globalState.managers; | |
| 1002 manager = t2.$index(t2, t1._workerId); | |
| 1003 if (manager != null) | |
| 1004 manager.postMessage(workerMessage); | |
| 1005 } | |
| 1006 }, | |
| 1007 "+call:0:0": 0, | |
| 1008 $isFunction: true | |
| 1009 }, | |
| 1010 | |
| 1011 ReceivePortImpl: {"": "Stream;_id<,_controller<", | |
| 1012 listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone,
onError) { | |
| 1013 var t1 = this._controller; | |
| 1014 t1.toString; | |
| 1015 t1 = new P._ControllerStream(t1); | |
| 1016 H.setRuntimeTypeInfo(t1, [null]); | |
| 1017 return t1.listen$4$cancelOnError$onDone$onError(onData, cancelOnError, onDon
e, onError); | |
| 1018 }, | |
| 1019 listen$3$onDone$onError: function(onData, onDone, onError) { | |
| 1020 return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onEr
ror); | |
| 1021 }, | |
| 1022 close$0: function(_) { | |
| 1023 var t1 = this._controller; | |
| 1024 if ((t1._state & 4) !== 0) | |
| 1025 return; | |
| 1026 t1.close$0(t1); | |
| 1027 $globalState.currentContext.unregister$1(this._id); | |
| 1028 }, | |
| 1029 get$close: function(_receiver) { | |
| 1030 return new H.BoundClosure$i0(this, H.ReceivePortImpl.prototype.close$0, _rec
eiver, "close$0"); | |
| 1031 }, | |
| 1032 ReceivePortImpl$0: function() { | |
| 1033 this._controller = P.StreamController_StreamController(this.get$close(this),
null, null, null, true, null); | |
| 1034 var t1 = $globalState.currentContext; | |
| 1035 t1.register$2(t1, this._id, this); | |
| 1036 }, | |
| 1037 static: { | |
| 1038 "": "ReceivePortImpl__nextFreeId", | |
| 1039 ReceivePortImpl$: function() { | |
| 1040 var t1 = $.ReceivePortImpl__nextFreeId; | |
| 1041 $.ReceivePortImpl__nextFreeId = t1 + 1; | |
| 1042 t1 = new H.ReceivePortImpl(t1, null); | |
| 1043 t1.ReceivePortImpl$0(); | |
| 1044 return t1; | |
| 1045 }} | |
| 1046 | |
| 1047 }, | |
| 1048 | |
| 1049 _waitForPendingPorts_closure: {"": "Closure;callback_0", | |
| 1050 call$1: function(_) { | |
| 1051 return this.callback_0.call$0(); | |
| 1052 }, | |
| 1053 "+call:1:0": 0, | |
| 1054 $isFunction: true, | |
| 1055 $is_args1: true | |
| 1056 }, | |
| 1057 | |
| 1058 _PendingSendPortFinder: {"": "_MessageTraverser;ports,_visited", | |
| 1059 visitPrimitive$1: function(x) { | |
| 1060 }, | |
| 1061 visitList$1: function(list) { | |
| 1062 var t1 = this._visited; | |
| 1063 if (t1.$index(t1, list) != null) | |
| 1064 return; | |
| 1065 t1 = this._visited; | |
| 1066 t1.$indexSet(t1, list, true); | |
| 1067 J.forEach$1$ax(list, this.get$_dispatch()); | |
| 1068 }, | |
| 1069 visitMap$1: function(map) { | |
| 1070 var t1 = this._visited; | |
| 1071 if (t1.$index(t1, map) != null) | |
| 1072 return; | |
| 1073 t1 = this._visited; | |
| 1074 t1.$indexSet(t1, map, true); | |
| 1075 t1 = map.get$values(map); | |
| 1076 t1.forEach$1(t1, this.get$_dispatch()); | |
| 1077 }, | |
| 1078 visitSendPort$1: function(port) { | |
| 1079 }, | |
| 1080 _PendingSendPortFinder$0: function() { | |
| 1081 this._visited = new H._JsVisitedMap(null); | |
| 1082 }, | |
| 1083 static: { | |
| 1084 _PendingSendPortFinder$: function() { | |
| 1085 var t1 = new H._PendingSendPortFinder([], new H._MessageTraverserVisitedMap())
; | |
| 1086 t1._PendingSendPortFinder$0(); | |
| 1087 return t1; | |
| 1088 }} | |
| 1089 | |
| 1090 }, | |
| 1091 | |
| 1092 _JsSerializer: {"": "_Serializer;_nextFreeRefId,_visited", | |
| 1093 visitSendPort$1: function(x) { | |
| 1094 if (!!x.$is_NativeJsSendPort) | |
| 1095 return ["sendport", $globalState.currentManagerId, x._isolateId, x._receiv
ePort.get$_id()]; | |
| 1096 if (!!x.$is_WorkerSendPort) | |
| 1097 return ["sendport", x._workerId, x._isolateId, x._receivePortId]; | |
| 1098 throw H.wrapException("Illegal underlying port " + H.S(x)); | |
| 1099 } | |
| 1100 }, | |
| 1101 | |
| 1102 _JsCopier: {"": "_Copier;_visited", | |
| 1103 visitSendPort$1: function(x) { | |
| 1104 if (!!x.$is_NativeJsSendPort) | |
| 1105 return new H._NativeJsSendPort(x._receivePort, x._isolateId); | |
| 1106 if (!!x.$is_WorkerSendPort) | |
| 1107 return new H._WorkerSendPort(x._workerId, x._receivePortId, x._isolateId); | |
| 1108 throw H.wrapException("Illegal underlying port " + H.S(x)); | |
| 1109 } | |
| 1110 }, | |
| 1111 | |
| 1112 _JsDeserializer: {"": "_Deserializer;_deserialized", | |
| 1113 deserializeSendPort$1: function(list) { | |
| 1114 var t1, managerId, isolateId, receivePortId, isolate, receivePort; | |
| 1115 t1 = J.getInterceptor$asx(list); | |
| 1116 managerId = t1.$index(list, 1); | |
| 1117 isolateId = t1.$index(list, 2); | |
| 1118 receivePortId = t1.$index(list, 3); | |
| 1119 if (J.$eq(managerId, $globalState.currentManagerId)) { | |
| 1120 t1 = $globalState.isolates; | |
| 1121 isolate = t1.$index(t1, isolateId); | |
| 1122 if (isolate == null) | |
| 1123 return; | |
| 1124 receivePort = isolate.lookup$1(receivePortId); | |
| 1125 if (receivePort == null) | |
| 1126 return; | |
| 1127 return new H._NativeJsSendPort(receivePort, isolateId); | |
| 1128 } else | |
| 1129 return new H._WorkerSendPort(managerId, receivePortId, isolateId); | |
| 1130 } | |
| 1131 }, | |
| 1132 | |
| 1133 _JsVisitedMap: {"": "Object;tagged", | |
| 1134 $index: function(_, object) { | |
| 1135 return object.__MessageTraverser__attached_info__; | |
| 1136 }, | |
| 1137 $indexSet: function(_, object, info) { | |
| 1138 this.tagged.push(object); | |
| 1139 object.__MessageTraverser__attached_info__ = info; | |
| 1140 }, | |
| 1141 reset$0: function(_) { | |
| 1142 this.tagged = P.List_List(null, null); | |
| 1143 }, | |
| 1144 cleanup$0: function() { | |
| 1145 var $length, i, t1; | |
| 1146 for ($length = this.tagged.length, i = 0; i < $length; ++i) { | |
| 1147 t1 = this.tagged; | |
| 1148 if (i >= t1.length) | |
| 1149 throw H.ioore(t1, i); | |
| 1150 t1[i].__MessageTraverser__attached_info__ = null; | |
| 1151 } | |
| 1152 this.tagged = null; | |
| 1153 } | |
| 1154 }, | |
| 1155 | |
| 1156 _MessageTraverserVisitedMap: {"": "Object;", | |
| 1157 $index: function(_, object) { | |
| 1158 return; | |
| 1159 }, | |
| 1160 $indexSet: function(_, object, info) { | |
| 1161 }, | |
| 1162 reset$0: function(_) { | |
| 1163 }, | |
| 1164 cleanup$0: function() { | |
| 1165 } | |
| 1166 }, | |
| 1167 | |
| 1168 _MessageTraverser: {"": "Object;", | |
| 1169 traverse$1: function(x) { | |
| 1170 var result, t1; | |
| 1171 if (H._MessageTraverser_isPrimitive(x)) | |
| 1172 return this.visitPrimitive$1(x); | |
| 1173 t1 = this._visited; | |
| 1174 t1.reset$0(t1); | |
| 1175 result = null; | |
| 1176 try { | |
| 1177 result = this._dispatch$1(x); | |
| 1178 } finally { | |
| 1179 this._visited.cleanup$0(); | |
| 1180 } | |
| 1181 return result; | |
| 1182 }, | |
| 1183 _dispatch$1: function(x) { | |
| 1184 var t1; | |
| 1185 if (x == null || typeof x === "string" || typeof x === "number" || typeof x
=== "boolean") | |
| 1186 return this.visitPrimitive$1(x); | |
| 1187 t1 = J.getInterceptor(x); | |
| 1188 if (typeof x === "object" && x !== null && (x.constructor === Array || !!t1.
$isList)) | |
| 1189 return this.visitList$1(x); | |
| 1190 if (typeof x === "object" && x !== null && !!t1.$isMap) | |
| 1191 return this.visitMap$1(x); | |
| 1192 if (typeof x === "object" && x !== null && !!t1.$isSendPort) | |
| 1193 return this.visitSendPort$1(x); | |
| 1194 return this.visitObject$1(x); | |
| 1195 }, | |
| 1196 get$_dispatch: function() { | |
| 1197 return new H.BoundClosure$1(this, H._MessageTraverser.prototype._dispatch$1,
null, "_dispatch$1"); | |
| 1198 }, | |
| 1199 visitObject$1: function(x) { | |
| 1200 throw H.wrapException("Message serialization: Illegal value " + H.S(x) + " p
assed"); | |
| 1201 } | |
| 1202 }, | |
| 1203 | |
| 1204 _Copier: {"": "_MessageTraverser;", | |
| 1205 visitPrimitive$1: function(x) { | |
| 1206 return x; | |
| 1207 }, | |
| 1208 visitList$1: function(list) { | |
| 1209 var t1, copy, len, t2, i, t3; | |
| 1210 t1 = this._visited; | |
| 1211 copy = t1.$index(t1, list); | |
| 1212 if (copy != null) | |
| 1213 return copy; | |
| 1214 t1 = J.getInterceptor$asx(list); | |
| 1215 len = t1.get$length(list); | |
| 1216 copy = P.List_List(len, null); | |
| 1217 t2 = this._visited; | |
| 1218 t2.$indexSet(t2, list, copy); | |
| 1219 if (typeof len !== "number") | |
| 1220 throw H.iae(len); | |
| 1221 t2 = copy.length; | |
| 1222 i = 0; | |
| 1223 for (; i < len; ++i) { | |
| 1224 t3 = this._dispatch$1(t1.$index(list, i)); | |
| 1225 if (i >= t2) | |
| 1226 throw H.ioore(copy, i); | |
| 1227 copy[i] = t3; | |
| 1228 } | |
| 1229 return copy; | |
| 1230 }, | |
| 1231 visitMap$1: function(map) { | |
| 1232 var t1, t2; | |
| 1233 t1 = {}; | |
| 1234 t2 = this._visited; | |
| 1235 t1.copy_0 = t2.$index(t2, map); | |
| 1236 t2 = t1.copy_0; | |
| 1237 if (t2 != null) | |
| 1238 return t2; | |
| 1239 t1.copy_0 = P.LinkedHashMap_LinkedHashMap(null, null, null, null, null); | |
| 1240 t2 = this._visited; | |
| 1241 t2.$indexSet(t2, map, t1.copy_0); | |
| 1242 map.forEach$1(map, new H._Copier_visitMap_closure(t1, this)); | |
| 1243 return t1.copy_0; | |
| 1244 } | |
| 1245 }, | |
| 1246 | |
| 1247 _Copier_visitMap_closure: {"": "Closure;box_0,this_1", | |
| 1248 call$2: function(key, val) { | |
| 1249 var t1 = this.this_1; | |
| 1250 J.$indexSet$ax(this.box_0.copy_0, t1._dispatch$1(key), t1._dispatch$1(val)); | |
| 1251 }, | |
| 1252 "+call:2:0": 0, | |
| 1253 $isFunction: true, | |
| 1254 $is_args2: true | |
| 1255 }, | |
| 1256 | |
| 1257 _Serializer: {"": "_MessageTraverser;", | |
| 1258 visitPrimitive$1: function(x) { | |
| 1259 return x; | |
| 1260 }, | |
| 1261 visitList$1: function(list) { | |
| 1262 var t1, copyId, id; | |
| 1263 t1 = this._visited; | |
| 1264 copyId = t1.$index(t1, list); | |
| 1265 if (copyId != null) | |
| 1266 return ["ref", copyId]; | |
| 1267 id = this._nextFreeRefId; | |
| 1268 this._nextFreeRefId = id + 1; | |
| 1269 t1 = this._visited; | |
| 1270 t1.$indexSet(t1, list, id); | |
| 1271 return ["list", id, this._serializeList$1(list)]; | |
| 1272 }, | |
| 1273 visitMap$1: function(map) { | |
| 1274 var t1, copyId, id, keys; | |
| 1275 t1 = this._visited; | |
| 1276 copyId = t1.$index(t1, map); | |
| 1277 if (copyId != null) | |
| 1278 return ["ref", copyId]; | |
| 1279 id = this._nextFreeRefId; | |
| 1280 this._nextFreeRefId = id + 1; | |
| 1281 t1 = this._visited; | |
| 1282 t1.$indexSet(t1, map, id); | |
| 1283 t1 = map.get$keys(); | |
| 1284 keys = this._serializeList$1(P.List_List$from(t1, true, H.getRuntimeTypeArgu
ment(t1, "IterableBase", 0))); | |
| 1285 t1 = map.get$values(map); | |
| 1286 return ["map", id, keys, this._serializeList$1(P.List_List$from(t1, true, H.
getRuntimeTypeArgument(t1, "IterableBase", 0)))]; | |
| 1287 }, | |
| 1288 _serializeList$1: function(list) { | |
| 1289 var t1, len, result, t2, i, t3; | |
| 1290 t1 = J.getInterceptor$asx(list); | |
| 1291 len = t1.get$length(list); | |
| 1292 result = P.List_List(len, null); | |
| 1293 if (typeof len !== "number") | |
| 1294 throw H.iae(len); | |
| 1295 t2 = result.length; | |
| 1296 i = 0; | |
| 1297 for (; i < len; ++i) { | |
| 1298 t3 = this._dispatch$1(t1.$index(list, i)); | |
| 1299 if (i >= t2) | |
| 1300 throw H.ioore(result, i); | |
| 1301 result[i] = t3; | |
| 1302 } | |
| 1303 return result; | |
| 1304 } | |
| 1305 }, | |
| 1306 | |
| 1307 _Deserializer: {"": "Object;", | |
| 1308 deserialize$1: function(x) { | |
| 1309 if (H._Deserializer_isPrimitive(x)) | |
| 1310 return x; | |
| 1311 this._deserialized = P.HashMap_HashMap(null, null, null, null, null); | |
| 1312 return this._deserializeHelper$1(x); | |
| 1313 }, | |
| 1314 _deserializeHelper$1: function(x) { | |
| 1315 var t1, id; | |
| 1316 if (x == null || typeof x === "string" || typeof x === "number" || typeof x
=== "boolean") | |
| 1317 return x; | |
| 1318 t1 = J.getInterceptor$asx(x); | |
| 1319 switch (t1.$index(x, 0)) { | |
| 1320 case "ref": | |
| 1321 id = t1.$index(x, 1); | |
| 1322 t1 = this._deserialized; | |
| 1323 return t1.$index(t1, id); | |
| 1324 case "list": | |
| 1325 return this._deserializeList$1(x); | |
| 1326 case "map": | |
| 1327 return this._deserializeMap$1(x); | |
| 1328 case "sendport": | |
| 1329 return this.deserializeSendPort$1(x); | |
| 1330 default: | |
| 1331 return this.deserializeObject$1(x); | |
| 1332 } | |
| 1333 }, | |
| 1334 _deserializeList$1: function(x) { | |
| 1335 var t1, id, dartList, len, i; | |
| 1336 t1 = J.getInterceptor$asx(x); | |
| 1337 id = t1.$index(x, 1); | |
| 1338 dartList = t1.$index(x, 2); | |
| 1339 t1 = this._deserialized; | |
| 1340 t1.$indexSet(t1, id, dartList); | |
| 1341 t1 = J.getInterceptor$asx(dartList); | |
| 1342 len = t1.get$length(dartList); | |
| 1343 if (typeof len !== "number") | |
| 1344 throw H.iae(len); | |
| 1345 i = 0; | |
| 1346 for (; i < len; ++i) | |
| 1347 t1.$indexSet(dartList, i, this._deserializeHelper$1(t1.$index(dartList, i)
)); | |
| 1348 return dartList; | |
| 1349 }, | |
| 1350 _deserializeMap$1: function(x) { | |
| 1351 var result, t1, id, t2, keys, values, len, i; | |
| 1352 result = P.LinkedHashMap_LinkedHashMap(null, null, null, null, null); | |
| 1353 t1 = J.getInterceptor$asx(x); | |
| 1354 id = t1.$index(x, 1); | |
| 1355 t2 = this._deserialized; | |
| 1356 t2.$indexSet(t2, id, result); | |
| 1357 keys = t1.$index(x, 2); | |
| 1358 values = t1.$index(x, 3); | |
| 1359 t1 = J.getInterceptor$asx(keys); | |
| 1360 len = t1.get$length(keys); | |
| 1361 if (typeof len !== "number") | |
| 1362 throw H.iae(len); | |
| 1363 t2 = J.getInterceptor$asx(values); | |
| 1364 i = 0; | |
| 1365 for (; i < len; ++i) | |
| 1366 result.$indexSet(result, this._deserializeHelper$1(t1.$index(keys, i)), th
is._deserializeHelper$1(t2.$index(values, i))); | |
| 1367 return result; | |
| 1368 }, | |
| 1369 deserializeObject$1: function(x) { | |
| 1370 throw H.wrapException("Unexpected serialized object"); | |
| 1371 } | |
| 1372 }, | |
| 1373 | |
| 1374 TimerImpl: {"": "Object;_once,_inEventLoop,_handle", | |
| 1375 TimerImpl$2: function(milliseconds, callback) { | |
| 1376 var t1, t2; | |
| 1377 if (milliseconds === 0) | |
| 1378 t1 = $.get$globalThis().setTimeout == null || $globalState.isWorker === tr
ue; | |
| 1379 else | |
| 1380 t1 = false; | |
| 1381 if (t1) { | |
| 1382 this._handle = 1; | |
| 1383 t1 = $globalState.topEventLoop; | |
| 1384 t2 = $globalState.currentContext; | |
| 1385 t1.events._add$1(new H._IsolateEvent(t2, new H.TimerImpl_internalCallback(
this, callback), "timer")); | |
| 1386 this._inEventLoop = true; | |
| 1387 } else if ($.get$globalThis().setTimeout != null) { | |
| 1388 t1 = $globalState.topEventLoop; | |
| 1389 t1.activeTimerCount = t1.activeTimerCount + 1; | |
| 1390 this._handle = $.get$globalThis().setTimeout(H.convertDartClosureToJS(new
H.TimerImpl_internalCallback0(this, callback), 0), milliseconds); | |
| 1391 } else | |
| 1392 throw H.wrapException(P.UnsupportedError$("Timer greater than 0.")); | |
| 1393 }, | |
| 1394 static: { | |
| 1395 TimerImpl$: function(milliseconds, callback) { | |
| 1396 var t1 = new H.TimerImpl(true, false, null); | |
| 1397 t1.TimerImpl$2(milliseconds, callback); | |
| 1398 return t1; | |
| 1399 }} | |
| 1400 | |
| 1401 }, | |
| 1402 | |
| 1403 TimerImpl_internalCallback: {"": "Closure;this_0,callback_1", | |
| 1404 call$0: function() { | |
| 1405 this.this_0._handle = null; | |
| 1406 this.callback_1.call$0(); | |
| 1407 }, | |
| 1408 "+call:0:0": 0, | |
| 1409 $isFunction: true | |
| 1410 }, | |
| 1411 | |
| 1412 TimerImpl_internalCallback0: {"": "Closure;this_2,callback_3", | |
| 1413 call$0: function() { | |
| 1414 this.this_2._handle = null; | |
| 1415 var t1 = $globalState.topEventLoop; | |
| 1416 t1.activeTimerCount = t1.activeTimerCount - 1; | |
| 1417 this.callback_3.call$0(); | |
| 1418 }, | |
| 1419 "+call:0:0": 0, | |
| 1420 $isFunction: true | |
| 1421 }}], | |
| 1422 ["_js_helper", "dart:_js_helper", , H, { | |
| 1423 isJsIndexable: function(object, record) { | |
| 1424 var result, t1; | |
| 1425 if (record != null) { | |
| 1426 result = record.x; | |
| 1427 if (result != null) | |
| 1428 return result; | |
| 1429 } | |
| 1430 t1 = J.getInterceptor(object); | |
| 1431 return typeof object === "object" && object !== null && !!t1.$isJavaScriptInde
xingBehavior; | |
| 1432 }, | |
| 1433 | |
| 1434 S: function(value) { | |
| 1435 var res; | |
| 1436 if (typeof value === "string") | |
| 1437 return value; | |
| 1438 if (typeof value === "number") { | |
| 1439 if (value !== 0) | |
| 1440 return "" + value; | |
| 1441 } else if (true === value) | |
| 1442 return "true"; | |
| 1443 else if (false === value) | |
| 1444 return "false"; | |
| 1445 else if (value == null) | |
| 1446 return "null"; | |
| 1447 res = J.toString$0(value); | |
| 1448 if (typeof res !== "string") | |
| 1449 throw H.wrapException(P.ArgumentError$(value)); | |
| 1450 return res; | |
| 1451 }, | |
| 1452 | |
| 1453 Primitives_initializeStatics: function(id) { | |
| 1454 $.Primitives_mirrorFunctionCacheName = $.Primitives_mirrorFunctionCacheName +
("_" + H.S(id)); | |
| 1455 $.Primitives_mirrorInvokeCacheName = $.Primitives_mirrorInvokeCacheName + ("_"
+ H.S(id)); | |
| 1456 }, | |
| 1457 | |
| 1458 Primitives_objectHashCode: function(object) { | |
| 1459 var hash = object.$identityHash; | |
| 1460 if (hash == null) { | |
| 1461 hash = Math.random() * 0x3fffffff | 0; | |
| 1462 object.$identityHash = hash; | |
| 1463 } | |
| 1464 return hash; | |
| 1465 }, | |
| 1466 | |
| 1467 Primitives__throwFormatException: function(string) { | |
| 1468 throw H.wrapException(P.FormatException$(string)); | |
| 1469 }, | |
| 1470 | |
| 1471 Primitives_parseInt: function(source, radix, handleError) { | |
| 1472 var match, t1; | |
| 1473 handleError = H.Primitives__throwFormatException$closure; | |
| 1474 if (typeof source !== "string") | |
| 1475 H.throwExpression(new P.ArgumentError(source)); | |
| 1476 match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source); | |
| 1477 if (match != null) { | |
| 1478 t1 = match.length; | |
| 1479 if (2 >= t1) | |
| 1480 throw H.ioore(match, 2); | |
| 1481 if (match[2] != null) | |
| 1482 return parseInt(source, 16); | |
| 1483 if (3 >= t1) | |
| 1484 throw H.ioore(match, 3); | |
| 1485 if (match[3] != null) | |
| 1486 return parseInt(source, 10); | |
| 1487 return handleError.call$1(source); | |
| 1488 } | |
| 1489 if (match == null) | |
| 1490 return handleError.call$1(source); | |
| 1491 return parseInt(source, 10); | |
| 1492 }, | |
| 1493 | |
| 1494 Primitives_objectTypeName: function(object) { | |
| 1495 var $name, decompiled, t1; | |
| 1496 $name = C.JS_CONST_86y(J.getInterceptor(object)); | |
| 1497 if ($name === "Object") { | |
| 1498 decompiled = String(object.constructor).match(/^\s*function\s*(\S*)\s*\(/)[1
]; | |
| 1499 if (typeof decompiled === "string") | |
| 1500 $name = decompiled; | |
| 1501 } | |
| 1502 t1 = J.getInterceptor$s($name); | |
| 1503 if (t1.codeUnitAt$1($name, 0) === 36) | |
| 1504 $name = t1.substring$1($name, 1); | |
| 1505 t1 = H.getRuntimeTypeInfo(object); | |
| 1506 return H.S($name) + H.joinArguments(t1, 0, null); | |
| 1507 }, | |
| 1508 | |
| 1509 Primitives_objectToString: function(object) { | |
| 1510 return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
| 1511 }, | |
| 1512 | |
| 1513 Primitives_newFixedList: function($length) { | |
| 1514 var result = new Array($length); | |
| 1515 result.fixed$length = true; | |
| 1516 return result; | |
| 1517 }, | |
| 1518 | |
| 1519 Primitives__fromCharCodeApply: function(array) { | |
| 1520 var end, t1, result, i, subarray, t2; | |
| 1521 end = array.length; | |
| 1522 for (t1 = end <= 500, result = "", i = 0; i < end; i += 500) { | |
| 1523 if (t1) | |
| 1524 subarray = array; | |
| 1525 else { | |
| 1526 t2 = i + 500; | |
| 1527 t2 = t2 < end ? t2 : end; | |
| 1528 subarray = array.slice(i, t2); | |
| 1529 } | |
| 1530 result += String.fromCharCode.apply(null, subarray); | |
| 1531 } | |
| 1532 return result; | |
| 1533 }, | |
| 1534 | |
| 1535 Primitives_stringFromCodePoints: function(codePoints) { | |
| 1536 var a, t1, i; | |
| 1537 a = []; | |
| 1538 a.$builtinTypeInfo = [J.JSInt]; | |
| 1539 for (t1 = new H.ListIterator(codePoints, codePoints.length, 0, null); t1.moveN
ext$0();) { | |
| 1540 i = t1._current; | |
| 1541 if (typeof i !== "number" || Math.floor(i) !== i) | |
| 1542 throw H.wrapException(new P.ArgumentError(i)); | |
| 1543 if (i <= 65535) | |
| 1544 a.push(i); | |
| 1545 else if (i <= 1114111) { | |
| 1546 a.push(55296 + (C.JSInt_methods.$shr(i - 65536, 10) & 1023)); | |
| 1547 a.push(56320 + (i & 1023)); | |
| 1548 } else | |
| 1549 throw H.wrapException(new P.ArgumentError(i)); | |
| 1550 } | |
| 1551 return H.Primitives__fromCharCodeApply(a); | |
| 1552 }, | |
| 1553 | |
| 1554 Primitives_stringFromCharCodes: function(charCodes) { | |
| 1555 var t1, i; | |
| 1556 for (t1 = new H.ListIterator(charCodes, charCodes.length, 0, null); t1.moveNex
t$0();) { | |
| 1557 i = t1._current; | |
| 1558 if (typeof i !== "number" || Math.floor(i) !== i) | |
| 1559 throw H.wrapException(new P.ArgumentError(i)); | |
| 1560 if (i < 0) | |
| 1561 throw H.wrapException(new P.ArgumentError(i)); | |
| 1562 if (i > 65535) | |
| 1563 return H.Primitives_stringFromCodePoints(charCodes); | |
| 1564 } | |
| 1565 return H.Primitives__fromCharCodeApply(charCodes); | |
| 1566 }, | |
| 1567 | |
| 1568 Primitives_lazyAsJsDate: function(receiver) { | |
| 1569 if (receiver.date === void 0) | |
| 1570 receiver.date = new Date(receiver.millisecondsSinceEpoch); | |
| 1571 return receiver.date; | |
| 1572 }, | |
| 1573 | |
| 1574 Primitives_getYear: function(receiver) { | |
| 1575 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCFullYear() +
0 : H.Primitives_lazyAsJsDate(receiver).getFullYear() + 0; | |
| 1576 }, | |
| 1577 | |
| 1578 Primitives_getMonth: function(receiver) { | |
| 1579 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMonth() + 1
: H.Primitives_lazyAsJsDate(receiver).getMonth() + 1; | |
| 1580 }, | |
| 1581 | |
| 1582 Primitives_getDay: function(receiver) { | |
| 1583 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCDate() + 0 :
H.Primitives_lazyAsJsDate(receiver).getDate() + 0; | |
| 1584 }, | |
| 1585 | |
| 1586 Primitives_getHours: function(receiver) { | |
| 1587 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCHours() + 0
: H.Primitives_lazyAsJsDate(receiver).getHours() + 0; | |
| 1588 }, | |
| 1589 | |
| 1590 Primitives_getMinutes: function(receiver) { | |
| 1591 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMinutes() +
0 : H.Primitives_lazyAsJsDate(receiver).getMinutes() + 0; | |
| 1592 }, | |
| 1593 | |
| 1594 Primitives_getSeconds: function(receiver) { | |
| 1595 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCSeconds() +
0 : H.Primitives_lazyAsJsDate(receiver).getSeconds() + 0; | |
| 1596 }, | |
| 1597 | |
| 1598 Primitives_getMilliseconds: function(receiver) { | |
| 1599 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMilliseconds
() + 0 : H.Primitives_lazyAsJsDate(receiver).getMilliseconds() + 0; | |
| 1600 }, | |
| 1601 | |
| 1602 Primitives_getProperty: function(object, key) { | |
| 1603 if (object == null || typeof object === "boolean" || typeof object === "number
" || typeof object === "string") | |
| 1604 throw H.wrapException(new P.ArgumentError(object)); | |
| 1605 return object[key]; | |
| 1606 }, | |
| 1607 | |
| 1608 Primitives_setProperty: function(object, key, value) { | |
| 1609 if (object == null || typeof object === "boolean" || typeof object === "number
" || typeof object === "string") | |
| 1610 throw H.wrapException(new P.ArgumentError(object)); | |
| 1611 object[key] = value; | |
| 1612 }, | |
| 1613 | |
| 1614 Primitives_applyFunction: function($function, positionalArguments, namedArgument
s) { | |
| 1615 var t1, buffer, $arguments, allNamedArguments, listOfNamedArguments, t2, t3, t
4, selectorName, jsFunction; | |
| 1616 t1 = {}; | |
| 1617 t1.argumentCount_0 = 0; | |
| 1618 buffer = P.StringBuffer$(""); | |
| 1619 $arguments = []; | |
| 1620 t1.argumentCount_0 = t1.argumentCount_0 + positionalArguments.length; | |
| 1621 C.JSArray_methods.addAll$1($arguments, positionalArguments); | |
| 1622 if ("call$catchAll" in $function) { | |
| 1623 allNamedArguments = $function.call$catchAll(); | |
| 1624 if (namedArguments != null && !namedArguments.get$isEmpty(namedArguments)) | |
| 1625 namedArguments.forEach$1(namedArguments, new H.Primitives_applyFunction_cl
osure(allNamedArguments)); | |
| 1626 listOfNamedArguments = Object.getOwnPropertyNames(allNamedArguments); | |
| 1627 t2 = t1.argumentCount_0; | |
| 1628 t3 = J.getInterceptor$asx(listOfNamedArguments); | |
| 1629 t4 = t3.get$length(listOfNamedArguments); | |
| 1630 if (typeof t4 !== "number") | |
| 1631 throw H.iae(t4); | |
| 1632 t1.argumentCount_0 = t2 + t4; | |
| 1633 t3.forEach$1(listOfNamedArguments, new H.Primitives_applyFunction_closure0(b
uffer, $arguments, allNamedArguments)); | |
| 1634 } else if (namedArguments != null && !namedArguments.get$isEmpty(namedArgument
s)) | |
| 1635 namedArguments.forEach$1(namedArguments, new H.Primitives_applyFunction_clos
ure1(t1, buffer, $arguments)); | |
| 1636 selectorName = "call$" + H.S(t1.argumentCount_0) + H.S(buffer); | |
| 1637 jsFunction = $function[selectorName]; | |
| 1638 if (jsFunction == null) { | |
| 1639 if (namedArguments == null) | |
| 1640 t1 = []; | |
| 1641 else { | |
| 1642 t1 = namedArguments.get$keys(); | |
| 1643 t1 = P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "IterableBase
", 0)); | |
| 1644 } | |
| 1645 return J.noSuchMethod$1($function, new H.JSInvocationMirror(C.Symbol_call, s
electorName, 0, $arguments, t1, null)); | |
| 1646 } | |
| 1647 return jsFunction.apply($function, $arguments); | |
| 1648 }, | |
| 1649 | |
| 1650 iae: function(argument) { | |
| 1651 throw H.wrapException(P.ArgumentError$(argument)); | |
| 1652 }, | |
| 1653 | |
| 1654 ioore: function(receiver, index) { | |
| 1655 if (receiver == null) | |
| 1656 J.get$length$asx(receiver); | |
| 1657 if (typeof index !== "number" || Math.floor(index) !== index) | |
| 1658 H.iae(index); | |
| 1659 throw H.wrapException(P.RangeError$value(index)); | |
| 1660 }, | |
| 1661 | |
| 1662 wrapException: function(ex) { | |
| 1663 var wrapper; | |
| 1664 if (ex == null) | |
| 1665 ex = new P.NullThrownError(); | |
| 1666 wrapper = new Error(); | |
| 1667 wrapper.dartException = ex; | |
| 1668 if ("defineProperty" in Object) { | |
| 1669 Object.defineProperty(wrapper, "message", { get: H.toStringWrapper$closure.c
all$0 }); | |
| 1670 wrapper.name = ""; | |
| 1671 } else | |
| 1672 wrapper.toString = H.toStringWrapper$closure.call$0; | |
| 1673 return wrapper; | |
| 1674 }, | |
| 1675 | |
| 1676 toStringWrapper: function() { | |
| 1677 return J.toString$0(this.dartException); | |
| 1678 }, | |
| 1679 | |
| 1680 throwExpression: function(ex) { | |
| 1681 throw H.wrapException(ex); | |
| 1682 }, | |
| 1683 | |
| 1684 makeLiteralListConst: function(list) { | |
| 1685 list.immutable$list = true; | |
| 1686 list.fixed$length = true; | |
| 1687 return list; | |
| 1688 }, | |
| 1689 | |
| 1690 unwrapException: function(ex) { | |
| 1691 var t1, message, number, ieErrorCode, t2, t3, t4, nullLiteralCall, t5, t6, t7,
t8, t9, match; | |
| 1692 t1 = new H.unwrapException_saveStackTrace(ex); | |
| 1693 if (ex == null) | |
| 1694 return; | |
| 1695 if (typeof ex !== "object") | |
| 1696 return ex; | |
| 1697 if ("dartException" in ex) | |
| 1698 return t1.call$1(ex.dartException); | |
| 1699 else if (!("message" in ex)) | |
| 1700 return ex; | |
| 1701 message = ex.message; | |
| 1702 if ("number" in ex && typeof ex.number == "number") { | |
| 1703 number = ex.number; | |
| 1704 ieErrorCode = number & 65535; | |
| 1705 if ((C.JSInt_methods.$shr(number, 16) & 8191) === 10) | |
| 1706 switch (ieErrorCode) { | |
| 1707 case 438: | |
| 1708 return t1.call$1(H.JsNoSuchMethodError$(H.S(message) + " (Error " + ie
ErrorCode + ")", null)); | |
| 1709 case 445: | |
| 1710 case 5007: | |
| 1711 t2 = H.S(message) + " (Error " + ieErrorCode + ")"; | |
| 1712 return t1.call$1(new H.NullError(t2, null)); | |
| 1713 default: | |
| 1714 } | |
| 1715 } | |
| 1716 if (ex instanceof TypeError) { | |
| 1717 t2 = $.get$TypeErrorDecoder_noSuchMethodPattern(); | |
| 1718 t3 = $.get$TypeErrorDecoder_notClosurePattern(); | |
| 1719 t4 = $.get$TypeErrorDecoder_nullCallPattern(); | |
| 1720 nullLiteralCall = $.get$TypeErrorDecoder_nullLiteralCallPattern(); | |
| 1721 t5 = $.get$TypeErrorDecoder_undefinedCallPattern(); | |
| 1722 t6 = $.get$TypeErrorDecoder_undefinedLiteralCallPattern(); | |
| 1723 t7 = $.get$TypeErrorDecoder_nullPropertyPattern(); | |
| 1724 $.get$TypeErrorDecoder_nullLiteralPropertyPattern(); | |
| 1725 t8 = $.get$TypeErrorDecoder_undefinedPropertyPattern(); | |
| 1726 t9 = $.get$TypeErrorDecoder_undefinedLiteralPropertyPattern(); | |
| 1727 match = t2.matchTypeError$1(message); | |
| 1728 if (match != null) | |
| 1729 return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
| 1730 else { | |
| 1731 match = t3.matchTypeError$1(message); | |
| 1732 if (match != null) { | |
| 1733 match.method = "call"; | |
| 1734 return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
| 1735 } else { | |
| 1736 match = t4.matchTypeError$1(message); | |
| 1737 if (match == null) { | |
| 1738 match = nullLiteralCall.matchTypeError$1(message); | |
| 1739 if (match == null) { | |
| 1740 match = t5.matchTypeError$1(message); | |
| 1741 if (match == null) { | |
| 1742 match = t6.matchTypeError$1(message); | |
| 1743 if (match == null) { | |
| 1744 match = t7.matchTypeError$1(message); | |
| 1745 if (match == null) { | |
| 1746 match = nullLiteralCall.matchTypeError$1(message); | |
| 1747 if (match == null) { | |
| 1748 match = t8.matchTypeError$1(message); | |
| 1749 if (match == null) { | |
| 1750 match = t9.matchTypeError$1(message); | |
| 1751 t2 = match != null; | |
| 1752 } else | |
| 1753 t2 = true; | |
| 1754 } else | |
| 1755 t2 = true; | |
| 1756 } else | |
| 1757 t2 = true; | |
| 1758 } else | |
| 1759 t2 = true; | |
| 1760 } else | |
| 1761 t2 = true; | |
| 1762 } else | |
| 1763 t2 = true; | |
| 1764 } else | |
| 1765 t2 = true; | |
| 1766 if (t2) { | |
| 1767 t2 = match == null ? null : match.method; | |
| 1768 return t1.call$1(new H.NullError(message, t2)); | |
| 1769 } | |
| 1770 } | |
| 1771 } | |
| 1772 t2 = typeof message === "string" ? message : ""; | |
| 1773 return t1.call$1(new H.UnknownJsTypeError(t2)); | |
| 1774 } | |
| 1775 if (ex instanceof RangeError) { | |
| 1776 if (typeof message === "string" && message.indexOf("call stack") !== -1) | |
| 1777 return new P.StackOverflowError(); | |
| 1778 return t1.call$1(new P.ArgumentError(null)); | |
| 1779 } | |
| 1780 if (typeof InternalError == "function" && ex instanceof InternalError) | |
| 1781 if (typeof message === "string" && message === "too much recursion") | |
| 1782 return new P.StackOverflowError(); | |
| 1783 return ex; | |
| 1784 }, | |
| 1785 | |
| 1786 objectHashCode: function(object) { | |
| 1787 if (object == null || typeof object != 'object') | |
| 1788 return J.get$hashCode$(object); | |
| 1789 else | |
| 1790 return H.Primitives_objectHashCode(object); | |
| 1791 }, | |
| 1792 | |
| 1793 fillLiteralMap: function(keyValuePairs, result) { | |
| 1794 var $length, index, index0, index1; | |
| 1795 $length = keyValuePairs.length; | |
| 1796 for (index = 0; index < $length; index = index1) { | |
| 1797 index0 = index + 1; | |
| 1798 index1 = index0 + 1; | |
| 1799 result.$indexSet(result, keyValuePairs[index], keyValuePairs[index0]); | |
| 1800 } | |
| 1801 return result; | |
| 1802 }, | |
| 1803 | |
| 1804 invokeClosure: function(closure, isolate, numberOfArguments, arg1, arg2, arg3, a
rg4) { | |
| 1805 var t1 = J.getInterceptor(numberOfArguments); | |
| 1806 if (t1.$eq(numberOfArguments, 0)) | |
| 1807 return H._callInIsolate(isolate, new H.invokeClosure_closure(closure)); | |
| 1808 else if (t1.$eq(numberOfArguments, 1)) | |
| 1809 return H._callInIsolate(isolate, new H.invokeClosure_closure0(closure, arg1)
); | |
| 1810 else if (t1.$eq(numberOfArguments, 2)) | |
| 1811 return H._callInIsolate(isolate, new H.invokeClosure_closure1(closure, arg1,
arg2)); | |
| 1812 else if (t1.$eq(numberOfArguments, 3)) | |
| 1813 return H._callInIsolate(isolate, new H.invokeClosure_closure2(closure, arg1,
arg2, arg3)); | |
| 1814 else if (t1.$eq(numberOfArguments, 4)) | |
| 1815 return H._callInIsolate(isolate, new H.invokeClosure_closure3(closure, arg1,
arg2, arg3, arg4)); | |
| 1816 else | |
| 1817 throw H.wrapException(P.Exception_Exception("Unsupported number of arguments
for wrapped closure")); | |
| 1818 }, | |
| 1819 | |
| 1820 convertDartClosureToJS: function(closure, arity) { | |
| 1821 var $function; | |
| 1822 if (closure == null) | |
| 1823 return; | |
| 1824 $function = closure.$identity; | |
| 1825 if (!!$function) | |
| 1826 return $function; | |
| 1827 $function = (function(closure, arity, context, invoke) { return function(a1,
a2, a3, a4) { return invoke(closure, context, arity, a1, a2, a3, a4); };})(
closure,arity,$globalState.currentContext,H.invokeClosure$closure.call$7); | |
| 1828 closure.$identity = $function; | |
| 1829 return $function; | |
| 1830 }, | |
| 1831 | |
| 1832 throwCyclicInit: function(staticName) { | |
| 1833 throw H.wrapException(P.CyclicInitializationError$("Cyclic initialization for
static " + H.S(staticName))); | |
| 1834 }, | |
| 1835 | |
| 1836 createRuntimeType: function($name) { | |
| 1837 return new H.TypeImpl($name, null); | |
| 1838 }, | |
| 1839 | |
| 1840 setRuntimeTypeInfo: function(target, typeInfo) { | |
| 1841 if (target != null) | |
| 1842 target.$builtinTypeInfo = typeInfo; | |
| 1843 return target; | |
| 1844 }, | |
| 1845 | |
| 1846 getRuntimeTypeInfo: function(target) { | |
| 1847 if (target == null) | |
| 1848 return; | |
| 1849 return target.$builtinTypeInfo; | |
| 1850 }, | |
| 1851 | |
| 1852 getRuntimeTypeArguments: function(target, substitutionName) { | |
| 1853 return H.substitute(target["$as" + H.S(substitutionName)], H.getRuntimeTypeInf
o(target)); | |
| 1854 }, | |
| 1855 | |
| 1856 getRuntimeTypeArgument: function(target, substitutionName, index) { | |
| 1857 var $arguments = H.getRuntimeTypeArguments(target, substitutionName); | |
| 1858 return $arguments == null ? null : $arguments[index]; | |
| 1859 }, | |
| 1860 | |
| 1861 getRuntimeTypeAsString: function(runtimeType, onTypeVariable) { | |
| 1862 return runtimeType[0].builtin$cls + H.joinArguments(runtimeType, 1, onTypeVari
able); | |
| 1863 }, | |
| 1864 | |
| 1865 runtimeTypeToString: function(type, onTypeVariable) { | |
| 1866 if (type == null) | |
| 1867 return "dynamic"; | |
| 1868 else if (typeof type === "object" && type !== null && type.constructor === Arr
ay) | |
| 1869 return H.getRuntimeTypeAsString(type, onTypeVariable); | |
| 1870 else if (typeof type == "function") | |
| 1871 return type.builtin$cls; | |
| 1872 else if (typeof type === "number" && Math.floor(type) === type) | |
| 1873 return C.JSInt_methods.toString$0(type); | |
| 1874 else | |
| 1875 return; | |
| 1876 }, | |
| 1877 | |
| 1878 joinArguments: function(types, startIndex, onTypeVariable) { | |
| 1879 var buffer, index, firstArgument, allDynamic, argument, str; | |
| 1880 if (types == null) | |
| 1881 return ""; | |
| 1882 buffer = P.StringBuffer$(""); | |
| 1883 for (index = startIndex, firstArgument = true, allDynamic = true; index < type
s.length; ++index) { | |
| 1884 if (firstArgument) | |
| 1885 firstArgument = false; | |
| 1886 else | |
| 1887 buffer._contents = buffer._contents + ", "; | |
| 1888 argument = types[index]; | |
| 1889 if (argument != null) | |
| 1890 allDynamic = false; | |
| 1891 str = H.runtimeTypeToString(argument, onTypeVariable); | |
| 1892 str = typeof str === "string" ? str : H.S(str); | |
| 1893 buffer._contents = buffer._contents + str; | |
| 1894 } | |
| 1895 return allDynamic ? "" : "<" + H.S(buffer) + ">"; | |
| 1896 }, | |
| 1897 | |
| 1898 substitute: function(substitution, $arguments) { | |
| 1899 if (typeof substitution === "object" && substitution !== null && substitution.
constructor === Array) | |
| 1900 $arguments = substitution; | |
| 1901 else if (typeof substitution == "function") { | |
| 1902 substitution = H.invokeOn(substitution, null, $arguments); | |
| 1903 if (typeof substitution === "object" && substitution !== null && substitutio
n.constructor === Array) | |
| 1904 $arguments = substitution; | |
| 1905 else if (typeof substitution == "function") | |
| 1906 $arguments = H.invokeOn(substitution, null, $arguments); | |
| 1907 } | |
| 1908 return $arguments; | |
| 1909 }, | |
| 1910 | |
| 1911 computeSignature: function(signature, context, contextName) { | |
| 1912 return H.invokeOn(signature, context, H.getRuntimeTypeArguments(context, conte
xtName)); | |
| 1913 }, | |
| 1914 | |
| 1915 invokeOn: function($function, receiver, $arguments) { | |
| 1916 return $function.apply(receiver, $arguments); | |
| 1917 }, | |
| 1918 | |
| 1919 toStringForNativeObject: function(obj) { | |
| 1920 var t1 = $.getTagFunction; | |
| 1921 return "Instance of " + (t1 == null ? "<Unknown>" : t1.call$1(obj)); | |
| 1922 }, | |
| 1923 | |
| 1924 hashCodeForNativeObject: function(object) { | |
| 1925 return H.Primitives_objectHashCode(object); | |
| 1926 }, | |
| 1927 | |
| 1928 defineProperty: function(obj, property, value) { | |
| 1929 Object.defineProperty(obj, property, {value: value, enumerable: false, writabl
e: true, configurable: true}); | |
| 1930 }, | |
| 1931 | |
| 1932 lookupAndCacheInterceptor: function(obj) { | |
| 1933 var tag, record, interceptor, interceptorClass, mark, t1; | |
| 1934 tag = $.getTagFunction.call$1(obj); | |
| 1935 record = $.dispatchRecordsForInstanceTags[tag]; | |
| 1936 if (record != null) { | |
| 1937 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
| 1938 return record.i; | |
| 1939 } | |
| 1940 interceptor = $.interceptorsForUncacheableTags[tag]; | |
| 1941 if (interceptor != null) | |
| 1942 return interceptor; | |
| 1943 interceptorClass = init.interceptorsByTag[tag]; | |
| 1944 if (interceptorClass == null) { | |
| 1945 tag = $.alternateTagFunction.call$2(obj, tag); | |
| 1946 if (tag != null) { | |
| 1947 record = $.dispatchRecordsForInstanceTags[tag]; | |
| 1948 if (record != null) { | |
| 1949 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, en
umerable: false, writable: true, configurable: true}); | |
| 1950 return record.i; | |
| 1951 } | |
| 1952 interceptor = $.interceptorsForUncacheableTags[tag]; | |
| 1953 if (interceptor != null) | |
| 1954 return interceptor; | |
| 1955 interceptorClass = init.interceptorsByTag[tag]; | |
| 1956 } | |
| 1957 } | |
| 1958 if (interceptorClass == null) | |
| 1959 return; | |
| 1960 interceptor = interceptorClass.prototype; | |
| 1961 mark = tag[0]; | |
| 1962 if (mark === "!") { | |
| 1963 record = H.makeLeafDispatchRecord(interceptor); | |
| 1964 $.dispatchRecordsForInstanceTags[tag] = record; | |
| 1965 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
| 1966 return record.i; | |
| 1967 } | |
| 1968 if (mark === "~") { | |
| 1969 $.interceptorsForUncacheableTags[tag] = interceptor; | |
| 1970 return interceptor; | |
| 1971 } | |
| 1972 if (mark === "-") { | |
| 1973 t1 = H.makeLeafDispatchRecord(interceptor); | |
| 1974 Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName,
{value: t1, enumerable: false, writable: true, configurable: true}); | |
| 1975 return t1.i; | |
| 1976 } | |
| 1977 if (mark === "+") | |
| 1978 return H.patchInteriorProto(obj, interceptor); | |
| 1979 if (mark === "*") | |
| 1980 throw H.wrapException(P.UnimplementedError$(tag)); | |
| 1981 if (init.leafTags[tag] === true) { | |
| 1982 t1 = H.makeLeafDispatchRecord(interceptor); | |
| 1983 Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName,
{value: t1, enumerable: false, writable: true, configurable: true}); | |
| 1984 return t1.i; | |
| 1985 } else | |
| 1986 return H.patchInteriorProto(obj, interceptor); | |
| 1987 }, | |
| 1988 | |
| 1989 patchInteriorProto: function(obj, interceptor) { | |
| 1990 var proto, record; | |
| 1991 proto = Object.getPrototypeOf(obj); | |
| 1992 record = J.makeDispatchRecord(interceptor, proto, null, null); | |
| 1993 Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
| 1994 return interceptor; | |
| 1995 }, | |
| 1996 | |
| 1997 makeLeafDispatchRecord: function(interceptor) { | |
| 1998 return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScr
iptIndexingBehavior); | |
| 1999 }, | |
| 2000 | |
| 2001 makeDefaultDispatchRecord: function(tag, interceptorClass, proto) { | |
| 2002 var interceptor = interceptorClass.prototype; | |
| 2003 if (init.leafTags[tag] === true) | |
| 2004 return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaS
criptIndexingBehavior); | |
| 2005 else | |
| 2006 return J.makeDispatchRecord(interceptor, proto, null, null); | |
| 2007 }, | |
| 2008 | |
| 2009 initNativeDispatch: function() { | |
| 2010 if (true === $.initNativeDispatchFlag) | |
| 2011 return; | |
| 2012 $.initNativeDispatchFlag = true; | |
| 2013 H.initNativeDispatchContinue(); | |
| 2014 }, | |
| 2015 | |
| 2016 initNativeDispatchContinue: function() { | |
| 2017 var map, tags, i, tag, proto, record, interceptorClass; | |
| 2018 $.dispatchRecordsForInstanceTags = Object.create(null); | |
| 2019 $.interceptorsForUncacheableTags = Object.create(null); | |
| 2020 H.initHooks(); | |
| 2021 map = init.interceptorsByTag; | |
| 2022 tags = Object.getOwnPropertyNames(map); | |
| 2023 if (typeof window != "undefined") { | |
| 2024 window; | |
| 2025 for (i = 0; i < tags.length; ++i) { | |
| 2026 tag = tags[i]; | |
| 2027 proto = $.prototypeForTagFunction.call$1(tag); | |
| 2028 if (proto != null) { | |
| 2029 record = H.makeDefaultDispatchRecord(tag, map[tag], proto); | |
| 2030 if (record != null) | |
| 2031 Object.defineProperty(proto, init.dispatchPropertyName, {value: record
, enumerable: false, writable: true, configurable: true}); | |
| 2032 } | |
| 2033 } | |
| 2034 } | |
| 2035 for (i = 0; i < tags.length; ++i) { | |
| 2036 tag = tags[i]; | |
| 2037 if (/^[A-Za-z_]/.test(tag)) { | |
| 2038 interceptorClass = map[tag]; | |
| 2039 map["!" + tag] = interceptorClass; | |
| 2040 map["~" + tag] = interceptorClass; | |
| 2041 map["-" + tag] = interceptorClass; | |
| 2042 map["+" + tag] = interceptorClass; | |
| 2043 map["*" + tag] = interceptorClass; | |
| 2044 } | |
| 2045 } | |
| 2046 }, | |
| 2047 | |
| 2048 initHooks: function() { | |
| 2049 var hooks, transformers, i, transformer, getTag, getUnknownTag, prototypeForTa
g; | |
| 2050 hooks = C.JS_CONST_TtD(); | |
| 2051 hooks = H.applyHooksTransformer(C.JS_CONST_0, H.applyHooksTransformer(C.JS_CON
ST_Fs4, H.applyHooksTransformer(C.JS_CONST_Fs4, H.applyHooksTransformer(C.JS_CON
ST_rD3, H.applyHooksTransformer(C.JS_CONST_6qb, H.applyHooksTransformer(C.JS_CON
ST_Cbr(C.JS_CONST_86y), hooks)))))); | |
| 2052 if (typeof dartNativeDispatchHooksTransformer != "undefined") { | |
| 2053 transformers = dartNativeDispatchHooksTransformer; | |
| 2054 if (typeof transformers == "function") | |
| 2055 transformers = [transformers]; | |
| 2056 if (transformers.constructor == Array) | |
| 2057 for (i = 0; i < transformers.length; ++i) { | |
| 2058 transformer = transformers[i]; | |
| 2059 if (typeof transformer == "function") | |
| 2060 hooks = transformer(hooks) || hooks; | |
| 2061 } | |
| 2062 } | |
| 2063 getTag = hooks.getTag; | |
| 2064 getUnknownTag = hooks.getUnknownTag; | |
| 2065 prototypeForTag = hooks.prototypeForTag; | |
| 2066 $.getTagFunction = new H.initHooks_closure(getTag); | |
| 2067 $.alternateTagFunction = new H.initHooks_closure0(getUnknownTag); | |
| 2068 $.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag); | |
| 2069 }, | |
| 2070 | |
| 2071 applyHooksTransformer: function(transformer, hooks) { | |
| 2072 return transformer(hooks) || hooks; | |
| 2073 }, | |
| 2074 | |
| 2075 JSInvocationMirror: {"": "Object;__js_helper$_memberName,_internalName,_kind,_ar
guments,_namedArgumentNames,_namedIndices", | |
| 2076 get$memberName: function() { | |
| 2077 return this.__js_helper$_memberName; | |
| 2078 }, | |
| 2079 get$positionalArguments: function() { | |
| 2080 var t1, argumentCount, list, index; | |
| 2081 if (this._kind === 1) | |
| 2082 return C.List_empty; | |
| 2083 t1 = this._arguments; | |
| 2084 argumentCount = t1.length - this._namedArgumentNames.length; | |
| 2085 if (argumentCount === 0) | |
| 2086 return C.List_empty; | |
| 2087 list = []; | |
| 2088 for (index = 0; index < argumentCount; ++index) { | |
| 2089 if (index >= t1.length) | |
| 2090 throw H.ioore(t1, index); | |
| 2091 list.push(t1[index]); | |
| 2092 } | |
| 2093 return H.makeLiteralListConst(list); | |
| 2094 }, | |
| 2095 get$namedArguments: function() { | |
| 2096 var t1, namedArgumentCount, t2, namedArgumentsStartIndex, map, i, t3, t4; | |
| 2097 if (this._kind !== 0) { | |
| 2098 t1 = H.fillLiteralMap([], P.LinkedHashMap_LinkedHashMap(null, null, null,
null, null)); | |
| 2099 H.setRuntimeTypeInfo(t1, [P.Symbol, null]); | |
| 2100 return t1; | |
| 2101 } | |
| 2102 t1 = this._namedArgumentNames; | |
| 2103 namedArgumentCount = t1.length; | |
| 2104 t2 = this._arguments; | |
| 2105 namedArgumentsStartIndex = t2.length - namedArgumentCount; | |
| 2106 if (namedArgumentCount === 0) { | |
| 2107 t1 = H.fillLiteralMap([], P.LinkedHashMap_LinkedHashMap(null, null, null,
null, null)); | |
| 2108 H.setRuntimeTypeInfo(t1, [P.Symbol, null]); | |
| 2109 return t1; | |
| 2110 } | |
| 2111 map = P.LinkedHashMap_LinkedHashMap(null, null, null, P.Symbol, null); | |
| 2112 for (i = 0; i < namedArgumentCount; ++i) { | |
| 2113 if (i >= t1.length) | |
| 2114 throw H.ioore(t1, i); | |
| 2115 t3 = t1[i]; | |
| 2116 t4 = namedArgumentsStartIndex + i; | |
| 2117 if (t4 < 0 || t4 >= t2.length) | |
| 2118 throw H.ioore(t2, t4); | |
| 2119 map.$indexSet(map, new H.Symbol0(t3), t2[t4]); | |
| 2120 } | |
| 2121 return map; | |
| 2122 }, | |
| 2123 static: { | |
| 2124 "": "JSInvocationMirror_METHOD,JSInvocationMirror_GETTER,JSInvocationMirror_SETT
ER", | |
| 2125 } | |
| 2126 | |
| 2127 }, | |
| 2128 | |
| 2129 Primitives_applyFunction_closure: {"": "Closure;allNamedArguments_1", | |
| 2130 call$2: function(key, argument) { | |
| 2131 this.allNamedArguments_1[key] = argument; | |
| 2132 }, | |
| 2133 "+call:2:0": 0, | |
| 2134 $isFunction: true, | |
| 2135 $is_args2: true | |
| 2136 }, | |
| 2137 | |
| 2138 Primitives_applyFunction_closure0: {"": "Closure;buffer_2,arguments_3,allNamedAr
guments_4", | |
| 2139 call$1: function($name) { | |
| 2140 this.buffer_2.write$1("$" + H.S($name)); | |
| 2141 this.arguments_3.push(this.allNamedArguments_4[$name]); | |
| 2142 }, | |
| 2143 "+call:1:0": 0, | |
| 2144 $isFunction: true, | |
| 2145 $is_args1: true | |
| 2146 }, | |
| 2147 | |
| 2148 Primitives_applyFunction_closure1: {"": "Closure;box_0,buffer_5,arguments_6", | |
| 2149 call$2: function($name, argument) { | |
| 2150 var t1; | |
| 2151 this.buffer_5.write$1("$" + H.S($name)); | |
| 2152 this.arguments_6.push(argument); | |
| 2153 t1 = this.box_0; | |
| 2154 t1.argumentCount_0 = t1.argumentCount_0 + 1; | |
| 2155 }, | |
| 2156 "+call:2:0": 0, | |
| 2157 $isFunction: true, | |
| 2158 $is_args2: true | |
| 2159 }, | |
| 2160 | |
| 2161 TypeErrorDecoder: {"": "Object;_pattern,_arguments,_argumentsExpr,_expr,_method,
_receiver", | |
| 2162 matchTypeError$1: function(message) { | |
| 2163 var match, result, t1; | |
| 2164 match = new RegExp(this._pattern).exec(message); | |
| 2165 if (match == null) | |
| 2166 return; | |
| 2167 result = {}; | |
| 2168 t1 = this._arguments; | |
| 2169 if (t1 !== -1) | |
| 2170 result.arguments = match[t1 + 1]; | |
| 2171 t1 = this._argumentsExpr; | |
| 2172 if (t1 !== -1) | |
| 2173 result.argumentsExpr = match[t1 + 1]; | |
| 2174 t1 = this._expr; | |
| 2175 if (t1 !== -1) | |
| 2176 result.expr = match[t1 + 1]; | |
| 2177 t1 = this._method; | |
| 2178 if (t1 !== -1) | |
| 2179 result.method = match[t1 + 1]; | |
| 2180 t1 = this._receiver; | |
| 2181 if (t1 !== -1) | |
| 2182 result.receiver = match[t1 + 1]; | |
| 2183 return result; | |
| 2184 }, | |
| 2185 static: { | |
| 2186 "": "TypeErrorDecoder_noSuchMethodPattern,TypeErrorDecoder_notClosurePattern,Typ
eErrorDecoder_nullCallPattern,TypeErrorDecoder_nullLiteralCallPattern,TypeErrorD
ecoder_undefinedCallPattern,TypeErrorDecoder_undefinedLiteralCallPattern,TypeErr
orDecoder_nullPropertyPattern,TypeErrorDecoder_nullLiteralPropertyPattern,TypeEr
rorDecoder_undefinedPropertyPattern,TypeErrorDecoder_undefinedLiteralPropertyPat
tern", | |
| 2187 TypeErrorDecoder_extractPattern: function(message) { | |
| 2188 var match, $arguments, argumentsExpr, expr, method, receiver; | |
| 2189 message = message.replace(String({}), '$receiver$').replace(new RegExp("[[\\]{
}()*+?.\\\\^$|]", 'g'), '\\$&'); | |
| 2190 match = message.match(/\\\$[a-zA-Z]+\\\$/g); | |
| 2191 if (match == null) | |
| 2192 match = []; | |
| 2193 $arguments = match.indexOf("\\$arguments\\$"); | |
| 2194 argumentsExpr = match.indexOf("\\$argumentsExpr\\$"); | |
| 2195 expr = match.indexOf("\\$expr\\$"); | |
| 2196 method = match.indexOf("\\$method\\$"); | |
| 2197 receiver = match.indexOf("\\$receiver\\$"); | |
| 2198 return new H.TypeErrorDecoder(message.replace('\\$arguments\\$', '((?:x|[^x])*
)').replace('\\$argumentsExpr\\$', '((?:x|[^x])*)').replace('\\$expr\\$', '((?:x
|[^x])*)').replace('\\$method\\$', '((?:x|[^x])*)').replace('\\$receiver\\$', '(
(?:x|[^x])*)'), $arguments, argumentsExpr, expr, method, receiver); | |
| 2199 }, | |
| 2200 | |
| 2201 TypeErrorDecoder_provokeCallErrorOn: function(expression) { | |
| 2202 return function($expr$) { | |
| 2203 var $argumentsExpr$ = '$arguments$' | |
| 2204 try { | |
| 2205 $expr$.$method$($argumentsExpr$); | |
| 2206 } catch (e) { | |
| 2207 return e.message; | |
| 2208 } | |
| 2209 }(expression); | |
| 2210 }, | |
| 2211 | |
| 2212 TypeErrorDecoder_provokeCallErrorOnNull: function() { | |
| 2213 return function() { | |
| 2214 var $argumentsExpr$ = '$arguments$' | |
| 2215 try { | |
| 2216 null.$method$($argumentsExpr$); | |
| 2217 } catch (e) { | |
| 2218 return e.message; | |
| 2219 } | |
| 2220 }(); | |
| 2221 }, | |
| 2222 | |
| 2223 TypeErrorDecoder_provokeCallErrorOnUndefined: function() { | |
| 2224 return function() { | |
| 2225 var $argumentsExpr$ = '$arguments$' | |
| 2226 try { | |
| 2227 (void 0).$method$($argumentsExpr$); | |
| 2228 } catch (e) { | |
| 2229 return e.message; | |
| 2230 } | |
| 2231 }(); | |
| 2232 }, | |
| 2233 | |
| 2234 TypeErrorDecoder_provokePropertyErrorOn: function(expression) { | |
| 2235 return function($expr$) { | |
| 2236 try { | |
| 2237 $expr$.$method$; | |
| 2238 } catch (e) { | |
| 2239 return e.message; | |
| 2240 } | |
| 2241 }(expression); | |
| 2242 }, | |
| 2243 | |
| 2244 TypeErrorDecoder_provokePropertyErrorOnNull: function() { | |
| 2245 return function() { | |
| 2246 try { | |
| 2247 null.$method$; | |
| 2248 } catch (e) { | |
| 2249 return e.message; | |
| 2250 } | |
| 2251 }(); | |
| 2252 }, | |
| 2253 | |
| 2254 TypeErrorDecoder_provokePropertyErrorOnUndefined: function() { | |
| 2255 return function() { | |
| 2256 try { | |
| 2257 (void 0).$method$; | |
| 2258 } catch (e) { | |
| 2259 return e.message; | |
| 2260 } | |
| 2261 }(); | |
| 2262 }} | |
| 2263 | |
| 2264 }, | |
| 2265 | |
| 2266 NullError: {"": "Error;_message,_method", | |
| 2267 toString$0: function(_) { | |
| 2268 var t1 = this._method; | |
| 2269 if (t1 == null) | |
| 2270 return "NullError: " + H.S(this._message); | |
| 2271 return "NullError: Cannot call \"" + H.S(t1) + "\" on null"; | |
| 2272 }, | |
| 2273 $isError: true | |
| 2274 }, | |
| 2275 | |
| 2276 JsNoSuchMethodError: {"": "Error;_message,_method,_receiver", | |
| 2277 toString$0: function(_) { | |
| 2278 var t1, t2; | |
| 2279 t1 = this._method; | |
| 2280 if (t1 == null) | |
| 2281 return "NoSuchMethodError: " + H.S(this._message); | |
| 2282 t2 = this._receiver; | |
| 2283 if (t2 == null) | |
| 2284 return "NoSuchMethodError: Cannot call \"" + t1 + "\" (" + H.S(this._messa
ge) + ")"; | |
| 2285 return "NoSuchMethodError: Cannot call \"" + t1 + "\" on \"" + t2 + "\" (" +
H.S(this._message) + ")"; | |
| 2286 }, | |
| 2287 $isError: true, | |
| 2288 static: { | |
| 2289 JsNoSuchMethodError$: function(_message, match) { | |
| 2290 var t1, t2; | |
| 2291 t1 = match == null; | |
| 2292 t2 = t1 ? null : match.method; | |
| 2293 t1 = t1 ? null : match.receiver; | |
| 2294 return new H.JsNoSuchMethodError(_message, t2, t1); | |
| 2295 }} | |
| 2296 | |
| 2297 }, | |
| 2298 | |
| 2299 UnknownJsTypeError: {"": "Error;_message", | |
| 2300 toString$0: function(_) { | |
| 2301 var t1 = this._message; | |
| 2302 return C.JSString_methods.get$isEmpty(t1) ? "Error" : "Error: " + t1; | |
| 2303 } | |
| 2304 }, | |
| 2305 | |
| 2306 unwrapException_saveStackTrace: {"": "Closure;ex_0", | |
| 2307 call$1: function(error) { | |
| 2308 var t1 = J.getInterceptor(error); | |
| 2309 if (typeof error === "object" && error !== null && !!t1.$isError) | |
| 2310 if (error.$thrownJsError == null) | |
| 2311 error.$thrownJsError = this.ex_0; | |
| 2312 return error; | |
| 2313 }, | |
| 2314 "+call:1:0": 0, | |
| 2315 $isFunction: true, | |
| 2316 $is_args1: true | |
| 2317 }, | |
| 2318 | |
| 2319 _StackTrace: {"": "Object;_exception,_trace", | |
| 2320 toString$0: function(_) { | |
| 2321 var t1, trace; | |
| 2322 t1 = this._trace; | |
| 2323 if (t1 != null) | |
| 2324 return t1; | |
| 2325 t1 = this._exception; | |
| 2326 trace = typeof t1 === "object" ? t1.stack : null; | |
| 2327 t1 = trace == null ? "" : trace; | |
| 2328 this._trace = t1; | |
| 2329 return t1; | |
| 2330 } | |
| 2331 }, | |
| 2332 | |
| 2333 invokeClosure_closure: {"": "Closure;closure_0", | |
| 2334 call$0: function() { | |
| 2335 return this.closure_0.call$0(); | |
| 2336 }, | |
| 2337 "+call:0:0": 0, | |
| 2338 $isFunction: true | |
| 2339 }, | |
| 2340 | |
| 2341 invokeClosure_closure0: {"": "Closure;closure_1,arg1_2", | |
| 2342 call$0: function() { | |
| 2343 return this.closure_1.call$1(this.arg1_2); | |
| 2344 }, | |
| 2345 "+call:0:0": 0, | |
| 2346 $isFunction: true | |
| 2347 }, | |
| 2348 | |
| 2349 invokeClosure_closure1: {"": "Closure;closure_3,arg1_4,arg2_5", | |
| 2350 call$0: function() { | |
| 2351 return this.closure_3.call$2(this.arg1_4, this.arg2_5); | |
| 2352 }, | |
| 2353 "+call:0:0": 0, | |
| 2354 $isFunction: true | |
| 2355 }, | |
| 2356 | |
| 2357 invokeClosure_closure2: {"": "Closure;closure_6,arg1_7,arg2_8,arg3_9", | |
| 2358 call$0: function() { | |
| 2359 return this.closure_6.call$3(this.arg1_7, this.arg2_8, this.arg3_9); | |
| 2360 }, | |
| 2361 "+call:0:0": 0, | |
| 2362 $isFunction: true | |
| 2363 }, | |
| 2364 | |
| 2365 invokeClosure_closure3: {"": "Closure;closure_10,arg1_11,arg2_12,arg3_13,arg4_14
", | |
| 2366 call$0: function() { | |
| 2367 return this.closure_10.call$4(this.arg1_11, this.arg2_12, this.arg3_13, this
.arg4_14); | |
| 2368 }, | |
| 2369 "+call:0:0": 0, | |
| 2370 $isFunction: true | |
| 2371 }, | |
| 2372 | |
| 2373 Closure: {"": "Object;", | |
| 2374 toString$0: function(_) { | |
| 2375 return "Closure"; | |
| 2376 }, | |
| 2377 $isFunction: true | |
| 2378 }, | |
| 2379 | |
| 2380 BoundClosure: {"": "Closure;_self,__js_helper$_target,_receiver,__js_helper$_nam
e", | |
| 2381 $eq: function(_, other) { | |
| 2382 var t1; | |
| 2383 if (other == null) | |
| 2384 return false; | |
| 2385 if (this === other) | |
| 2386 return true; | |
| 2387 t1 = J.getInterceptor(other); | |
| 2388 if (typeof other !== "object" || other === null || !t1.$isBoundClosure) | |
| 2389 return false; | |
| 2390 return this._self === other._self && this.__js_helper$_target === other.__js
_helper$_target && this._receiver === other._receiver; | |
| 2391 }, | |
| 2392 get$hashCode: function(_) { | |
| 2393 var t1, receiverHashCode; | |
| 2394 t1 = this._receiver; | |
| 2395 if (t1 == null) | |
| 2396 receiverHashCode = H.Primitives_objectHashCode(this._self); | |
| 2397 else | |
| 2398 receiverHashCode = typeof t1 !== "object" ? J.get$hashCode$(t1) : H.Primit
ives_objectHashCode(t1); | |
| 2399 return (receiverHashCode ^ H.Primitives_objectHashCode(this.__js_helper$_tar
get)) >>> 0; | |
| 2400 }, | |
| 2401 $isBoundClosure: true | |
| 2402 }, | |
| 2403 | |
| 2404 TypeImpl: {"": "Object;_typeName,_unmangledName", | |
| 2405 toString$0: function(_) { | |
| 2406 var t1, unmangledName, unmangledName0; | |
| 2407 t1 = this._unmangledName; | |
| 2408 if (t1 != null) | |
| 2409 return t1; | |
| 2410 unmangledName = this._typeName; | |
| 2411 unmangledName0 = H.unmangleGlobalNameIfPreservedAnyways(unmangledName); | |
| 2412 unmangledName = unmangledName0 == null ? unmangledName : unmangledName0; | |
| 2413 this._unmangledName = unmangledName; | |
| 2414 return unmangledName; | |
| 2415 }, | |
| 2416 get$hashCode: function(_) { | |
| 2417 return J.get$hashCode$(this._typeName); | |
| 2418 }, | |
| 2419 $eq: function(_, other) { | |
| 2420 var t1; | |
| 2421 if (other == null) | |
| 2422 return false; | |
| 2423 t1 = J.getInterceptor(other); | |
| 2424 return typeof other === "object" && other !== null && !!t1.$isTypeImpl && J.
$eq(this._typeName, other._typeName); | |
| 2425 }, | |
| 2426 $isTypeImpl: true | |
| 2427 }, | |
| 2428 | |
| 2429 initHooks_closure: {"": "Closure;getTag_0", | |
| 2430 call$1: function(o) { | |
| 2431 return this.getTag_0(o); | |
| 2432 }, | |
| 2433 "+call:1:0": 0, | |
| 2434 $isFunction: true, | |
| 2435 $is_args1: true | |
| 2436 }, | |
| 2437 | |
| 2438 initHooks_closure0: {"": "Closure;getUnknownTag_1", | |
| 2439 call$2: function(o, tag) { | |
| 2440 return this.getUnknownTag_1(o, tag); | |
| 2441 }, | |
| 2442 "+call:2:0": 0, | |
| 2443 $isFunction: true, | |
| 2444 $is_args2: true | |
| 2445 }, | |
| 2446 | |
| 2447 initHooks_closure1: {"": "Closure;prototypeForTag_2", | |
| 2448 call$1: function(tag) { | |
| 2449 return this.prototypeForTag_2(tag); | |
| 2450 }, | |
| 2451 "+call:1:0": 0, | |
| 2452 $isFunction: true, | |
| 2453 $is_args1: true | |
| 2454 }}], | |
| 2455 ["dart._collection.dev", "dart:_collection-dev", , H, { | |
| 2456 Arrays_copy: function(src, srcStart, dst, dstStart, count) { | |
| 2457 var i, j, t1; | |
| 2458 if (srcStart < dstStart) | |
| 2459 for (i = srcStart + count - 1, j = dstStart + count - 1; i >= srcStart; --i,
--j) { | |
| 2460 if (i < 0 || i >= src.length) | |
| 2461 throw H.ioore(src, i); | |
| 2462 C.JSArray_methods.$indexSet(dst, j, src[i]); | |
| 2463 } | |
| 2464 else | |
| 2465 for (t1 = srcStart + count, j = dstStart, i = srcStart; i < t1; ++i, ++j) { | |
| 2466 if (i < 0 || i >= src.length) | |
| 2467 throw H.ioore(src, i); | |
| 2468 C.JSArray_methods.$indexSet(dst, j, src[i]); | |
| 2469 } | |
| 2470 }, | |
| 2471 | |
| 2472 IterableMixinWorkaround_forEach: function(iterable, f) { | |
| 2473 var t1; | |
| 2474 for (t1 = new H.ListIterator(iterable, iterable.length, 0, null); t1.moveNext$
0();) | |
| 2475 f.call$1(t1._current); | |
| 2476 }, | |
| 2477 | |
| 2478 IterableMixinWorkaround_toStringIterable: function(iterable, leftDelimiter, righ
tDelimiter) { | |
| 2479 var result, i, t1; | |
| 2480 for (i = 0; i < $.get$IterableMixinWorkaround__toStringList().length; ++i) { | |
| 2481 t1 = $.get$IterableMixinWorkaround__toStringList(); | |
| 2482 if (i >= t1.length) | |
| 2483 throw H.ioore(t1, i); | |
| 2484 if (t1[i] === iterable) | |
| 2485 return H.S(leftDelimiter) + "..." + H.S(rightDelimiter); | |
| 2486 } | |
| 2487 result = P.StringBuffer$(""); | |
| 2488 try { | |
| 2489 $.get$IterableMixinWorkaround__toStringList().push(iterable); | |
| 2490 result.write$1(leftDelimiter); | |
| 2491 result.writeAll$2(iterable, ", "); | |
| 2492 result.write$1(rightDelimiter); | |
| 2493 } finally { | |
| 2494 t1 = $.get$IterableMixinWorkaround__toStringList(); | |
| 2495 if (0 >= t1.length) | |
| 2496 throw H.ioore(t1, 0); | |
| 2497 t1.pop(); | |
| 2498 } | |
| 2499 return result.get$_contents(); | |
| 2500 }, | |
| 2501 | |
| 2502 IterableMixinWorkaround__rangeCheck: function(list, start, end) { | |
| 2503 if (start < 0 || start > list.length) | |
| 2504 throw H.wrapException(P.RangeError$range(start, 0, list.length)); | |
| 2505 if (end < start || end > list.length) | |
| 2506 throw H.wrapException(P.RangeError$range(end, start, list.length)); | |
| 2507 }, | |
| 2508 | |
| 2509 IterableMixinWorkaround_setRangeList: function(list, start, end, from, skipCount
) { | |
| 2510 var $length; | |
| 2511 H.IterableMixinWorkaround__rangeCheck(list, start, end); | |
| 2512 $length = end - start; | |
| 2513 if ($length === 0) | |
| 2514 return; | |
| 2515 if (skipCount < 0) | |
| 2516 throw H.wrapException(new P.ArgumentError(skipCount)); | |
| 2517 if (skipCount + $length > from.length) | |
| 2518 throw H.wrapException(P.StateError$("Not enough elements")); | |
| 2519 H.Arrays_copy(from, skipCount, list, start, $length); | |
| 2520 }, | |
| 2521 | |
| 2522 printToConsole: function(line) { | |
| 2523 if (typeof dartPrint == "function") { | |
| 2524 dartPrint(line); | |
| 2525 return; | |
| 2526 } | |
| 2527 if (typeof console == "object" && typeof console.log == "function") { | |
| 2528 console.log(line); | |
| 2529 return; | |
| 2530 } | |
| 2531 if (typeof window == "object") | |
| 2532 return; | |
| 2533 if (typeof print == "function") { | |
| 2534 print(line); | |
| 2535 return; | |
| 2536 } | |
| 2537 throw "Unable to print message: " + String(line); | |
| 2538 }, | |
| 2539 | |
| 2540 ListIterable: {"": "IterableBase;", | |
| 2541 get$iterator: function(_) { | |
| 2542 return new H.ListIterator(this, this.get$length(this), 0, null); | |
| 2543 }, | |
| 2544 forEach$1: function(_, action) { | |
| 2545 var $length, i; | |
| 2546 $length = this.get$length(this); | |
| 2547 if (typeof $length !== "number") | |
| 2548 throw H.iae($length); | |
| 2549 i = 0; | |
| 2550 for (; i < $length; ++i) { | |
| 2551 action.call$1(this.elementAt$1(this, i)); | |
| 2552 if ($length !== this.get$length(this)) | |
| 2553 throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| 2554 } | |
| 2555 }, | |
| 2556 map$1: function(_, f) { | |
| 2557 var t1 = new H.MappedListIterable(this, f); | |
| 2558 H.setRuntimeTypeInfo(t1, [null, null]); | |
| 2559 return t1; | |
| 2560 }, | |
| 2561 $asIterableBase: null, | |
| 2562 $asIterable: null, | |
| 2563 $isEfficientLength: true | |
| 2564 }, | |
| 2565 | |
| 2566 ListIterator: {"": "Object;_iterable,_length,_index,_current", | |
| 2567 get$current: function() { | |
| 2568 return this._current; | |
| 2569 }, | |
| 2570 moveNext$0: function() { | |
| 2571 var t1, t2, $length, t3; | |
| 2572 t1 = this._iterable; | |
| 2573 t2 = J.getInterceptor$asx(t1); | |
| 2574 $length = t2.get$length(t1); | |
| 2575 if (!J.$eq(this._length, $length)) | |
| 2576 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 2577 t3 = this._index; | |
| 2578 if (typeof $length !== "number") | |
| 2579 throw H.iae($length); | |
| 2580 if (t3 >= $length) { | |
| 2581 this._current = null; | |
| 2582 return false; | |
| 2583 } | |
| 2584 this._current = t2.elementAt$1(t1, t3); | |
| 2585 this._index = this._index + 1; | |
| 2586 return true; | |
| 2587 } | |
| 2588 }, | |
| 2589 | |
| 2590 MappedIterable: {"": "IterableBase;_iterable,_f", | |
| 2591 get$iterator: function(_) { | |
| 2592 var t1 = this._iterable; | |
| 2593 t1 = t1.get$iterator(t1); | |
| 2594 t1 = new H.MappedIterator(null, t1, this._f); | |
| 2595 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "MappedIterable", 0
), H.getRuntimeTypeArgument(this, "MappedIterable", 1)]); | |
| 2596 return t1; | |
| 2597 }, | |
| 2598 get$length: function(_) { | |
| 2599 var t1 = this._iterable; | |
| 2600 return t1.get$length(t1); | |
| 2601 }, | |
| 2602 $asIterableBase: function($S, $T) { | |
| 2603 return [$T]; | |
| 2604 }, | |
| 2605 $asIterable: function($S, $T) { | |
| 2606 return [$T]; | |
| 2607 }, | |
| 2608 static: { | |
| 2609 MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { | |
| 2610 var t1; | |
| 2611 if (!!iterable.$isEfficientLength) { | |
| 2612 t1 = new H.EfficientLengthMappedIterable(iterable, $function); | |
| 2613 H.setRuntimeTypeInfo(t1, [$S, $T]); | |
| 2614 return t1; | |
| 2615 } | |
| 2616 t1 = new H.MappedIterable(iterable, $function); | |
| 2617 H.setRuntimeTypeInfo(t1, [$S, $T]); | |
| 2618 return t1; | |
| 2619 }} | |
| 2620 | |
| 2621 }, | |
| 2622 | |
| 2623 EfficientLengthMappedIterable: {"": "MappedIterable;_iterable,_f", $asMappedIter
able: null, | |
| 2624 $asIterable: function($S, $T) { | |
| 2625 return [$T]; | |
| 2626 }, | |
| 2627 $isEfficientLength: true | |
| 2628 }, | |
| 2629 | |
| 2630 MappedIterator: {"": "Iterator;_current,_iterator,_f", | |
| 2631 _f$1: function(arg0) { | |
| 2632 return this._f.call$1(arg0); | |
| 2633 }, | |
| 2634 moveNext$0: function() { | |
| 2635 var t1 = this._iterator; | |
| 2636 if (t1.moveNext$0()) { | |
| 2637 this._current = this._f$1(t1.get$current()); | |
| 2638 return true; | |
| 2639 } | |
| 2640 this._current = null; | |
| 2641 return false; | |
| 2642 }, | |
| 2643 get$current: function() { | |
| 2644 return this._current; | |
| 2645 }, | |
| 2646 $asIterator: function($S, $T) { | |
| 2647 return [$T]; | |
| 2648 } | |
| 2649 }, | |
| 2650 | |
| 2651 MappedListIterable: {"": "ListIterable;_dev$_source,_f", | |
| 2652 _f$1: function(arg0) { | |
| 2653 return this._f.call$1(arg0); | |
| 2654 }, | |
| 2655 get$length: function(_) { | |
| 2656 return J.get$length$asx(this._dev$_source); | |
| 2657 }, | |
| 2658 elementAt$1: function(_, index) { | |
| 2659 return this._f$1(J.elementAt$1$ax(this._dev$_source, index)); | |
| 2660 }, | |
| 2661 $asListIterable: function($S, $T) { | |
| 2662 return [$T]; | |
| 2663 }, | |
| 2664 $asIterable: function($S, $T) { | |
| 2665 return [$T]; | |
| 2666 }, | |
| 2667 $isEfficientLength: true | |
| 2668 }, | |
| 2669 | |
| 2670 FixedLengthListMixin: {"": "Object;"}, | |
| 2671 | |
| 2672 Symbol0: {"": "Object;_name<", | |
| 2673 $eq: function(_, other) { | |
| 2674 var t1; | |
| 2675 if (other == null) | |
| 2676 return false; | |
| 2677 t1 = J.getInterceptor(other); | |
| 2678 return typeof other === "object" && other !== null && !!t1.$isSymbol0 && J.$
eq(this._name, other._name); | |
| 2679 }, | |
| 2680 get$hashCode: function(_) { | |
| 2681 return 536870911 & 664597 * J.get$hashCode$(this._name); | |
| 2682 }, | |
| 2683 toString$0: function(_) { | |
| 2684 return "Symbol(\"" + H.S(this._name) + "\")"; | |
| 2685 }, | |
| 2686 $isSymbol0: true, | |
| 2687 static: { | |
| 2688 "": "Symbol_validationPattern", | |
| 2689 } | |
| 2690 | |
| 2691 }}], | |
| 2692 ["dart._js_names", "dart:_js_names", , H, { | |
| 2693 unmangleGlobalNameIfPreservedAnyways: function($name) { | |
| 2694 return init.mangledGlobalNames[$name]; | |
| 2695 }}], | |
| 2696 ["dart.async", "dart:async", , P, { | |
| 2697 _invokeErrorHandler: function(errorHandler, error, stackTrace) { | |
| 2698 var t1 = J.getInterceptor(errorHandler); | |
| 2699 if (!!t1.$is_args2) | |
| 2700 return errorHandler.call$2(error, stackTrace); | |
| 2701 else | |
| 2702 return errorHandler.call$1(error); | |
| 2703 }, | |
| 2704 | |
| 2705 _registerErrorHandler: function(errorHandler, zone) { | |
| 2706 var t1 = J.getInterceptor(errorHandler); | |
| 2707 zone.toString; | |
| 2708 if (!!t1.$is_args2) | |
| 2709 return errorHandler; | |
| 2710 else | |
| 2711 return errorHandler; | |
| 2712 }, | |
| 2713 | |
| 2714 Future_wait: function(futures) { | |
| 2715 var t1, t2, t3, future, pos, t4, t5, result, completer; | |
| 2716 t1 = {}; | |
| 2717 t1.completer_0 = null; | |
| 2718 t1.values_1 = null; | |
| 2719 t2 = new P.Future_wait_handleError(t1); | |
| 2720 t1.remaining_2 = 0; | |
| 2721 for (t3 = new H.ListIterator(futures, futures.length, 0, null); t3.moveNext$0(
);) { | |
| 2722 future = t3._current; | |
| 2723 pos = t1.remaining_2; | |
| 2724 t1.remaining_2 = pos + 1; | |
| 2725 t4 = future.catchError$1(t2); | |
| 2726 t5 = $.Zone__current; | |
| 2727 t5.toString; | |
| 2728 result = new P._Future(0, t5, null, null, new P.Future_wait_closure(t1, pos)
, null, P._registerErrorHandler(null, t5), null); | |
| 2729 result.$builtinTypeInfo = [null]; | |
| 2730 t4._addListener$1(result); | |
| 2731 } | |
| 2732 t2 = t1.remaining_2; | |
| 2733 if (t2 === 0) | |
| 2734 return P._Future$immediate(C.List_empty, null); | |
| 2735 t1.values_1 = P.List_List(t2, null); | |
| 2736 t2 = J.JSArray; | |
| 2737 completer = new P._AsyncCompleter(P._Future$(t2)); | |
| 2738 H.setRuntimeTypeInfo(completer, [t2]); | |
| 2739 t1.completer_0 = completer; | |
| 2740 return t1.completer_0.future; | |
| 2741 }, | |
| 2742 | |
| 2743 _asyncRunCallback: function() { | |
| 2744 var callback, t1, exception, milliseconds; | |
| 2745 for (; t1 = $.get$_asyncCallbacks(), t1._head !== t1._tail;) { | |
| 2746 callback = $.get$_asyncCallbacks().removeFirst$0(); | |
| 2747 try { | |
| 2748 callback.call$0(); | |
| 2749 } catch (exception) { | |
| 2750 H.unwrapException(exception); | |
| 2751 milliseconds = C.JSNumber_methods.$tdiv(C.Duration_0._duration, 1000); | |
| 2752 H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, P._asyncRunCallback$clos
ure); | |
| 2753 throw exception; | |
| 2754 } | |
| 2755 | |
| 2756 } | |
| 2757 $._callbacksAreEnqueued = false; | |
| 2758 }, | |
| 2759 | |
| 2760 _scheduleAsyncCallback: function(callback) { | |
| 2761 $.get$_asyncCallbacks()._add$1(callback); | |
| 2762 if (!$._callbacksAreEnqueued) { | |
| 2763 P._createTimer(C.Duration_0, P._asyncRunCallback$closure); | |
| 2764 $._callbacksAreEnqueued = true; | |
| 2765 } | |
| 2766 }, | |
| 2767 | |
| 2768 scheduleMicrotask: function(callback) { | |
| 2769 var t1 = $.Zone__current; | |
| 2770 if (t1 === C.C__RootZone) { | |
| 2771 t1.toString; | |
| 2772 P._scheduleAsyncCallback(callback); | |
| 2773 return; | |
| 2774 } | |
| 2775 P._scheduleAsyncCallback(t1.bindCallback$2$runGuarded(callback, true)); | |
| 2776 }, | |
| 2777 | |
| 2778 StreamController_StreamController: function(onCancel, onListen, onPause, onResum
e, sync, $T) { | |
| 2779 var t1; | |
| 2780 if (sync) { | |
| 2781 t1 = new P._SyncStreamController(onListen, onPause, onResume, onCancel, null
, 0, null); | |
| 2782 H.setRuntimeTypeInfo(t1, [$T]); | |
| 2783 } else { | |
| 2784 t1 = new P._AsyncStreamController(onListen, onPause, onResume, onCancel, nul
l, 0, null); | |
| 2785 H.setRuntimeTypeInfo(t1, [$T]); | |
| 2786 } | |
| 2787 return t1; | |
| 2788 }, | |
| 2789 | |
| 2790 _runGuarded: function(notificationHandler) { | |
| 2791 var result, e, s, t1, t2, exception; | |
| 2792 if (notificationHandler == null) | |
| 2793 return; | |
| 2794 try { | |
| 2795 result = notificationHandler.call$0(); | |
| 2796 t1 = result; | |
| 2797 t2 = J.getInterceptor(t1); | |
| 2798 if (typeof t1 === "object" && t1 !== null && !!t2.$isFuture) | |
| 2799 return result; | |
| 2800 return; | |
| 2801 } catch (exception) { | |
| 2802 t1 = H.unwrapException(exception); | |
| 2803 e = t1; | |
| 2804 s = new H._StackTrace(exception, null); | |
| 2805 t1 = $.Zone__current; | |
| 2806 t1.toString; | |
| 2807 P._rootHandleUncaughtError(t1, null, t1, e, s); | |
| 2808 } | |
| 2809 | |
| 2810 }, | |
| 2811 | |
| 2812 _nullDataHandler: function(value) { | |
| 2813 }, | |
| 2814 | |
| 2815 _nullErrorHandler: function(error, stackTrace) { | |
| 2816 var t1 = $.Zone__current; | |
| 2817 t1.toString; | |
| 2818 P._rootHandleUncaughtError(t1, null, t1, error, stackTrace); | |
| 2819 }, | |
| 2820 | |
| 2821 _nullDoneHandler: function() { | |
| 2822 }, | |
| 2823 | |
| 2824 _runUserCode: function(userCode, onSuccess, onError) { | |
| 2825 var e, s, exception, t1; | |
| 2826 try { | |
| 2827 onSuccess.call$1(userCode.call$0()); | |
| 2828 } catch (exception) { | |
| 2829 t1 = H.unwrapException(exception); | |
| 2830 e = t1; | |
| 2831 s = new H._StackTrace(exception, null); | |
| 2832 onError.call$2(e, s); | |
| 2833 } | |
| 2834 | |
| 2835 }, | |
| 2836 | |
| 2837 _cancelAndError: function(subscription, future, error, stackTrace) { | |
| 2838 var cancelFuture, t1; | |
| 2839 cancelFuture = subscription.cancel$0(); | |
| 2840 t1 = J.getInterceptor(cancelFuture); | |
| 2841 if (typeof cancelFuture === "object" && cancelFuture !== null && !!t1.$isFutur
e) | |
| 2842 cancelFuture.whenComplete$1(new P._cancelAndError_closure(future, error, sta
ckTrace)); | |
| 2843 else | |
| 2844 future._completeError$2(error, stackTrace); | |
| 2845 }, | |
| 2846 | |
| 2847 _cancelAndErrorClosure: function(subscription, future) { | |
| 2848 return new P._cancelAndErrorClosure_closure(subscription, future); | |
| 2849 }, | |
| 2850 | |
| 2851 Timer_Timer: function(duration, callback) { | |
| 2852 var t1 = $.Zone__current; | |
| 2853 if (t1 === C.C__RootZone) { | |
| 2854 t1.toString; | |
| 2855 return P._createTimer(duration, callback); | |
| 2856 } | |
| 2857 return P._createTimer(duration, t1.bindCallback$2$runGuarded(callback, true)); | |
| 2858 }, | |
| 2859 | |
| 2860 _createTimer: function(duration, callback) { | |
| 2861 var milliseconds = C.JSNumber_methods.$tdiv(duration._duration, 1000); | |
| 2862 return H.TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback); | |
| 2863 }, | |
| 2864 | |
| 2865 _rootHandleUncaughtError: function($self, $parent, zone, error, stackTrace) { | |
| 2866 P._rootRun($self, null, $self, new P._rootHandleUncaughtError_closure(error, s
tackTrace)); | |
| 2867 }, | |
| 2868 | |
| 2869 _rootRun: function($self, $parent, zone, f) { | |
| 2870 var old, t1, t2; | |
| 2871 t1 = $.Zone__current; | |
| 2872 t2 = zone; | |
| 2873 if (t1 == null ? t2 == null : t1 === t2) | |
| 2874 return f.call$0(); | |
| 2875 old = t1; | |
| 2876 try { | |
| 2877 $.Zone__current = zone; | |
| 2878 t1 = f.call$0(); | |
| 2879 return t1; | |
| 2880 } finally { | |
| 2881 $.Zone__current = old; | |
| 2882 } | |
| 2883 }, | |
| 2884 | |
| 2885 _rootRunUnary: function($self, $parent, zone, f, arg) { | |
| 2886 var old, t1, t2; | |
| 2887 t1 = $.Zone__current; | |
| 2888 t2 = zone; | |
| 2889 if (t1 == null ? t2 == null : t1 === t2) | |
| 2890 return f.call$1(arg); | |
| 2891 old = t1; | |
| 2892 try { | |
| 2893 $.Zone__current = zone; | |
| 2894 t1 = f.call$1(arg); | |
| 2895 return t1; | |
| 2896 } finally { | |
| 2897 $.Zone__current = old; | |
| 2898 } | |
| 2899 }, | |
| 2900 | |
| 2901 _rootRunBinary: function($self, $parent, zone, f, arg1, arg2) { | |
| 2902 var old, t1, t2; | |
| 2903 t1 = $.Zone__current; | |
| 2904 t2 = zone; | |
| 2905 if (t1 == null ? t2 == null : t1 === t2) | |
| 2906 return f.call$2(arg1, arg2); | |
| 2907 old = t1; | |
| 2908 try { | |
| 2909 $.Zone__current = zone; | |
| 2910 t1 = f.call$2(arg1, arg2); | |
| 2911 return t1; | |
| 2912 } finally { | |
| 2913 $.Zone__current = old; | |
| 2914 } | |
| 2915 }, | |
| 2916 | |
| 2917 _AsyncError: {"": "Object;error>,stackTrace<", $isError: true}, | |
| 2918 | |
| 2919 Future: {"": "Object;", $isFuture: true}, | |
| 2920 | |
| 2921 Future_wait_handleError: {"": "Closure;box_0", | |
| 2922 call$1: function(error) { | |
| 2923 var t1 = this.box_0; | |
| 2924 if (t1.values_1 != null) { | |
| 2925 t1.values_1 = null; | |
| 2926 t1.completer_0.completeError$1(error); | |
| 2927 } | |
| 2928 return; | |
| 2929 }, | |
| 2930 "+call:1:0": 0, | |
| 2931 $isFunction: true, | |
| 2932 $is_args1: true | |
| 2933 }, | |
| 2934 | |
| 2935 Future_wait_closure: {"": "Closure;box_0,pos_1", | |
| 2936 call$1: function(value) { | |
| 2937 var t1, t2, t3; | |
| 2938 t1 = this.box_0; | |
| 2939 t2 = t1.values_1; | |
| 2940 if (t2 == null) | |
| 2941 return; | |
| 2942 t3 = this.pos_1; | |
| 2943 if (t3 < 0 || t3 >= t2.length) | |
| 2944 throw H.ioore(t2, t3); | |
| 2945 t2[t3] = value; | |
| 2946 t1.remaining_2 = t1.remaining_2 - 1; | |
| 2947 if (t1.remaining_2 === 0) { | |
| 2948 t2 = t1.completer_0; | |
| 2949 t1 = t1.values_1; | |
| 2950 t2 = t2.future; | |
| 2951 if (t2._state !== 0) | |
| 2952 H.throwExpression(P.StateError$("Future already completed")); | |
| 2953 t2._asyncComplete$1(t1); | |
| 2954 } | |
| 2955 }, | |
| 2956 "+call:1:0": 0, | |
| 2957 $isFunction: true, | |
| 2958 $is_args1: true | |
| 2959 }, | |
| 2960 | |
| 2961 _Completer: {"": "Object;"}, | |
| 2962 | |
| 2963 _AsyncCompleter: {"": "_Completer;future", | |
| 2964 complete$1: function(_, value) { | |
| 2965 var t1 = this.future; | |
| 2966 if (t1._state !== 0) | |
| 2967 throw H.wrapException(P.StateError$("Future already completed")); | |
| 2968 t1._asyncComplete$1(value); | |
| 2969 }, | |
| 2970 get$complete: function(_receiver) { | |
| 2971 return new P.BoundClosure$i1(this, P._AsyncCompleter.prototype.complete$1, _
receiver, "complete$1"); | |
| 2972 }, | |
| 2973 completeError$2: function(error, stackTrace) { | |
| 2974 var t1; | |
| 2975 if (error == null) | |
| 2976 throw H.wrapException(new P.ArgumentError("Error must not be null")); | |
| 2977 t1 = this.future; | |
| 2978 if (t1._state !== 0) | |
| 2979 throw H.wrapException(P.StateError$("Future already completed")); | |
| 2980 t1._asyncCompleteError$2(error, stackTrace); | |
| 2981 }, | |
| 2982 completeError$1: function(error) { | |
| 2983 return this.completeError$2(error, null); | |
| 2984 }, | |
| 2985 $as_Completer: null | |
| 2986 }, | |
| 2987 | |
| 2988 _Future: {"": "Object;_state,_zone<,_resultOrListeners,_nextListener@,_onValueCa
llback,_errorTestCallback,_onErrorCallback,_whenCompleteActionCallback", | |
| 2989 get$_isComplete: function() { | |
| 2990 return this._state >= 4; | |
| 2991 }, | |
| 2992 get$_hasError: function() { | |
| 2993 return this._state === 8; | |
| 2994 }, | |
| 2995 set$_isChained: function(value) { | |
| 2996 if (value) | |
| 2997 this._state = 2; | |
| 2998 else | |
| 2999 this._state = 0; | |
| 3000 }, | |
| 3001 get$_onValue: function() { | |
| 3002 return this._state === 2 ? null : this._onValueCallback; | |
| 3003 }, | |
| 3004 _onValue$1: function(arg0) { | |
| 3005 return this.get$_onValue().call$1(arg0); | |
| 3006 }, | |
| 3007 get$_errorTest: function() { | |
| 3008 return this._state === 2 ? null : this._errorTestCallback; | |
| 3009 }, | |
| 3010 get$_onError: function() { | |
| 3011 return this._state === 2 ? null : this._onErrorCallback; | |
| 3012 }, | |
| 3013 get$_whenCompleteAction: function() { | |
| 3014 return this._state === 2 ? null : this._whenCompleteActionCallback; | |
| 3015 }, | |
| 3016 _whenCompleteAction$0: function() { | |
| 3017 return this.get$_whenCompleteAction().call$0(); | |
| 3018 }, | |
| 3019 then$2$onError: function(f, onError) { | |
| 3020 var result = P._Future$_then(f, onError, null); | |
| 3021 this._addListener$1(result); | |
| 3022 return result; | |
| 3023 }, | |
| 3024 then$1: function(f) { | |
| 3025 return this.then$2$onError(f, null); | |
| 3026 }, | |
| 3027 catchError$2$test: function(onError, test) { | |
| 3028 var result = P._Future$_catchError(onError, test, null); | |
| 3029 this._addListener$1(result); | |
| 3030 return result; | |
| 3031 }, | |
| 3032 catchError$1: function(onError) { | |
| 3033 return this.catchError$2$test(onError, null); | |
| 3034 }, | |
| 3035 whenComplete$1: function(action) { | |
| 3036 var result = P._Future$_whenComplete(action, H.getRuntimeTypeArgument(this,
"_Future", 0)); | |
| 3037 this._addListener$1(result); | |
| 3038 return result; | |
| 3039 }, | |
| 3040 get$_value: function() { | |
| 3041 return this._resultOrListeners; | |
| 3042 }, | |
| 3043 get$_error: function() { | |
| 3044 return this._resultOrListeners; | |
| 3045 }, | |
| 3046 _setValue$1: function(value) { | |
| 3047 this._state = 4; | |
| 3048 this._resultOrListeners = value; | |
| 3049 }, | |
| 3050 _setError$2: function(error, stackTrace) { | |
| 3051 this._state = 8; | |
| 3052 this._resultOrListeners = new P._AsyncError(error, stackTrace); | |
| 3053 }, | |
| 3054 _addListener$1: function(listener) { | |
| 3055 if (this._state >= 4) { | |
| 3056 this._zone.toString; | |
| 3057 P._scheduleAsyncCallback(new P._Future__addListener_closure(this, listener
)); | |
| 3058 } else { | |
| 3059 listener.set$_nextListener(this._resultOrListeners); | |
| 3060 this._resultOrListeners = listener; | |
| 3061 } | |
| 3062 }, | |
| 3063 _removeListeners$0: function() { | |
| 3064 var current, prev, next; | |
| 3065 current = this._resultOrListeners; | |
| 3066 this._resultOrListeners = null; | |
| 3067 for (prev = null; current != null; prev = current, current = next) { | |
| 3068 next = current.get$_nextListener(); | |
| 3069 current.set$_nextListener(prev); | |
| 3070 } | |
| 3071 return prev; | |
| 3072 }, | |
| 3073 _complete$1: function(value) { | |
| 3074 var t1, listeners; | |
| 3075 t1 = J.getInterceptor(value); | |
| 3076 if (typeof value === "object" && value !== null && !!t1.$isFuture) { | |
| 3077 P._Future__chainFutures(value, this); | |
| 3078 return; | |
| 3079 } | |
| 3080 listeners = this._removeListeners$0(); | |
| 3081 this._setValue$1(value); | |
| 3082 P._Future__propagateToListeners(this, listeners); | |
| 3083 }, | |
| 3084 _completeError$2: function(error, stackTrace) { | |
| 3085 var listeners = this._removeListeners$0(); | |
| 3086 this._setError$2(error, stackTrace); | |
| 3087 P._Future__propagateToListeners(this, listeners); | |
| 3088 }, | |
| 3089 get$_completeError: function() { | |
| 3090 return new P.BoundClosure$2(this, P._Future.prototype._completeError$2, null
, "_completeError$2"); | |
| 3091 }, | |
| 3092 _asyncComplete$1: function(value) { | |
| 3093 var t1, t2; | |
| 3094 t1 = J.getInterceptor(value); | |
| 3095 t2 = typeof value === "object" && value !== null && !!t1.$isFuture; | |
| 3096 if (t2) | |
| 3097 ; | |
| 3098 if (t2) | |
| 3099 t1 = typeof value !== "object" || value === null || !t1.$is_Future || valu
e._state < 4; | |
| 3100 else | |
| 3101 t1 = false; | |
| 3102 if (t1) { | |
| 3103 this._complete$1(value); | |
| 3104 return; | |
| 3105 } | |
| 3106 if (this._state !== 0) | |
| 3107 H.throwExpression(P.StateError$("Future already completed")); | |
| 3108 this._state = 1; | |
| 3109 this._zone.toString; | |
| 3110 P._scheduleAsyncCallback(new P._Future__asyncComplete_closure(this, value)); | |
| 3111 }, | |
| 3112 _asyncCompleteError$2: function(error, stackTrace) { | |
| 3113 if (this._state !== 0) | |
| 3114 H.throwExpression(P.StateError$("Future already completed")); | |
| 3115 this._state = 1; | |
| 3116 this._zone.toString; | |
| 3117 P._scheduleAsyncCallback(new P._Future__asyncCompleteError_closure(this, err
or, stackTrace)); | |
| 3118 }, | |
| 3119 _async$_Future$immediate$1: function(value, $T) { | |
| 3120 this._asyncComplete$1(value); | |
| 3121 }, | |
| 3122 $is_Future: true, | |
| 3123 $isFuture: true, | |
| 3124 static: { | |
| 3125 "": "_Future__INCOMPLETE,_Future__PENDING_COMPLETE,_Future__CHAINED,_Future__VAL
UE,_Future__ERROR", | |
| 3126 _Future$: function($T) { | |
| 3127 var t1 = new P._Future(0, $.Zone__current, null, null, null, null, null, null)
; | |
| 3128 H.setRuntimeTypeInfo(t1, [$T]); | |
| 3129 return t1; | |
| 3130 }, | |
| 3131 | |
| 3132 _Future$immediate: function(value, $T) { | |
| 3133 var t1 = new P._Future(0, $.Zone__current, null, null, null, null, null, null)
; | |
| 3134 H.setRuntimeTypeInfo(t1, [$T]); | |
| 3135 t1._async$_Future$immediate$1(value, $T); | |
| 3136 return t1; | |
| 3137 }, | |
| 3138 | |
| 3139 _Future$_then: function(onValueCallback, onErrorCallback, $T) { | |
| 3140 var t1 = $.Zone__current; | |
| 3141 t1.toString; | |
| 3142 t1 = new P._Future(0, t1, null, null, onValueCallback, null, P._registerErrorH
andler(onErrorCallback, t1), null); | |
| 3143 H.setRuntimeTypeInfo(t1, [$T]); | |
| 3144 return t1; | |
| 3145 }, | |
| 3146 | |
| 3147 _Future$_catchError: function(onErrorCallback, errorTestCallback, $T) { | |
| 3148 var t1, t2; | |
| 3149 t1 = $.Zone__current; | |
| 3150 t2 = P._registerErrorHandler(onErrorCallback, t1); | |
| 3151 $.Zone__current.toString; | |
| 3152 t2 = new P._Future(0, t1, null, null, null, errorTestCallback, t2, null); | |
| 3153 H.setRuntimeTypeInfo(t2, [$T]); | |
| 3154 return t2; | |
| 3155 }, | |
| 3156 | |
| 3157 _Future$_whenComplete: function(whenCompleteActionCallback, $T) { | |
| 3158 var t1 = $.Zone__current; | |
| 3159 t1.toString; | |
| 3160 t1 = new P._Future(0, t1, null, null, null, null, null, whenCompleteActionCall
back); | |
| 3161 H.setRuntimeTypeInfo(t1, [$T]); | |
| 3162 return t1; | |
| 3163 }, | |
| 3164 | |
| 3165 _Future__chainFutures: function(source, target) { | |
| 3166 var t1; | |
| 3167 target.set$_isChained(true); | |
| 3168 t1 = J.getInterceptor(source); | |
| 3169 if (typeof source === "object" && source !== null && !!t1.$is_Future) | |
| 3170 if (source._state >= 4) | |
| 3171 P._Future__propagateToListeners(source, target); | |
| 3172 else | |
| 3173 source._addListener$1(target); | |
| 3174 else | |
| 3175 source.then$2$onError(new P._Future__chainFutures_closure(target), new P._Fu
ture__chainFutures_closure0(target)); | |
| 3176 }, | |
| 3177 | |
| 3178 _Future__propagateMultipleListeners: function(source, listeners) { | |
| 3179 var listeners0; | |
| 3180 do { | |
| 3181 listeners0 = listeners.get$_nextListener(); | |
| 3182 listeners.set$_nextListener(null); | |
| 3183 P._Future__propagateToListeners(source, listeners); | |
| 3184 if (listeners0 != null) { | |
| 3185 listeners = listeners0; | |
| 3186 continue; | |
| 3187 } else | |
| 3188 break; | |
| 3189 } while (true); | |
| 3190 }, | |
| 3191 | |
| 3192 _Future__propagateToListeners: function(source, listeners) { | |
| 3193 var t1, t2, hasError, asyncError, t3, t4, t5, chainSource, listeners0; | |
| 3194 t1 = {}; | |
| 3195 t1.source_4 = source; | |
| 3196 for (; true;) { | |
| 3197 t2 = {}; | |
| 3198 if (!t1.source_4.get$_isComplete()) | |
| 3199 return; | |
| 3200 hasError = t1.source_4.get$_hasError(); | |
| 3201 if (hasError && listeners == null) { | |
| 3202 asyncError = t1.source_4.get$_error(); | |
| 3203 t2 = t1.source_4.get$_zone(); | |
| 3204 t3 = J.get$error$x(asyncError); | |
| 3205 t4 = asyncError.get$stackTrace(); | |
| 3206 t2.toString; | |
| 3207 P._rootHandleUncaughtError(t2, null, t2, t3, t4); | |
| 3208 return; | |
| 3209 } | |
| 3210 if (listeners == null) | |
| 3211 return; | |
| 3212 if (listeners.get$_nextListener() != null) { | |
| 3213 P._Future__propagateMultipleListeners(t1.source_4, listeners); | |
| 3214 return; | |
| 3215 } | |
| 3216 if (hasError) { | |
| 3217 t3 = t1.source_4.get$_zone(); | |
| 3218 t4 = listeners.get$_zone(); | |
| 3219 t3.toString; | |
| 3220 t4.toString; | |
| 3221 t3 = t4 == null ? t3 != null : t4 !== t3; | |
| 3222 } else | |
| 3223 t3 = false; | |
| 3224 if (t3) { | |
| 3225 asyncError = t1.source_4.get$_error(); | |
| 3226 t2 = t1.source_4.get$_zone(); | |
| 3227 t3 = J.get$error$x(asyncError); | |
| 3228 t4 = asyncError.get$stackTrace(); | |
| 3229 t2.toString; | |
| 3230 P._rootHandleUncaughtError(t2, null, t2, t3, t4); | |
| 3231 return; | |
| 3232 } | |
| 3233 t3 = $.Zone__current; | |
| 3234 t4 = listeners.get$_zone(); | |
| 3235 if (t3 == null ? t4 != null : t3 !== t4) { | |
| 3236 t4.toString; | |
| 3237 P._rootRun(t4, null, t4, new P._Future__propagateToListeners_closure(t1, l
isteners)); | |
| 3238 return; | |
| 3239 } | |
| 3240 t2.listenerHasValue_1 = null; | |
| 3241 t2.listenerValueOrError_2 = null; | |
| 3242 t2.isPropagationAborted_3 = false; | |
| 3243 t3 = listeners.get$_zone(); | |
| 3244 t3.toString; | |
| 3245 P._rootRun(t3, null, t3, new P._Future__propagateToListeners_closure0(t1, t2
, hasError, listeners)); | |
| 3246 if (t2.isPropagationAborted_3) | |
| 3247 return; | |
| 3248 t3 = t2.listenerHasValue_1 === true; | |
| 3249 if (t3) { | |
| 3250 t4 = t2.listenerValueOrError_2; | |
| 3251 t5 = J.getInterceptor(t4); | |
| 3252 t5 = typeof t4 === "object" && t4 !== null && !!t5.$isFuture; | |
| 3253 t4 = t5; | |
| 3254 } else | |
| 3255 t4 = false; | |
| 3256 if (t4) { | |
| 3257 chainSource = t2.listenerValueOrError_2; | |
| 3258 t2 = J.getInterceptor(chainSource); | |
| 3259 if (typeof chainSource === "object" && chainSource !== null && !!t2.$is_Fu
ture && chainSource._state >= 4) { | |
| 3260 listeners.set$_isChained(true); | |
| 3261 t1.source_4 = chainSource; | |
| 3262 continue; | |
| 3263 } | |
| 3264 P._Future__chainFutures(chainSource, listeners); | |
| 3265 return; | |
| 3266 } | |
| 3267 if (t3) { | |
| 3268 listeners0 = listeners._removeListeners$0(); | |
| 3269 listeners._setValue$1(t2.listenerValueOrError_2); | |
| 3270 } else { | |
| 3271 listeners0 = listeners._removeListeners$0(); | |
| 3272 asyncError = t2.listenerValueOrError_2; | |
| 3273 listeners._setError$2(J.get$error$x(asyncError), asyncError.get$stackTrace
()); | |
| 3274 } | |
| 3275 t1.source_4 = listeners; | |
| 3276 listeners = listeners0; | |
| 3277 } | |
| 3278 }} | |
| 3279 | |
| 3280 }, | |
| 3281 | |
| 3282 _Future__addListener_closure: {"": "Closure;this_0,listener_1", | |
| 3283 call$0: function() { | |
| 3284 P._Future__propagateToListeners(this.this_0, this.listener_1); | |
| 3285 }, | |
| 3286 "+call:0:0": 0, | |
| 3287 $isFunction: true | |
| 3288 }, | |
| 3289 | |
| 3290 _Future__chainFutures_closure: {"": "Closure;target_0", | |
| 3291 call$1: function(value) { | |
| 3292 this.target_0._complete$1(value); | |
| 3293 }, | |
| 3294 "+call:1:0": 0, | |
| 3295 $isFunction: true, | |
| 3296 $is_args1: true | |
| 3297 }, | |
| 3298 | |
| 3299 _Future__chainFutures_closure0: {"": "Closure;target_1", | |
| 3300 call$2: function(error, stackTrace) { | |
| 3301 this.target_1._completeError$2(error, stackTrace); | |
| 3302 }, | |
| 3303 "+call:2:0": 0, | |
| 3304 "*call": [0], | |
| 3305 call$1: function(error) { | |
| 3306 return this.call$2(error, null); | |
| 3307 }, | |
| 3308 "+call:1:0": 0, | |
| 3309 $isFunction: true, | |
| 3310 $is_args2: true, | |
| 3311 $is_args1: true | |
| 3312 }, | |
| 3313 | |
| 3314 _Future__asyncComplete_closure: {"": "Closure;this_0,value_1", | |
| 3315 call$0: function() { | |
| 3316 this.this_0._complete$1(this.value_1); | |
| 3317 }, | |
| 3318 "+call:0:0": 0, | |
| 3319 $isFunction: true | |
| 3320 }, | |
| 3321 | |
| 3322 _Future__asyncCompleteError_closure: {"": "Closure;this_0,error_1,stackTrace_2", | |
| 3323 call$0: function() { | |
| 3324 this.this_0._completeError$2(this.error_1, this.stackTrace_2); | |
| 3325 }, | |
| 3326 "+call:0:0": 0, | |
| 3327 $isFunction: true | |
| 3328 }, | |
| 3329 | |
| 3330 _Future__propagateToListeners_closure: {"": "Closure;box_2,listener_3", | |
| 3331 call$0: function() { | |
| 3332 P._Future__propagateToListeners(this.box_2.source_4, this.listener_3); | |
| 3333 }, | |
| 3334 "+call:0:0": 0, | |
| 3335 $isFunction: true | |
| 3336 }, | |
| 3337 | |
| 3338 _Future__propagateToListeners_closure0: {"": "Closure;box_2,box_1,hasError_4,lis
tener_5", | |
| 3339 call$0: function() { | |
| 3340 var t1, value, asyncError, test, matchesTest, errorCallback, e, s, t2, t3, t
4, exception; | |
| 3341 t1 = {}; | |
| 3342 try { | |
| 3343 t2 = this.box_2; | |
| 3344 if (!this.hasError_4) { | |
| 3345 value = t2.source_4.get$_value(); | |
| 3346 t2 = this.listener_5; | |
| 3347 t3 = this.box_1; | |
| 3348 if (t2.get$_onValue() != null) { | |
| 3349 t3.listenerValueOrError_2 = t2._onValue$1(value); | |
| 3350 t3.listenerHasValue_1 = true; | |
| 3351 } else { | |
| 3352 t3.listenerValueOrError_2 = value; | |
| 3353 t3.listenerHasValue_1 = true; | |
| 3354 } | |
| 3355 } else { | |
| 3356 asyncError = t2.source_4.get$_error(); | |
| 3357 t2 = this.listener_5; | |
| 3358 test = t2.get$_errorTest(); | |
| 3359 matchesTest = true; | |
| 3360 if (test != null) | |
| 3361 matchesTest = test.call$1(J.get$error$x(asyncError)); | |
| 3362 t3 = matchesTest === true && t2.get$_onError() != null; | |
| 3363 t4 = this.box_1; | |
| 3364 if (t3) { | |
| 3365 errorCallback = t2.get$_onError(); | |
| 3366 t4.listenerValueOrError_2 = P._invokeErrorHandler(errorCallback, J.get
$error$x(asyncError), asyncError.get$stackTrace()); | |
| 3367 t4.listenerHasValue_1 = true; | |
| 3368 } else { | |
| 3369 t4.listenerValueOrError_2 = asyncError; | |
| 3370 t4.listenerHasValue_1 = false; | |
| 3371 } | |
| 3372 } | |
| 3373 t2 = this.listener_5; | |
| 3374 if (t2.get$_whenCompleteAction() != null) { | |
| 3375 t1.completeResult_0 = t2._whenCompleteAction$0(); | |
| 3376 t3 = t1.completeResult_0; | |
| 3377 t4 = J.getInterceptor(t3); | |
| 3378 if (typeof t3 === "object" && t3 !== null && !!t4.$isFuture) { | |
| 3379 t2.set$_isChained(true); | |
| 3380 t1.completeResult_0.then$2$onError(new P._Future__propagateToListeners
__closure(this.box_2, t2), new P._Future__propagateToListeners__closure0(t1, t2)
); | |
| 3381 this.box_1.isPropagationAborted_3 = true; | |
| 3382 } | |
| 3383 } | |
| 3384 } catch (exception) { | |
| 3385 t1 = H.unwrapException(exception); | |
| 3386 e = t1; | |
| 3387 s = new H._StackTrace(exception, null); | |
| 3388 if (this.hasError_4) { | |
| 3389 t1 = J.get$error$x(this.box_2.source_4.get$_error()); | |
| 3390 t2 = e; | |
| 3391 t2 = t1 == null ? t2 == null : t1 === t2; | |
| 3392 t1 = t2; | |
| 3393 } else | |
| 3394 t1 = false; | |
| 3395 t2 = this.box_1; | |
| 3396 if (t1) | |
| 3397 t2.listenerValueOrError_2 = this.box_2.source_4.get$_error(); | |
| 3398 else | |
| 3399 t2.listenerValueOrError_2 = new P._AsyncError(e, s); | |
| 3400 this.box_1.listenerHasValue_1 = false; | |
| 3401 } | |
| 3402 | |
| 3403 }, | |
| 3404 "+call:0:0": 0, | |
| 3405 $isFunction: true | |
| 3406 }, | |
| 3407 | |
| 3408 _Future__propagateToListeners__closure: {"": "Closure;box_2,listener_6", | |
| 3409 call$1: function(ignored) { | |
| 3410 P._Future__propagateToListeners(this.box_2.source_4, this.listener_6); | |
| 3411 }, | |
| 3412 "+call:1:0": 0, | |
| 3413 $isFunction: true, | |
| 3414 $is_args1: true | |
| 3415 }, | |
| 3416 | |
| 3417 _Future__propagateToListeners__closure0: {"": "Closure;box_0,listener_7", | |
| 3418 call$2: function(error, stackTrace) { | |
| 3419 var t1, t2, t3; | |
| 3420 t1 = this.box_0; | |
| 3421 t2 = t1.completeResult_0; | |
| 3422 t3 = J.getInterceptor(t2); | |
| 3423 if (typeof t2 !== "object" || t2 === null || !t3.$is_Future) { | |
| 3424 t1.completeResult_0 = P._Future$(null); | |
| 3425 t1.completeResult_0._setError$2(error, stackTrace); | |
| 3426 } | |
| 3427 P._Future__propagateToListeners(t1.completeResult_0, this.listener_7); | |
| 3428 }, | |
| 3429 "+call:2:0": 0, | |
| 3430 "*call": [0], | |
| 3431 call$1: function(error) { | |
| 3432 return this.call$2(error, null); | |
| 3433 }, | |
| 3434 "+call:1:0": 0, | |
| 3435 $isFunction: true, | |
| 3436 $is_args2: true, | |
| 3437 $is_args1: true | |
| 3438 }, | |
| 3439 | |
| 3440 Stream: {"": "Object;", | |
| 3441 map$1: function(_, convert) { | |
| 3442 var t1 = new P._MapStream(convert, this); | |
| 3443 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "Stream", 0), null]
); | |
| 3444 return t1; | |
| 3445 }, | |
| 3446 forEach$1: function(_, action) { | |
| 3447 var t1, future; | |
| 3448 t1 = {}; | |
| 3449 future = P._Future$(null); | |
| 3450 t1.subscription_0 = null; | |
| 3451 t1.subscription_0 = this.listen$4$cancelOnError$onDone$onError(new P.Stream_
forEach_closure(t1, this, action, future), true, new P.Stream_forEach_closure0(f
uture), future.get$_completeError()); | |
| 3452 return future; | |
| 3453 }, | |
| 3454 get$length: function(_) { | |
| 3455 var t1, future; | |
| 3456 t1 = {}; | |
| 3457 future = P._Future$(J.JSInt); | |
| 3458 t1.count_0 = 0; | |
| 3459 this.listen$4$cancelOnError$onDone$onError(new P.Stream_length_closure(t1),
true, new P.Stream_length_closure0(t1, future), future.get$_completeError()); | |
| 3460 return future; | |
| 3461 } | |
| 3462 }, | |
| 3463 | |
| 3464 Stream_forEach_closure: {"": "Closure;box_0,this_1,action_2,future_3", | |
| 3465 call$1: function(element) { | |
| 3466 P._runUserCode(new P.Stream_forEach__closure(this.action_2, element), new P.
Stream_forEach__closure0(), P._cancelAndErrorClosure(this.box_0.subscription_0,
this.future_3)); | |
| 3467 }, | |
| 3468 "+call:1:0": 0, | |
| 3469 $isFunction: true, | |
| 3470 $is_args1: true | |
| 3471 }, | |
| 3472 | |
| 3473 Stream_forEach__closure: {"": "Closure;action_4,element_5", | |
| 3474 call$0: function() { | |
| 3475 return this.action_4.call$1(this.element_5); | |
| 3476 }, | |
| 3477 "+call:0:0": 0, | |
| 3478 $isFunction: true | |
| 3479 }, | |
| 3480 | |
| 3481 Stream_forEach__closure0: {"": "Closure;", | |
| 3482 call$1: function(_) { | |
| 3483 }, | |
| 3484 "+call:1:0": 0, | |
| 3485 $isFunction: true, | |
| 3486 $is_args1: true | |
| 3487 }, | |
| 3488 | |
| 3489 Stream_forEach_closure0: {"": "Closure;future_6", | |
| 3490 call$0: function() { | |
| 3491 this.future_6._complete$1(null); | |
| 3492 }, | |
| 3493 "+call:0:0": 0, | |
| 3494 $isFunction: true | |
| 3495 }, | |
| 3496 | |
| 3497 Stream_length_closure: {"": "Closure;box_0", | |
| 3498 call$1: function(_) { | |
| 3499 var t1 = this.box_0; | |
| 3500 t1.count_0 = t1.count_0 + 1; | |
| 3501 }, | |
| 3502 "+call:1:0": 0, | |
| 3503 $isFunction: true, | |
| 3504 $is_args1: true | |
| 3505 }, | |
| 3506 | |
| 3507 Stream_length_closure0: {"": "Closure;box_0,future_1", | |
| 3508 call$0: function() { | |
| 3509 this.future_1._complete$1(this.box_0.count_0); | |
| 3510 }, | |
| 3511 "+call:0:0": 0, | |
| 3512 $isFunction: true | |
| 3513 }, | |
| 3514 | |
| 3515 StreamSubscription: {"": "Object;"}, | |
| 3516 | |
| 3517 _StreamController: {"": "Object;", | |
| 3518 get$_pendingEvents: function() { | |
| 3519 if ((this._state & 8) === 0) | |
| 3520 return this._varData; | |
| 3521 return this._varData.get$varData(); | |
| 3522 }, | |
| 3523 _ensurePendingEvents$0: function() { | |
| 3524 if ((this._state & 8) === 0) { | |
| 3525 if (this._varData == null) | |
| 3526 this._varData = new P._StreamImplEvents(null, null, 0); | |
| 3527 return this._varData; | |
| 3528 } | |
| 3529 var t1 = this._varData.get$varData(); | |
| 3530 return t1; | |
| 3531 }, | |
| 3532 get$_subscription: function() { | |
| 3533 if ((this._state & 8) !== 0) | |
| 3534 return this._varData.get$varData(); | |
| 3535 return this._varData; | |
| 3536 }, | |
| 3537 _badEventState$0: function() { | |
| 3538 if ((this._state & 4) !== 0) | |
| 3539 return new P.StateError("Cannot add event after closing"); | |
| 3540 return new P.StateError("Cannot add event while adding a stream"); | |
| 3541 }, | |
| 3542 _ensureDoneFuture$0: function() { | |
| 3543 if (this._doneFuture == null) { | |
| 3544 this._doneFuture = P._Future$(null); | |
| 3545 if ((this._state & 2) !== 0) | |
| 3546 this._doneFuture._complete$1(null); | |
| 3547 } | |
| 3548 return this._doneFuture; | |
| 3549 }, | |
| 3550 close$0: function(_) { | |
| 3551 var t1 = this._state; | |
| 3552 if ((t1 & 4) !== 0) | |
| 3553 return this._doneFuture; | |
| 3554 if (t1 >= 4) | |
| 3555 throw H.wrapException(this._badEventState$0()); | |
| 3556 this._state = (t1 | 4) >>> 0; | |
| 3557 this._ensureDoneFuture$0(); | |
| 3558 t1 = this._state; | |
| 3559 if ((t1 & 1) !== 0) | |
| 3560 this._sendDone$0(); | |
| 3561 else if ((t1 & 3) === 0) { | |
| 3562 t1 = this._ensurePendingEvents$0(); | |
| 3563 t1.add$1(t1, C.C__DelayedDone); | |
| 3564 } | |
| 3565 return this._doneFuture; | |
| 3566 }, | |
| 3567 _async$_add$1: function(value) { | |
| 3568 var t1 = this._state; | |
| 3569 if ((t1 & 1) !== 0) | |
| 3570 this._sendData$1(value); | |
| 3571 else if ((t1 & 3) === 0) { | |
| 3572 t1 = this._ensurePendingEvents$0(); | |
| 3573 t1.add$1(t1, new P._DelayedData(value, null)); | |
| 3574 } | |
| 3575 }, | |
| 3576 _addError$2: function(error, stackTrace) { | |
| 3577 var t1 = this._state; | |
| 3578 if ((t1 & 1) !== 0) | |
| 3579 this._sendError$2(error, stackTrace); | |
| 3580 else if ((t1 & 3) === 0) { | |
| 3581 t1 = this._ensurePendingEvents$0(); | |
| 3582 t1.add$1(t1, new P._DelayedError(error, stackTrace, null)); | |
| 3583 } | |
| 3584 }, | |
| 3585 _subscribe$1: function(cancelOnError) { | |
| 3586 var t1, t2, subscription, pendingEvents, addState; | |
| 3587 if ((this._state & 3) !== 0) | |
| 3588 throw H.wrapException(P.StateError$("Stream has already been listened to."
)); | |
| 3589 t1 = $.Zone__current; | |
| 3590 t2 = cancelOnError ? 1 : 0; | |
| 3591 subscription = new P._ControllerSubscription(this, null, null, null, t1, t2,
null, null); | |
| 3592 H.setRuntimeTypeInfo(subscription, [null]); | |
| 3593 pendingEvents = this.get$_pendingEvents(); | |
| 3594 this._state = (this._state | 1) >>> 0; | |
| 3595 if ((this._state & 8) !== 0) { | |
| 3596 addState = this._varData; | |
| 3597 addState.set$varData(subscription); | |
| 3598 addState.resume$0(); | |
| 3599 } else | |
| 3600 this._varData = subscription; | |
| 3601 subscription._setPendingEvents$1(pendingEvents); | |
| 3602 subscription._guardCallback$1(new P._StreamController__subscribe_closure(thi
s)); | |
| 3603 return subscription; | |
| 3604 }, | |
| 3605 _recordCancel$1: function(subscription) { | |
| 3606 var t1, future; | |
| 3607 if ((this._state & 8) !== 0) | |
| 3608 this._varData.cancel$0(); | |
| 3609 this._varData = null; | |
| 3610 this._state = (this._state & 4294967286 | 2) >>> 0; | |
| 3611 t1 = new P._StreamController__recordCancel_complete(this); | |
| 3612 future = P._runGuarded(this.get$_onCancel()); | |
| 3613 if (future != null) | |
| 3614 future = future.whenComplete$1(t1); | |
| 3615 else | |
| 3616 t1.call$0(); | |
| 3617 return future; | |
| 3618 } | |
| 3619 }, | |
| 3620 | |
| 3621 _StreamController__subscribe_closure: {"": "Closure;this_0", | |
| 3622 call$0: function() { | |
| 3623 P._runGuarded(this.this_0.get$_onListen()); | |
| 3624 }, | |
| 3625 "+call:0:0": 0, | |
| 3626 $isFunction: true | |
| 3627 }, | |
| 3628 | |
| 3629 _StreamController__recordCancel_complete: {"": "Closure;this_0", | |
| 3630 call$0: function() { | |
| 3631 var t1 = this.this_0._doneFuture; | |
| 3632 if (t1 != null && t1._state === 0) | |
| 3633 t1._asyncComplete$1(null); | |
| 3634 }, | |
| 3635 "+call:0:0": 0, | |
| 3636 $isFunction: true | |
| 3637 }, | |
| 3638 | |
| 3639 _SyncStreamControllerDispatch: {"": "Object;", | |
| 3640 _sendData$1: function(data) { | |
| 3641 this.get$_subscription()._async$_add$1(data); | |
| 3642 }, | |
| 3643 _sendError$2: function(error, stackTrace) { | |
| 3644 this.get$_subscription()._addError$2(error, stackTrace); | |
| 3645 }, | |
| 3646 _sendDone$0: function() { | |
| 3647 this.get$_subscription()._close$0(); | |
| 3648 } | |
| 3649 }, | |
| 3650 | |
| 3651 _AsyncStreamControllerDispatch: {"": "Object;", | |
| 3652 _sendData$1: function(data) { | |
| 3653 this.get$_subscription()._addPending$1(new P._DelayedData(data, null)); | |
| 3654 }, | |
| 3655 _sendError$2: function(error, stackTrace) { | |
| 3656 this.get$_subscription()._addPending$1(new P._DelayedError(error, stackTrace
, null)); | |
| 3657 }, | |
| 3658 _sendDone$0: function() { | |
| 3659 this.get$_subscription()._addPending$1(C.C__DelayedDone); | |
| 3660 } | |
| 3661 }, | |
| 3662 | |
| 3663 _AsyncStreamController: {"": "_StreamController__AsyncStreamControllerDispatch;_
onListen<,_onPause<,_onResume<,_onCancel<,_varData,_state,_doneFuture"}, | |
| 3664 | |
| 3665 _StreamController__AsyncStreamControllerDispatch: {"": "_StreamController+_Async
StreamControllerDispatch;"}, | |
| 3666 | |
| 3667 _SyncStreamController: {"": "_StreamController__SyncStreamControllerDispatch;_on
Listen<,_onPause<,_onResume<,_onCancel<,_varData,_state,_doneFuture"}, | |
| 3668 | |
| 3669 _StreamController__SyncStreamControllerDispatch: {"": "_StreamController+_SyncSt
reamControllerDispatch;"}, | |
| 3670 | |
| 3671 _ControllerStream: {"": "_StreamImpl;_async$_controller", | |
| 3672 _createSubscription$1: function(cancelOnError) { | |
| 3673 return this._async$_controller._subscribe$1(cancelOnError); | |
| 3674 }, | |
| 3675 get$hashCode: function(_) { | |
| 3676 return (H.Primitives_objectHashCode(this._async$_controller) ^ 892482866) >>
> 0; | |
| 3677 }, | |
| 3678 $eq: function(_, other) { | |
| 3679 var t1; | |
| 3680 if (other == null) | |
| 3681 return false; | |
| 3682 if (this === other) | |
| 3683 return true; | |
| 3684 t1 = J.getInterceptor(other); | |
| 3685 if (typeof other !== "object" || other === null || !t1.$is_ControllerStream) | |
| 3686 return false; | |
| 3687 return other._async$_controller === this._async$_controller; | |
| 3688 }, | |
| 3689 $is_ControllerStream: true, | |
| 3690 $as_StreamImpl: null | |
| 3691 }, | |
| 3692 | |
| 3693 _ControllerSubscription: {"": "_BufferingStreamSubscription;_async$_controller,_
async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending", | |
| 3694 _onCancel$0: function() { | |
| 3695 return this._async$_controller._recordCancel$1(this); | |
| 3696 }, | |
| 3697 _onPause$0: function() { | |
| 3698 var t1, addState; | |
| 3699 t1 = this._async$_controller; | |
| 3700 if ((t1._state & 8) !== 0) { | |
| 3701 addState = t1._varData; | |
| 3702 addState.pause$0(addState); | |
| 3703 } | |
| 3704 P._runGuarded(t1.get$_onPause()); | |
| 3705 }, | |
| 3706 get$_onPause: function() { | |
| 3707 return new P.BoundClosure$0(this, P._ControllerSubscription.prototype._onPau
se$0, null, "_onPause$0"); | |
| 3708 }, | |
| 3709 _onResume$0: function() { | |
| 3710 var t1 = this._async$_controller; | |
| 3711 if ((t1._state & 8) !== 0) | |
| 3712 t1._varData.resume$0(); | |
| 3713 P._runGuarded(t1.get$_onResume()); | |
| 3714 }, | |
| 3715 get$_onResume: function() { | |
| 3716 return new P.BoundClosure$0(this, P._ControllerSubscription.prototype._onRes
ume$0, null, "_onResume$0"); | |
| 3717 }, | |
| 3718 $as_BufferingStreamSubscription: null | |
| 3719 }, | |
| 3720 | |
| 3721 _EventSink: {"": "Object;"}, | |
| 3722 | |
| 3723 _BufferingStreamSubscription: {"": "Object;_async$_onData,_onError<,_onDone,_zon
e<,_state,_cancelFuture,_pending", | |
| 3724 _setPendingEvents$1: function(pendingEvents) { | |
| 3725 if (pendingEvents == null) | |
| 3726 return; | |
| 3727 this._pending = pendingEvents; | |
| 3728 if (!pendingEvents.get$isEmpty(pendingEvents)) { | |
| 3729 this._state = (this._state | 64) >>> 0; | |
| 3730 this._pending.schedule$1(this); | |
| 3731 } | |
| 3732 }, | |
| 3733 onData$1: function(handleData) { | |
| 3734 $.Zone__current.toString; | |
| 3735 this._async$_onData = handleData; | |
| 3736 }, | |
| 3737 onError$1: function(_, handleError) { | |
| 3738 this._onError = P._registerErrorHandler(handleError, $.Zone__current); | |
| 3739 }, | |
| 3740 onDone$1: function(handleDone) { | |
| 3741 $.Zone__current.toString; | |
| 3742 this._onDone = handleDone; | |
| 3743 }, | |
| 3744 pause$1: function(_, resumeSignal) { | |
| 3745 var t1 = this._state; | |
| 3746 if ((t1 & 8) !== 0) | |
| 3747 return; | |
| 3748 this._state = (t1 + 128 | 4) >>> 0; | |
| 3749 if (t1 < 128 && this._pending != null) | |
| 3750 this._pending.cancelSchedule$0(); | |
| 3751 if ((t1 & 4) === 0 && (this._state & 32) === 0) | |
| 3752 this._guardCallback$1(this.get$_onPause()); | |
| 3753 }, | |
| 3754 pause$0: function($receiver) { | |
| 3755 return this.pause$1($receiver, null); | |
| 3756 }, | |
| 3757 resume$0: function() { | |
| 3758 var t1 = this._state; | |
| 3759 if ((t1 & 8) !== 0) | |
| 3760 return; | |
| 3761 if (t1 >= 128) { | |
| 3762 this._state = t1 - 128; | |
| 3763 t1 = this._state; | |
| 3764 if (t1 < 128) { | |
| 3765 if ((t1 & 64) !== 0) { | |
| 3766 t1 = this._pending; | |
| 3767 t1 = !t1.get$isEmpty(t1); | |
| 3768 } else | |
| 3769 t1 = false; | |
| 3770 if (t1) | |
| 3771 this._pending.schedule$1(this); | |
| 3772 else { | |
| 3773 this._state = (this._state & 4294967291) >>> 0; | |
| 3774 if ((this._state & 32) === 0) | |
| 3775 this._guardCallback$1(this.get$_onResume()); | |
| 3776 } | |
| 3777 } | |
| 3778 } | |
| 3779 }, | |
| 3780 cancel$0: function() { | |
| 3781 this._state = (this._state & 4294967279) >>> 0; | |
| 3782 if ((this._state & 8) !== 0) | |
| 3783 return this._cancelFuture; | |
| 3784 this._cancel$0(); | |
| 3785 return this._cancelFuture; | |
| 3786 }, | |
| 3787 get$_mayResumeInput: function() { | |
| 3788 if (this._state < 128) { | |
| 3789 var t1 = this._pending; | |
| 3790 t1 = t1 == null || t1.get$isEmpty(t1); | |
| 3791 } else | |
| 3792 t1 = false; | |
| 3793 return t1; | |
| 3794 }, | |
| 3795 _cancel$0: function() { | |
| 3796 this._state = (this._state | 8) >>> 0; | |
| 3797 if ((this._state & 64) !== 0) | |
| 3798 this._pending.cancelSchedule$0(); | |
| 3799 if ((this._state & 32) === 0) | |
| 3800 this._pending = null; | |
| 3801 this._cancelFuture = this._onCancel$0(); | |
| 3802 }, | |
| 3803 _async$_add$1: function(data) { | |
| 3804 var t1 = this._state; | |
| 3805 if ((t1 & 8) !== 0) | |
| 3806 return; | |
| 3807 if (t1 < 32) | |
| 3808 this._sendData$1(data); | |
| 3809 else | |
| 3810 this._addPending$1(new P._DelayedData(data, null)); | |
| 3811 }, | |
| 3812 _addError$2: function(error, stackTrace) { | |
| 3813 var t1 = this._state; | |
| 3814 if ((t1 & 8) !== 0) | |
| 3815 return; | |
| 3816 if (t1 < 32) | |
| 3817 this._sendError$2(error, stackTrace); | |
| 3818 else | |
| 3819 this._addPending$1(new P._DelayedError(error, stackTrace, null)); | |
| 3820 }, | |
| 3821 _close$0: function() { | |
| 3822 var t1 = this._state; | |
| 3823 if ((t1 & 8) !== 0) | |
| 3824 return; | |
| 3825 this._state = (t1 | 2) >>> 0; | |
| 3826 if (this._state < 32) | |
| 3827 this._sendDone$0(); | |
| 3828 else | |
| 3829 this._addPending$1(C.C__DelayedDone); | |
| 3830 }, | |
| 3831 _onPause$0: function() { | |
| 3832 }, | |
| 3833 get$_onPause: function() { | |
| 3834 return new P.BoundClosure$0(this, P._BufferingStreamSubscription.prototype._
onPause$0, null, "_onPause$0"); | |
| 3835 }, | |
| 3836 _onResume$0: function() { | |
| 3837 }, | |
| 3838 get$_onResume: function() { | |
| 3839 return new P.BoundClosure$0(this, P._BufferingStreamSubscription.prototype._
onResume$0, null, "_onResume$0"); | |
| 3840 }, | |
| 3841 _onCancel$0: function() { | |
| 3842 }, | |
| 3843 _addPending$1: function($event) { | |
| 3844 var pending, t1; | |
| 3845 pending = this._pending; | |
| 3846 if (pending == null) { | |
| 3847 pending = new P._StreamImplEvents(null, null, 0); | |
| 3848 this._pending = pending; | |
| 3849 } | |
| 3850 pending.add$1(pending, $event); | |
| 3851 t1 = this._state; | |
| 3852 if ((t1 & 64) === 0) { | |
| 3853 this._state = (t1 | 64) >>> 0; | |
| 3854 if (this._state < 128) | |
| 3855 this._pending.schedule$1(this); | |
| 3856 } | |
| 3857 }, | |
| 3858 _sendData$1: function(data) { | |
| 3859 var t1 = this._state; | |
| 3860 this._state = (t1 | 32) >>> 0; | |
| 3861 this._zone.runUnaryGuarded$2(this._async$_onData, data); | |
| 3862 this._state = (this._state & 4294967263) >>> 0; | |
| 3863 this._checkState$1((t1 & 4) !== 0); | |
| 3864 }, | |
| 3865 _sendError$2: function(error, stackTrace) { | |
| 3866 var t1, t2, t3; | |
| 3867 t1 = this._state; | |
| 3868 t2 = new P._BufferingStreamSubscription__sendError_sendError(this, error, st
ackTrace); | |
| 3869 if ((t1 & 1) !== 0) { | |
| 3870 this._state = (t1 | 16) >>> 0; | |
| 3871 this._cancel$0(); | |
| 3872 t1 = this._cancelFuture; | |
| 3873 t3 = J.getInterceptor(t1); | |
| 3874 if (typeof t1 === "object" && t1 !== null && !!t3.$isFuture) | |
| 3875 t1.whenComplete$1(t2); | |
| 3876 else | |
| 3877 t2.call$0(); | |
| 3878 } else { | |
| 3879 t2.call$0(); | |
| 3880 this._checkState$1((t1 & 4) !== 0); | |
| 3881 } | |
| 3882 }, | |
| 3883 _sendDone$0: function() { | |
| 3884 var t1, t2, t3; | |
| 3885 t1 = new P._BufferingStreamSubscription__sendDone_sendDone(this); | |
| 3886 this._cancel$0(); | |
| 3887 this._state = (this._state | 16) >>> 0; | |
| 3888 t2 = this._cancelFuture; | |
| 3889 t3 = J.getInterceptor(t2); | |
| 3890 if (typeof t2 === "object" && t2 !== null && !!t3.$isFuture) | |
| 3891 t2.whenComplete$1(t1); | |
| 3892 else | |
| 3893 t1.call$0(); | |
| 3894 }, | |
| 3895 _guardCallback$1: function(callback) { | |
| 3896 var t1 = this._state; | |
| 3897 this._state = (t1 | 32) >>> 0; | |
| 3898 callback.call$0(); | |
| 3899 this._state = (this._state & 4294967263) >>> 0; | |
| 3900 this._checkState$1((t1 & 4) !== 0); | |
| 3901 }, | |
| 3902 _checkState$1: function(wasInputPaused) { | |
| 3903 var t1, isInputPaused; | |
| 3904 if ((this._state & 64) !== 0) { | |
| 3905 t1 = this._pending; | |
| 3906 t1 = t1.get$isEmpty(t1); | |
| 3907 } else | |
| 3908 t1 = false; | |
| 3909 if (t1) { | |
| 3910 this._state = (this._state & 4294967231) >>> 0; | |
| 3911 if ((this._state & 4) !== 0 && this.get$_mayResumeInput()) | |
| 3912 this._state = (this._state & 4294967291) >>> 0; | |
| 3913 } | |
| 3914 for (; true; wasInputPaused = isInputPaused) { | |
| 3915 t1 = this._state; | |
| 3916 if ((t1 & 8) !== 0) { | |
| 3917 this._pending = null; | |
| 3918 return; | |
| 3919 } | |
| 3920 isInputPaused = (t1 & 4) !== 0; | |
| 3921 if (wasInputPaused === isInputPaused) | |
| 3922 break; | |
| 3923 this._state = (t1 ^ 32) >>> 0; | |
| 3924 if (isInputPaused) | |
| 3925 this._onPause$0(); | |
| 3926 else | |
| 3927 this._onResume$0(); | |
| 3928 this._state = (this._state & 4294967263) >>> 0; | |
| 3929 } | |
| 3930 t1 = this._state; | |
| 3931 if ((t1 & 64) !== 0 && t1 < 128) | |
| 3932 this._pending.schedule$1(this); | |
| 3933 }, | |
| 3934 static: { | |
| 3935 "": "_BufferingStreamSubscription__STATE_CANCEL_ON_ERROR,_BufferingStreamSubscri
ption__STATE_CLOSED,_BufferingStreamSubscription__STATE_INPUT_PAUSED,_BufferingS
treamSubscription__STATE_CANCELED,_BufferingStreamSubscription__STATE_WAIT_FOR_C
ANCEL,_BufferingStreamSubscription__STATE_IN_CALLBACK,_BufferingStreamSubscripti
on__STATE_HAS_PENDING,_BufferingStreamSubscription__STATE_PAUSE_COUNT,_Buffering
StreamSubscription__STATE_PAUSE_COUNT_SHIFT", | |
| 3936 } | |
| 3937 | |
| 3938 }, | |
| 3939 | |
| 3940 _BufferingStreamSubscription__sendError_sendError: {"": "Closure;this_0,error_1,
stackTrace_2", | |
| 3941 call$0: function() { | |
| 3942 var t1, t2, t3, t4, t5; | |
| 3943 t1 = this.this_0; | |
| 3944 t2 = t1._state; | |
| 3945 if ((t2 & 8) !== 0 && (t2 & 16) === 0) | |
| 3946 return; | |
| 3947 t1._state = (t2 | 32) >>> 0; | |
| 3948 t2 = t1._zone; | |
| 3949 t3 = $.Zone__current; | |
| 3950 t2.toString; | |
| 3951 t3.toString; | |
| 3952 if (t3 == null ? t2 != null : t3 !== t2) | |
| 3953 P._rootHandleUncaughtError(t3, null, t3, this.error_1, this.stackTrace_2); | |
| 3954 else { | |
| 3955 t3 = t1._onError; | |
| 3956 t4 = J.getInterceptor(t3); | |
| 3957 t5 = this.error_1; | |
| 3958 if (!!t4.$is_args2) | |
| 3959 t2.runBinaryGuarded$3(t3, t5, this.stackTrace_2); | |
| 3960 else | |
| 3961 t2.runUnaryGuarded$2(t3, t5); | |
| 3962 } | |
| 3963 t1._state = (t1._state & 4294967263) >>> 0; | |
| 3964 }, | |
| 3965 "+call:0:0": 0, | |
| 3966 $isFunction: true | |
| 3967 }, | |
| 3968 | |
| 3969 _BufferingStreamSubscription__sendDone_sendDone: {"": "Closure;this_0", | |
| 3970 call$0: function() { | |
| 3971 var t1, t2; | |
| 3972 t1 = this.this_0; | |
| 3973 t2 = t1._state; | |
| 3974 if ((t2 & 16) === 0) | |
| 3975 return; | |
| 3976 t1._state = (t2 | 42) >>> 0; | |
| 3977 t1._zone.runGuarded$1(t1._onDone); | |
| 3978 t1._state = (t1._state & 4294967263) >>> 0; | |
| 3979 }, | |
| 3980 "+call:0:0": 0, | |
| 3981 $isFunction: true | |
| 3982 }, | |
| 3983 | |
| 3984 _StreamImpl: {"": "Stream;", | |
| 3985 listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone,
onError) { | |
| 3986 var subscription = this._createSubscription$1(true === cancelOnError); | |
| 3987 subscription.onData$1(onData); | |
| 3988 subscription.onError$1(subscription, onError); | |
| 3989 subscription.onDone$1(onDone); | |
| 3990 return subscription; | |
| 3991 }, | |
| 3992 listen$3$onDone$onError: function(onData, onDone, onError) { | |
| 3993 return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onEr
ror); | |
| 3994 }, | |
| 3995 _createSubscription$1: function(cancelOnError) { | |
| 3996 var t1, t2; | |
| 3997 t1 = $.Zone__current; | |
| 3998 t2 = cancelOnError ? 1 : 0; | |
| 3999 return new P._BufferingStreamSubscription(null, null, null, t1, t2, null, nu
ll); | |
| 4000 }, | |
| 4001 $asStream: null | |
| 4002 }, | |
| 4003 | |
| 4004 _DelayedEvent: {"": "Object;next@"}, | |
| 4005 | |
| 4006 _DelayedData: {"": "_DelayedEvent;value,next", | |
| 4007 perform$1: function(dispatch) { | |
| 4008 dispatch._sendData$1(this.value); | |
| 4009 } | |
| 4010 }, | |
| 4011 | |
| 4012 _DelayedError: {"": "_DelayedEvent;error>,stackTrace<,next", | |
| 4013 perform$1: function(dispatch) { | |
| 4014 dispatch._sendError$2(this.error, this.stackTrace); | |
| 4015 } | |
| 4016 }, | |
| 4017 | |
| 4018 _DelayedDone: {"": "Object;", | |
| 4019 perform$1: function(dispatch) { | |
| 4020 dispatch._sendDone$0(); | |
| 4021 }, | |
| 4022 get$next: function() { | |
| 4023 return; | |
| 4024 }, | |
| 4025 set$next: function(_) { | |
| 4026 throw H.wrapException(P.StateError$("No events after a done.")); | |
| 4027 } | |
| 4028 }, | |
| 4029 | |
| 4030 _PendingEvents: {"": "Object;", | |
| 4031 schedule$1: function(dispatch) { | |
| 4032 var t1 = this._state; | |
| 4033 if (t1 === 1) | |
| 4034 return; | |
| 4035 if (t1 >= 1) { | |
| 4036 this._state = 1; | |
| 4037 return; | |
| 4038 } | |
| 4039 P.scheduleMicrotask(new P._PendingEvents_schedule_closure(this, dispatch)); | |
| 4040 this._state = 1; | |
| 4041 }, | |
| 4042 cancelSchedule$0: function() { | |
| 4043 if (this._state === 1) | |
| 4044 this._state = 3; | |
| 4045 } | |
| 4046 }, | |
| 4047 | |
| 4048 _PendingEvents_schedule_closure: {"": "Closure;this_0,dispatch_1", | |
| 4049 call$0: function() { | |
| 4050 var t1, oldState; | |
| 4051 t1 = this.this_0; | |
| 4052 oldState = t1._state; | |
| 4053 t1._state = 0; | |
| 4054 if (oldState === 3) | |
| 4055 return; | |
| 4056 t1.handleNext$1(this.dispatch_1); | |
| 4057 }, | |
| 4058 "+call:0:0": 0, | |
| 4059 $isFunction: true | |
| 4060 }, | |
| 4061 | |
| 4062 _StreamImplEvents: {"": "_PendingEvents;firstPendingEvent,lastPendingEvent,_stat
e", | |
| 4063 get$isEmpty: function(_) { | |
| 4064 return this.lastPendingEvent == null; | |
| 4065 }, | |
| 4066 add$1: function(_, $event) { | |
| 4067 var t1 = this.lastPendingEvent; | |
| 4068 if (t1 == null) { | |
| 4069 this.lastPendingEvent = $event; | |
| 4070 this.firstPendingEvent = $event; | |
| 4071 } else { | |
| 4072 t1.set$next($event); | |
| 4073 this.lastPendingEvent = $event; | |
| 4074 } | |
| 4075 }, | |
| 4076 handleNext$1: function(dispatch) { | |
| 4077 var $event = this.firstPendingEvent; | |
| 4078 this.firstPendingEvent = $event.get$next(); | |
| 4079 if (this.firstPendingEvent == null) | |
| 4080 this.lastPendingEvent = null; | |
| 4081 $event.perform$1(dispatch); | |
| 4082 } | |
| 4083 }, | |
| 4084 | |
| 4085 _cancelAndError_closure: {"": "Closure;future_0,error_1,stackTrace_2", | |
| 4086 call$0: function() { | |
| 4087 return this.future_0._completeError$2(this.error_1, this.stackTrace_2); | |
| 4088 }, | |
| 4089 "+call:0:0": 0, | |
| 4090 $isFunction: true | |
| 4091 }, | |
| 4092 | |
| 4093 _cancelAndErrorClosure_closure: {"": "Closure;subscription_0,future_1", | |
| 4094 call$2: function(error, stackTrace) { | |
| 4095 return P._cancelAndError(this.subscription_0, this.future_1, error, stackTra
ce); | |
| 4096 }, | |
| 4097 "+call:2:0": 0, | |
| 4098 $isFunction: true, | |
| 4099 $is_args2: true | |
| 4100 }, | |
| 4101 | |
| 4102 _ForwardingStream: {"": "Stream;", | |
| 4103 listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone,
onError) { | |
| 4104 var result = P._ForwardingStreamSubscription$(this, true === cancelOnError,
H.getRuntimeTypeArgument(this, "_ForwardingStream", 0), H.getRuntimeTypeArgument
(this, "_ForwardingStream", 1)); | |
| 4105 result.onData$1(onData); | |
| 4106 result.onError$1(result, onError); | |
| 4107 result.onDone$1(onDone); | |
| 4108 return result; | |
| 4109 }, | |
| 4110 listen$3$onDone$onError: function(onData, onDone, onError) { | |
| 4111 return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onEr
ror); | |
| 4112 }, | |
| 4113 _handleData$2: function(data, sink) { | |
| 4114 sink._async$_add$1(data); | |
| 4115 }, | |
| 4116 $asStream: function($S, $T) { | |
| 4117 return [$T]; | |
| 4118 } | |
| 4119 }, | |
| 4120 | |
| 4121 _ForwardingStreamSubscription: {"": "_BufferingStreamSubscription;_stream,_subsc
ription,_async$_onData,_onError,_onDone,_zone,_state,_cancelFuture,_pending", | |
| 4122 _async$_add$1: function(data) { | |
| 4123 if ((this._state & 2) !== 0) | |
| 4124 return; | |
| 4125 P._BufferingStreamSubscription.prototype._async$_add$1.call(this, data); | |
| 4126 }, | |
| 4127 _addError$2: function(error, stackTrace) { | |
| 4128 if ((this._state & 2) !== 0) | |
| 4129 return; | |
| 4130 P._BufferingStreamSubscription.prototype._addError$2.call(this, error, stack
Trace); | |
| 4131 }, | |
| 4132 _onPause$0: function() { | |
| 4133 var t1 = this._subscription; | |
| 4134 if (t1 == null) | |
| 4135 return; | |
| 4136 t1.pause$0(t1); | |
| 4137 }, | |
| 4138 get$_onPause: function() { | |
| 4139 return new P.BoundClosure$0(this, P._ForwardingStreamSubscription.prototype.
_onPause$0, null, "_onPause$0"); | |
| 4140 }, | |
| 4141 _onResume$0: function() { | |
| 4142 var t1 = this._subscription; | |
| 4143 if (t1 == null) | |
| 4144 return; | |
| 4145 t1.resume$0(); | |
| 4146 }, | |
| 4147 get$_onResume: function() { | |
| 4148 return new P.BoundClosure$0(this, P._ForwardingStreamSubscription.prototype.
_onResume$0, null, "_onResume$0"); | |
| 4149 }, | |
| 4150 _onCancel$0: function() { | |
| 4151 var t1 = this._subscription; | |
| 4152 if (t1 != null) { | |
| 4153 this._subscription = null; | |
| 4154 t1.cancel$0(); | |
| 4155 } | |
| 4156 return; | |
| 4157 }, | |
| 4158 _handleData$1: function(data) { | |
| 4159 this._stream._handleData$2(data, this); | |
| 4160 }, | |
| 4161 get$_handleData: function() { | |
| 4162 return new H.BoundClosure$1(this, P._ForwardingStreamSubscription.prototype.
_handleData$1, null, "_handleData$1"); | |
| 4163 }, | |
| 4164 _handleError$2: function(error, stackTrace) { | |
| 4165 this._addError$2(error, stackTrace); | |
| 4166 }, | |
| 4167 get$_handleError: function() { | |
| 4168 return new P.BoundClosure$20(this, P._ForwardingStreamSubscription.prototype
._handleError$2, null, "_handleError$2"); | |
| 4169 }, | |
| 4170 _handleDone$0: function() { | |
| 4171 this._close$0(); | |
| 4172 }, | |
| 4173 get$_handleDone: function() { | |
| 4174 return new P.BoundClosure$0(this, P._ForwardingStreamSubscription.prototype.
_handleDone$0, null, "_handleDone$0"); | |
| 4175 }, | |
| 4176 _ForwardingStreamSubscription$2: function(_stream, cancelOnError, $S, $T) { | |
| 4177 var t1, t2; | |
| 4178 t1 = this.get$_handleData(); | |
| 4179 t2 = this.get$_handleError(); | |
| 4180 this._subscription = this._stream._source.listen$3$onDone$onError(t1, this.g
et$_handleDone(), t2); | |
| 4181 }, | |
| 4182 $as_BufferingStreamSubscription: function($S, $T) { | |
| 4183 return [$T]; | |
| 4184 }, | |
| 4185 static: { | |
| 4186 _ForwardingStreamSubscription$: function(_stream, cancelOnError, $S, $T) { | |
| 4187 var t1, t2; | |
| 4188 t1 = $.Zone__current; | |
| 4189 t2 = cancelOnError ? 1 : 0; | |
| 4190 t2 = new P._ForwardingStreamSubscription(_stream, null, null, null, null, t1,
t2, null, null); | |
| 4191 H.setRuntimeTypeInfo(t2, [$S, $T]); | |
| 4192 t2._ForwardingStreamSubscription$2(_stream, cancelOnError, $S, $T); | |
| 4193 return t2; | |
| 4194 }} | |
| 4195 | |
| 4196 }, | |
| 4197 | |
| 4198 _MapStream: {"": "_ForwardingStream;_transform,_source", | |
| 4199 _transform$1: function(arg0) { | |
| 4200 return this._transform.call$1(arg0); | |
| 4201 }, | |
| 4202 _handleData$2: function(inputEvent, sink) { | |
| 4203 var outputEvent, e, s, exception, t1; | |
| 4204 outputEvent = null; | |
| 4205 try { | |
| 4206 outputEvent = this._transform$1(inputEvent); | |
| 4207 } catch (exception) { | |
| 4208 t1 = H.unwrapException(exception); | |
| 4209 e = t1; | |
| 4210 s = new H._StackTrace(exception, null); | |
| 4211 sink._addError$2(e, s); | |
| 4212 return; | |
| 4213 } | |
| 4214 | |
| 4215 sink._async$_add$1(outputEvent); | |
| 4216 }, | |
| 4217 $as_ForwardingStream: null | |
| 4218 }, | |
| 4219 | |
| 4220 _BaseZone: {"": "Object;", | |
| 4221 runGuarded$1: function(f) { | |
| 4222 var e, s, t1, exception; | |
| 4223 try { | |
| 4224 t1 = this.run$1(f); | |
| 4225 return t1; | |
| 4226 } catch (exception) { | |
| 4227 t1 = H.unwrapException(exception); | |
| 4228 e = t1; | |
| 4229 s = new H._StackTrace(exception, null); | |
| 4230 return this.handleUncaughtError$2(e, s); | |
| 4231 } | |
| 4232 | |
| 4233 }, | |
| 4234 runUnaryGuarded$2: function(f, arg) { | |
| 4235 var e, s, t1, exception; | |
| 4236 try { | |
| 4237 t1 = this.runUnary$2(f, arg); | |
| 4238 return t1; | |
| 4239 } catch (exception) { | |
| 4240 t1 = H.unwrapException(exception); | |
| 4241 e = t1; | |
| 4242 s = new H._StackTrace(exception, null); | |
| 4243 return this.handleUncaughtError$2(e, s); | |
| 4244 } | |
| 4245 | |
| 4246 }, | |
| 4247 runBinaryGuarded$3: function(f, arg1, arg2) { | |
| 4248 var e, s, t1, exception; | |
| 4249 try { | |
| 4250 t1 = this.runBinary$3(f, arg1, arg2); | |
| 4251 return t1; | |
| 4252 } catch (exception) { | |
| 4253 t1 = H.unwrapException(exception); | |
| 4254 e = t1; | |
| 4255 s = new H._StackTrace(exception, null); | |
| 4256 return this.handleUncaughtError$2(e, s); | |
| 4257 } | |
| 4258 | |
| 4259 }, | |
| 4260 bindCallback$2$runGuarded: function(f, runGuarded) { | |
| 4261 var registered = this.registerCallback$1(f); | |
| 4262 if (runGuarded) | |
| 4263 return new P._BaseZone_bindCallback_closure(this, registered); | |
| 4264 else | |
| 4265 return new P._BaseZone_bindCallback_closure0(this, registered); | |
| 4266 }, | |
| 4267 bindUnaryCallback$2$runGuarded: function(f, runGuarded) { | |
| 4268 var registered = this.registerUnaryCallback$1(f); | |
| 4269 if (runGuarded) | |
| 4270 return new P._BaseZone_bindUnaryCallback_closure(this, registered); | |
| 4271 else | |
| 4272 return new P._BaseZone_bindUnaryCallback_closure0(this, registered); | |
| 4273 } | |
| 4274 }, | |
| 4275 | |
| 4276 _BaseZone_bindCallback_closure: {"": "Closure;this_0,registered_1", | |
| 4277 call$0: function() { | |
| 4278 return this.this_0.runGuarded$1(this.registered_1); | |
| 4279 }, | |
| 4280 "+call:0:0": 0, | |
| 4281 $isFunction: true | |
| 4282 }, | |
| 4283 | |
| 4284 _BaseZone_bindCallback_closure0: {"": "Closure;this_2,registered_3", | |
| 4285 call$0: function() { | |
| 4286 return this.this_2.run$1(this.registered_3); | |
| 4287 }, | |
| 4288 "+call:0:0": 0, | |
| 4289 $isFunction: true | |
| 4290 }, | |
| 4291 | |
| 4292 _BaseZone_bindUnaryCallback_closure: {"": "Closure;this_0,registered_1", | |
| 4293 call$1: function(arg) { | |
| 4294 return this.this_0.runUnaryGuarded$2(this.registered_1, arg); | |
| 4295 }, | |
| 4296 "+call:1:0": 0, | |
| 4297 $isFunction: true, | |
| 4298 $is_args1: true | |
| 4299 }, | |
| 4300 | |
| 4301 _BaseZone_bindUnaryCallback_closure0: {"": "Closure;this_2,registered_3", | |
| 4302 call$1: function(arg) { | |
| 4303 return this.this_2.runUnary$2(this.registered_3, arg); | |
| 4304 }, | |
| 4305 "+call:1:0": 0, | |
| 4306 $isFunction: true, | |
| 4307 $is_args1: true | |
| 4308 }, | |
| 4309 | |
| 4310 _rootHandleUncaughtError_closure: {"": "Closure;error_0,stackTrace_1", | |
| 4311 call$0: function() { | |
| 4312 P._scheduleAsyncCallback(new P._rootHandleUncaughtError__closure(this.error_
0, this.stackTrace_1)); | |
| 4313 }, | |
| 4314 "+call:0:0": 0, | |
| 4315 $isFunction: true | |
| 4316 }, | |
| 4317 | |
| 4318 _rootHandleUncaughtError__closure: {"": "Closure;error_2,stackTrace_3", | |
| 4319 call$0: function() { | |
| 4320 var t1, trace, t2; | |
| 4321 t1 = this.error_2; | |
| 4322 P.print("Uncaught Error: " + H.S(t1)); | |
| 4323 trace = this.stackTrace_3; | |
| 4324 if (trace == null) { | |
| 4325 t2 = J.getInterceptor(t1); | |
| 4326 t2 = typeof t1 === "object" && t1 !== null && !!t2.$isError; | |
| 4327 } else | |
| 4328 t2 = false; | |
| 4329 if (t2) | |
| 4330 trace = t1.get$stackTrace(); | |
| 4331 if (trace != null) | |
| 4332 P.print("Stack Trace: \n" + H.S(trace) + "\n"); | |
| 4333 throw H.wrapException(t1); | |
| 4334 }, | |
| 4335 "+call:0:0": 0, | |
| 4336 $isFunction: true | |
| 4337 }, | |
| 4338 | |
| 4339 _RootZone: {"": "_BaseZone;", | |
| 4340 $index: function(_, key) { | |
| 4341 return; | |
| 4342 }, | |
| 4343 handleUncaughtError$2: function(error, stackTrace) { | |
| 4344 return P._rootHandleUncaughtError(this, null, this, error, stackTrace); | |
| 4345 }, | |
| 4346 run$1: function(f) { | |
| 4347 return P._rootRun(this, null, this, f); | |
| 4348 }, | |
| 4349 runUnary$2: function(f, arg) { | |
| 4350 return P._rootRunUnary(this, null, this, f, arg); | |
| 4351 }, | |
| 4352 runBinary$3: function(f, arg1, arg2) { | |
| 4353 return P._rootRunBinary(this, null, this, f, arg1, arg2); | |
| 4354 }, | |
| 4355 registerCallback$1: function(f) { | |
| 4356 return f; | |
| 4357 }, | |
| 4358 registerUnaryCallback$1: function(f) { | |
| 4359 return f; | |
| 4360 } | |
| 4361 }}], | |
| 4362 ["dart.collection", "dart:collection", , P, { | |
| 4363 _defaultEquals: function(a, b) { | |
| 4364 return J.$eq(a, b); | |
| 4365 }, | |
| 4366 | |
| 4367 _defaultHashCode: function(a) { | |
| 4368 return J.get$hashCode$(a); | |
| 4369 }, | |
| 4370 | |
| 4371 HashMap_HashMap: function(equals, hashCode, isValidKey, $K, $V) { | |
| 4372 var t1 = new P._HashMap(0, null, null, null, null); | |
| 4373 H.setRuntimeTypeInfo(t1, [$K, $V]); | |
| 4374 return t1; | |
| 4375 }, | |
| 4376 | |
| 4377 HashMap_HashMap$identity: function($K, $V) { | |
| 4378 var t1 = new P._IdentityHashMap(0, null, null, null, null); | |
| 4379 H.setRuntimeTypeInfo(t1, [$K, $V]); | |
| 4380 return t1; | |
| 4381 }, | |
| 4382 | |
| 4383 HashSet_HashSet$identity: function($E) { | |
| 4384 var t1 = new P._IdentityHashSet(0, null, null, null, null); | |
| 4385 H.setRuntimeTypeInfo(t1, [$E]); | |
| 4386 return t1; | |
| 4387 }, | |
| 4388 | |
| 4389 _iterableToString: function(iterable) { | |
| 4390 var parts, t1; | |
| 4391 t1 = $.get$_toStringVisiting(); | |
| 4392 if (t1.contains$1(t1, iterable)) | |
| 4393 return "(...)"; | |
| 4394 t1 = $.get$_toStringVisiting(); | |
| 4395 t1.add$1(t1, iterable); | |
| 4396 parts = []; | |
| 4397 try { | |
| 4398 P._iterablePartsToStrings(iterable, parts); | |
| 4399 } finally { | |
| 4400 t1 = $.get$_toStringVisiting(); | |
| 4401 t1.remove$1(t1, iterable); | |
| 4402 } | |
| 4403 t1 = P.StringBuffer$("("); | |
| 4404 t1.writeAll$2(parts, ", "); | |
| 4405 t1.write$1(")"); | |
| 4406 return t1._contents; | |
| 4407 }, | |
| 4408 | |
| 4409 _iterablePartsToStrings: function(iterable, parts) { | |
| 4410 var it, $length, count, next, ultimateString, penultimateString, penultimate,
ultimate, ultimate0, elision; | |
| 4411 it = iterable.get$iterator(iterable); | |
| 4412 $length = 0; | |
| 4413 count = 0; | |
| 4414 while (true) { | |
| 4415 if (!($length < 80 || count < 3)) | |
| 4416 break; | |
| 4417 if (!it.moveNext$0()) | |
| 4418 return; | |
| 4419 next = H.S(it.get$current()); | |
| 4420 parts.push(next); | |
| 4421 $length += next.length + 2; | |
| 4422 ++count; | |
| 4423 } | |
| 4424 if (!it.moveNext$0()) { | |
| 4425 if (count <= 5) | |
| 4426 return; | |
| 4427 if (0 >= parts.length) | |
| 4428 throw H.ioore(parts, 0); | |
| 4429 ultimateString = parts.pop(); | |
| 4430 if (0 >= parts.length) | |
| 4431 throw H.ioore(parts, 0); | |
| 4432 penultimateString = parts.pop(); | |
| 4433 } else { | |
| 4434 penultimate = it.get$current(); | |
| 4435 ++count; | |
| 4436 if (!it.moveNext$0()) { | |
| 4437 if (count <= 4) { | |
| 4438 parts.push(H.S(penultimate)); | |
| 4439 return; | |
| 4440 } | |
| 4441 ultimateString = H.S(penultimate); | |
| 4442 if (0 >= parts.length) | |
| 4443 throw H.ioore(parts, 0); | |
| 4444 penultimateString = parts.pop(); | |
| 4445 $length += ultimateString.length + 2; | |
| 4446 } else { | |
| 4447 ultimate = it.get$current(); | |
| 4448 ++count; | |
| 4449 for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { | |
| 4450 ultimate0 = it.get$current(); | |
| 4451 ++count; | |
| 4452 if (count > 100) { | |
| 4453 while (true) { | |
| 4454 if (!($length > 75 && count > 3)) | |
| 4455 break; | |
| 4456 if (0 >= parts.length) | |
| 4457 throw H.ioore(parts, 0); | |
| 4458 $length -= parts.pop().length + 2; | |
| 4459 --count; | |
| 4460 } | |
| 4461 parts.push("..."); | |
| 4462 return; | |
| 4463 } | |
| 4464 } | |
| 4465 penultimateString = H.S(penultimate); | |
| 4466 ultimateString = H.S(ultimate); | |
| 4467 $length += ultimateString.length + penultimateString.length + 4; | |
| 4468 } | |
| 4469 } | |
| 4470 if (count > parts.length + 2) { | |
| 4471 $length += 5; | |
| 4472 elision = "..."; | |
| 4473 } else | |
| 4474 elision = null; | |
| 4475 while (true) { | |
| 4476 if (!($length > 80 && parts.length > 3)) | |
| 4477 break; | |
| 4478 if (0 >= parts.length) | |
| 4479 throw H.ioore(parts, 0); | |
| 4480 $length -= parts.pop().length + 2; | |
| 4481 if (elision == null) { | |
| 4482 $length += 5; | |
| 4483 elision = "..."; | |
| 4484 } | |
| 4485 } | |
| 4486 if (elision != null) | |
| 4487 parts.push(elision); | |
| 4488 parts.push(penultimateString); | |
| 4489 parts.push(ultimateString); | |
| 4490 }, | |
| 4491 | |
| 4492 LinkedHashMap_LinkedHashMap: function(equals, hashCode, isValidKey, $K, $V) { | |
| 4493 var t1 = new P._LinkedHashMap(0, null, null, null, null, null, 0); | |
| 4494 H.setRuntimeTypeInfo(t1, [$K, $V]); | |
| 4495 return t1; | |
| 4496 }, | |
| 4497 | |
| 4498 Maps_mapToString: function(m) { | |
| 4499 var t1, result, i, t2; | |
| 4500 t1 = {}; | |
| 4501 for (i = 0; i < $.get$Maps__toStringList().length; ++i) { | |
| 4502 t2 = $.get$Maps__toStringList(); | |
| 4503 if (i >= t2.length) | |
| 4504 throw H.ioore(t2, i); | |
| 4505 if (t2[i] === m) | |
| 4506 return "{...}"; | |
| 4507 } | |
| 4508 result = P.StringBuffer$(""); | |
| 4509 try { | |
| 4510 $.get$Maps__toStringList().push(m); | |
| 4511 result.write$1("{"); | |
| 4512 t1.first_0 = true; | |
| 4513 J.forEach$1$ax(m, new P.Maps_mapToString_closure(t1, result)); | |
| 4514 result.write$1("}"); | |
| 4515 } finally { | |
| 4516 t1 = $.get$Maps__toStringList(); | |
| 4517 if (0 >= t1.length) | |
| 4518 throw H.ioore(t1, 0); | |
| 4519 t1.pop(); | |
| 4520 } | |
| 4521 return result.get$_contents(); | |
| 4522 }, | |
| 4523 | |
| 4524 _HashMap: {"": "Object;_collection$_length,_strings,_nums,_rest,_keys", | |
| 4525 get$length: function(_) { | |
| 4526 return this._collection$_length; | |
| 4527 }, | |
| 4528 get$keys: function() { | |
| 4529 var t1 = new P.HashMapKeyIterable(this); | |
| 4530 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_HashMap", 0)]); | |
| 4531 return t1; | |
| 4532 }, | |
| 4533 get$values: function(_) { | |
| 4534 var t1 = new P.HashMapKeyIterable(this); | |
| 4535 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_HashMap", 0)]); | |
| 4536 return H.MappedIterable_MappedIterable(t1, new P._HashMap_values_closure(thi
s), H.getRuntimeTypeArgument(t1, "IterableBase", 0), null); | |
| 4537 }, | |
| 4538 containsKey$1: function(key) { | |
| 4539 var strings, nums, rest; | |
| 4540 if (typeof key === "string" && key !== "__proto__") { | |
| 4541 strings = this._strings; | |
| 4542 return strings == null ? false : strings[key] != null; | |
| 4543 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| 4544 nums = this._nums; | |
| 4545 return nums == null ? false : nums[key] != null; | |
| 4546 } else { | |
| 4547 rest = this._rest; | |
| 4548 if (rest == null) | |
| 4549 return false; | |
| 4550 return this._findBucketIndex$2(rest[this._computeHashCode$1(key)], key) >=
0; | |
| 4551 } | |
| 4552 }, | |
| 4553 $index: function(_, key) { | |
| 4554 var strings, t1, entry, nums, rest, bucket, index; | |
| 4555 if (typeof key === "string" && key !== "__proto__") { | |
| 4556 strings = this._strings; | |
| 4557 if (strings == null) | |
| 4558 t1 = null; | |
| 4559 else { | |
| 4560 entry = strings[key]; | |
| 4561 t1 = entry === strings ? null : entry; | |
| 4562 } | |
| 4563 return t1; | |
| 4564 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| 4565 nums = this._nums; | |
| 4566 if (nums == null) | |
| 4567 t1 = null; | |
| 4568 else { | |
| 4569 entry = nums[key]; | |
| 4570 t1 = entry === nums ? null : entry; | |
| 4571 } | |
| 4572 return t1; | |
| 4573 } else { | |
| 4574 rest = this._rest; | |
| 4575 if (rest == null) | |
| 4576 return; | |
| 4577 bucket = rest[this._computeHashCode$1(key)]; | |
| 4578 index = this._findBucketIndex$2(bucket, key); | |
| 4579 return index < 0 ? null : bucket[index + 1]; | |
| 4580 } | |
| 4581 }, | |
| 4582 $indexSet: function(_, key, value) { | |
| 4583 var strings, nums, rest, hash, bucket, index; | |
| 4584 if (typeof key === "string" && key !== "__proto__") { | |
| 4585 strings = this._strings; | |
| 4586 if (strings == null) { | |
| 4587 strings = P._HashMap__newHashTable(); | |
| 4588 this._strings = strings; | |
| 4589 } | |
| 4590 this._addHashTableEntry$3(strings, key, value); | |
| 4591 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| 4592 nums = this._nums; | |
| 4593 if (nums == null) { | |
| 4594 nums = P._HashMap__newHashTable(); | |
| 4595 this._nums = nums; | |
| 4596 } | |
| 4597 this._addHashTableEntry$3(nums, key, value); | |
| 4598 } else { | |
| 4599 rest = this._rest; | |
| 4600 if (rest == null) { | |
| 4601 rest = P._HashMap__newHashTable(); | |
| 4602 this._rest = rest; | |
| 4603 } | |
| 4604 hash = this._computeHashCode$1(key); | |
| 4605 bucket = rest[hash]; | |
| 4606 if (bucket == null) { | |
| 4607 P._HashMap__setTableEntry(rest, hash, [key, value]); | |
| 4608 this._collection$_length = this._collection$_length + 1; | |
| 4609 this._keys = null; | |
| 4610 } else { | |
| 4611 index = this._findBucketIndex$2(bucket, key); | |
| 4612 if (index >= 0) | |
| 4613 bucket[index + 1] = value; | |
| 4614 else { | |
| 4615 bucket.push(key, value); | |
| 4616 this._collection$_length = this._collection$_length + 1; | |
| 4617 this._keys = null; | |
| 4618 } | |
| 4619 } | |
| 4620 } | |
| 4621 }, | |
| 4622 forEach$1: function(_, action) { | |
| 4623 var keys, $length, i, key; | |
| 4624 keys = this._computeKeys$0(); | |
| 4625 for ($length = keys.length, i = 0; i < $length; ++i) { | |
| 4626 key = keys[i]; | |
| 4627 action.call$2(key, this.$index(this, key)); | |
| 4628 if (keys !== this._keys) | |
| 4629 throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| 4630 } | |
| 4631 }, | |
| 4632 _computeKeys$0: function() { | |
| 4633 var t1, result, strings, names, entries, index, i, nums, rest, bucket, $leng
th, i0; | |
| 4634 t1 = this._keys; | |
| 4635 if (t1 != null) | |
| 4636 return t1; | |
| 4637 result = P.List_List(this._collection$_length, null); | |
| 4638 strings = this._strings; | |
| 4639 if (strings != null) { | |
| 4640 names = Object.getOwnPropertyNames(strings); | |
| 4641 entries = names.length; | |
| 4642 for (index = 0, i = 0; i < entries; ++i) { | |
| 4643 result[index] = names[i]; | |
| 4644 ++index; | |
| 4645 } | |
| 4646 } else | |
| 4647 index = 0; | |
| 4648 nums = this._nums; | |
| 4649 if (nums != null) { | |
| 4650 names = Object.getOwnPropertyNames(nums); | |
| 4651 entries = names.length; | |
| 4652 for (i = 0; i < entries; ++i) { | |
| 4653 result[index] = +names[i]; | |
| 4654 ++index; | |
| 4655 } | |
| 4656 } | |
| 4657 rest = this._rest; | |
| 4658 if (rest != null) { | |
| 4659 names = Object.getOwnPropertyNames(rest); | |
| 4660 entries = names.length; | |
| 4661 for (i = 0; i < entries; ++i) { | |
| 4662 bucket = rest[names[i]]; | |
| 4663 $length = bucket.length; | |
| 4664 for (i0 = 0; i0 < $length; i0 += 2) { | |
| 4665 result[index] = bucket[i0]; | |
| 4666 ++index; | |
| 4667 } | |
| 4668 } | |
| 4669 } | |
| 4670 this._keys = result; | |
| 4671 return result; | |
| 4672 }, | |
| 4673 _addHashTableEntry$3: function(table, key, value) { | |
| 4674 if (table[key] == null) { | |
| 4675 this._collection$_length = this._collection$_length + 1; | |
| 4676 this._keys = null; | |
| 4677 } | |
| 4678 P._HashMap__setTableEntry(table, key, value); | |
| 4679 }, | |
| 4680 _computeHashCode$1: function(key) { | |
| 4681 return J.get$hashCode$(key) & 0x3ffffff; | |
| 4682 }, | |
| 4683 _findBucketIndex$2: function(bucket, key) { | |
| 4684 var $length, i; | |
| 4685 if (bucket == null) | |
| 4686 return -1; | |
| 4687 $length = bucket.length; | |
| 4688 for (i = 0; i < $length; i += 2) | |
| 4689 if (J.$eq(bucket[i], key)) | |
| 4690 return i; | |
| 4691 return -1; | |
| 4692 }, | |
| 4693 $isMap: true, | |
| 4694 static: { | |
| 4695 _HashMap__setTableEntry: function(table, key, value) { | |
| 4696 if (value == null) | |
| 4697 table[key] = table; | |
| 4698 else | |
| 4699 table[key] = value; | |
| 4700 }, | |
| 4701 | |
| 4702 _HashMap__newHashTable: function() { | |
| 4703 var table = Object.create(null); | |
| 4704 P._HashMap__setTableEntry(table, "<non-identifier-key>", table); | |
| 4705 delete table["<non-identifier-key>"]; | |
| 4706 return table; | |
| 4707 }} | |
| 4708 | |
| 4709 }, | |
| 4710 | |
| 4711 _HashMap_values_closure: {"": "Closure;this_0", | |
| 4712 call$1: function(each) { | |
| 4713 var t1 = this.this_0; | |
| 4714 return t1.$index(t1, each); | |
| 4715 }, | |
| 4716 "+call:1:0": 0, | |
| 4717 $isFunction: true, | |
| 4718 $is_args1: true | |
| 4719 }, | |
| 4720 | |
| 4721 _IdentityHashMap: {"": "_HashMap;_collection$_length,_strings,_nums,_rest,_keys"
, | |
| 4722 _computeHashCode$1: function(key) { | |
| 4723 return H.objectHashCode(key) & 0x3ffffff; | |
| 4724 }, | |
| 4725 _findBucketIndex$2: function(bucket, key) { | |
| 4726 var $length, i, t1; | |
| 4727 if (bucket == null) | |
| 4728 return -1; | |
| 4729 $length = bucket.length; | |
| 4730 for (i = 0; i < $length; i += 2) { | |
| 4731 t1 = bucket[i]; | |
| 4732 if (t1 == null ? key == null : t1 === key) | |
| 4733 return i; | |
| 4734 } | |
| 4735 return -1; | |
| 4736 }, | |
| 4737 $as_HashMap: null, | |
| 4738 $asMap: null | |
| 4739 }, | |
| 4740 | |
| 4741 HashMapKeyIterable: {"": "IterableBase;_map", | |
| 4742 get$length: function(_) { | |
| 4743 return this._map._collection$_length; | |
| 4744 }, | |
| 4745 get$iterator: function(_) { | |
| 4746 var t1 = this._map; | |
| 4747 return new P.HashMapKeyIterator(t1, t1._computeKeys$0(), 0, null); | |
| 4748 }, | |
| 4749 forEach$1: function(_, f) { | |
| 4750 var t1, keys, $length, i; | |
| 4751 t1 = this._map; | |
| 4752 keys = t1._computeKeys$0(); | |
| 4753 for ($length = keys.length, i = 0; i < $length; ++i) { | |
| 4754 f.call$1(keys[i]); | |
| 4755 if (keys !== t1._keys) | |
| 4756 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 4757 } | |
| 4758 }, | |
| 4759 $asIterableBase: null, | |
| 4760 $asIterable: null, | |
| 4761 $isEfficientLength: true | |
| 4762 }, | |
| 4763 | |
| 4764 HashMapKeyIterator: {"": "Object;_map,_keys,_offset,_collection$_current", | |
| 4765 get$current: function() { | |
| 4766 return this._collection$_current; | |
| 4767 }, | |
| 4768 moveNext$0: function() { | |
| 4769 var keys, offset, t1; | |
| 4770 keys = this._keys; | |
| 4771 offset = this._offset; | |
| 4772 t1 = this._map; | |
| 4773 if (keys !== t1._keys) | |
| 4774 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 4775 else if (offset >= keys.length) { | |
| 4776 this._collection$_current = null; | |
| 4777 return false; | |
| 4778 } else { | |
| 4779 this._collection$_current = keys[offset]; | |
| 4780 this._offset = offset + 1; | |
| 4781 return true; | |
| 4782 } | |
| 4783 } | |
| 4784 }, | |
| 4785 | |
| 4786 _LinkedHashMap: {"": "Object;_collection$_length,_strings,_nums,_rest,_first,_la
st,_modifications", | |
| 4787 get$length: function(_) { | |
| 4788 return this._collection$_length; | |
| 4789 }, | |
| 4790 get$isEmpty: function(_) { | |
| 4791 return this._collection$_length === 0; | |
| 4792 }, | |
| 4793 get$keys: function() { | |
| 4794 var t1 = new P.LinkedHashMapKeyIterable(this); | |
| 4795 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_LinkedHashMap", 0
)]); | |
| 4796 return t1; | |
| 4797 }, | |
| 4798 get$values: function(_) { | |
| 4799 var t1 = new P.LinkedHashMapKeyIterable(this); | |
| 4800 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_LinkedHashMap", 0
)]); | |
| 4801 return H.MappedIterable_MappedIterable(t1, new P._LinkedHashMap_values_closu
re(this), H.getRuntimeTypeArgument(t1, "IterableBase", 0), null); | |
| 4802 }, | |
| 4803 containsKey$1: function(key) { | |
| 4804 var nums, rest; | |
| 4805 if ((key & 0x3ffffff) === key) { | |
| 4806 nums = this._nums; | |
| 4807 if (nums == null) | |
| 4808 return false; | |
| 4809 return nums[key] != null; | |
| 4810 } else { | |
| 4811 rest = this._rest; | |
| 4812 if (rest == null) | |
| 4813 return false; | |
| 4814 return this._findBucketIndex$2(rest[this._computeHashCode$1(key)], key) >=
0; | |
| 4815 } | |
| 4816 }, | |
| 4817 $index: function(_, key) { | |
| 4818 var strings, cell, nums, rest, bucket, index; | |
| 4819 if (typeof key === "string" && key !== "__proto__") { | |
| 4820 strings = this._strings; | |
| 4821 if (strings == null) | |
| 4822 return; | |
| 4823 cell = strings[key]; | |
| 4824 return cell == null ? null : cell.get$_collection$_value(); | |
| 4825 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| 4826 nums = this._nums; | |
| 4827 if (nums == null) | |
| 4828 return; | |
| 4829 cell = nums[key]; | |
| 4830 return cell == null ? null : cell.get$_collection$_value(); | |
| 4831 } else { | |
| 4832 rest = this._rest; | |
| 4833 if (rest == null) | |
| 4834 return; | |
| 4835 bucket = rest[this._computeHashCode$1(key)]; | |
| 4836 index = this._findBucketIndex$2(bucket, key); | |
| 4837 if (index < 0) | |
| 4838 return; | |
| 4839 return bucket[index].get$_collection$_value(); | |
| 4840 } | |
| 4841 }, | |
| 4842 $indexSet: function(_, key, value) { | |
| 4843 var strings, nums, rest, hash, bucket, index; | |
| 4844 if (typeof key === "string" && key !== "__proto__") { | |
| 4845 strings = this._strings; | |
| 4846 if (strings == null) { | |
| 4847 strings = P._LinkedHashMap__newHashTable(); | |
| 4848 this._strings = strings; | |
| 4849 } | |
| 4850 this._addHashTableEntry$3(strings, key, value); | |
| 4851 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
| 4852 nums = this._nums; | |
| 4853 if (nums == null) { | |
| 4854 nums = P._LinkedHashMap__newHashTable(); | |
| 4855 this._nums = nums; | |
| 4856 } | |
| 4857 this._addHashTableEntry$3(nums, key, value); | |
| 4858 } else { | |
| 4859 rest = this._rest; | |
| 4860 if (rest == null) { | |
| 4861 rest = P._LinkedHashMap__newHashTable(); | |
| 4862 this._rest = rest; | |
| 4863 } | |
| 4864 hash = this._computeHashCode$1(key); | |
| 4865 bucket = rest[hash]; | |
| 4866 if (bucket == null) | |
| 4867 rest[hash] = [this._newLinkedCell$2(key, value)]; | |
| 4868 else { | |
| 4869 index = this._findBucketIndex$2(bucket, key); | |
| 4870 if (index >= 0) | |
| 4871 bucket[index].set$_collection$_value(value); | |
| 4872 else | |
| 4873 bucket.push(this._newLinkedCell$2(key, value)); | |
| 4874 } | |
| 4875 } | |
| 4876 }, | |
| 4877 remove$1: function(_, key) { | |
| 4878 var rest, bucket, index, cell; | |
| 4879 if (typeof key === "string" && key !== "__proto__") | |
| 4880 return this._removeHashTableEntry$2(this._strings, key); | |
| 4881 else if (typeof key === "number" && (key & 0x3ffffff) === key) | |
| 4882 return this._removeHashTableEntry$2(this._nums, key); | |
| 4883 else { | |
| 4884 rest = this._rest; | |
| 4885 if (rest == null) | |
| 4886 return; | |
| 4887 bucket = rest[this._computeHashCode$1(key)]; | |
| 4888 index = this._findBucketIndex$2(bucket, key); | |
| 4889 if (index < 0) | |
| 4890 return; | |
| 4891 cell = bucket.splice(index, 1)[0]; | |
| 4892 this._unlinkCell$1(cell); | |
| 4893 return cell.get$_collection$_value(); | |
| 4894 } | |
| 4895 }, | |
| 4896 forEach$1: function(_, action) { | |
| 4897 var cell, modifications; | |
| 4898 cell = this._first; | |
| 4899 modifications = this._modifications; | |
| 4900 for (; cell != null;) { | |
| 4901 action.call$2(cell._key, cell._collection$_value); | |
| 4902 if (modifications !== this._modifications) | |
| 4903 throw H.wrapException(P.ConcurrentModificationError$(this)); | |
| 4904 cell = cell._next; | |
| 4905 } | |
| 4906 }, | |
| 4907 _addHashTableEntry$3: function(table, key, value) { | |
| 4908 var cell = table[key]; | |
| 4909 if (cell == null) | |
| 4910 table[key] = this._newLinkedCell$2(key, value); | |
| 4911 else | |
| 4912 cell.set$_collection$_value(value); | |
| 4913 }, | |
| 4914 _removeHashTableEntry$2: function(table, key) { | |
| 4915 var cell; | |
| 4916 if (table == null) | |
| 4917 return; | |
| 4918 cell = table[key]; | |
| 4919 if (cell == null) | |
| 4920 return; | |
| 4921 this._unlinkCell$1(cell); | |
| 4922 delete table[key]; | |
| 4923 return cell.get$_collection$_value(); | |
| 4924 }, | |
| 4925 _newLinkedCell$2: function(key, value) { | |
| 4926 var cell, last; | |
| 4927 cell = new P.LinkedHashMapCell(key, value, null, null); | |
| 4928 if (this._first == null) { | |
| 4929 this._last = cell; | |
| 4930 this._first = cell; | |
| 4931 } else { | |
| 4932 last = this._last; | |
| 4933 cell._previous = last; | |
| 4934 last._next = cell; | |
| 4935 this._last = cell; | |
| 4936 } | |
| 4937 this._collection$_length = this._collection$_length + 1; | |
| 4938 this._modifications = this._modifications + 1 & 67108863; | |
| 4939 return cell; | |
| 4940 }, | |
| 4941 _unlinkCell$1: function(cell) { | |
| 4942 var previous, next; | |
| 4943 previous = cell.get$_previous(); | |
| 4944 next = cell.get$_next(); | |
| 4945 if (previous == null) | |
| 4946 this._first = next; | |
| 4947 else | |
| 4948 previous._next = next; | |
| 4949 if (next == null) | |
| 4950 this._last = previous; | |
| 4951 else | |
| 4952 next._previous = previous; | |
| 4953 this._collection$_length = this._collection$_length - 1; | |
| 4954 this._modifications = this._modifications + 1 & 67108863; | |
| 4955 }, | |
| 4956 _computeHashCode$1: function(key) { | |
| 4957 return J.get$hashCode$(key) & 0x3ffffff; | |
| 4958 }, | |
| 4959 _findBucketIndex$2: function(bucket, key) { | |
| 4960 var $length, i; | |
| 4961 if (bucket == null) | |
| 4962 return -1; | |
| 4963 $length = bucket.length; | |
| 4964 for (i = 0; i < $length; ++i) | |
| 4965 if (J.$eq(bucket[i].get$_key(), key)) | |
| 4966 return i; | |
| 4967 return -1; | |
| 4968 }, | |
| 4969 toString$0: function(_) { | |
| 4970 return P.Maps_mapToString(this); | |
| 4971 }, | |
| 4972 $isMap: true, | |
| 4973 static: { | |
| 4974 _LinkedHashMap__newHashTable: function() { | |
| 4975 var table = Object.create(null); | |
| 4976 table["<non-identifier-key>"] = table; | |
| 4977 delete table["<non-identifier-key>"]; | |
| 4978 return table; | |
| 4979 }} | |
| 4980 | |
| 4981 }, | |
| 4982 | |
| 4983 _LinkedHashMap_values_closure: {"": "Closure;this_0", | |
| 4984 call$1: function(each) { | |
| 4985 var t1 = this.this_0; | |
| 4986 return t1.$index(t1, each); | |
| 4987 }, | |
| 4988 "+call:1:0": 0, | |
| 4989 $isFunction: true, | |
| 4990 $is_args1: true | |
| 4991 }, | |
| 4992 | |
| 4993 LinkedHashMapCell: {"": "Object;_key<,_collection$_value@,_next<,_previous<"}, | |
| 4994 | |
| 4995 LinkedHashMapKeyIterable: {"": "IterableBase;_map", | |
| 4996 get$length: function(_) { | |
| 4997 return this._map._collection$_length; | |
| 4998 }, | |
| 4999 get$iterator: function(_) { | |
| 5000 var t1 = this._map; | |
| 5001 t1 = new P.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); | |
| 5002 t1._cell = t1._map._first; | |
| 5003 return t1; | |
| 5004 }, | |
| 5005 forEach$1: function(_, f) { | |
| 5006 var t1, cell, modifications; | |
| 5007 t1 = this._map; | |
| 5008 cell = t1._first; | |
| 5009 modifications = t1._modifications; | |
| 5010 for (; cell != null;) { | |
| 5011 f.call$1(cell._key); | |
| 5012 if (modifications !== t1._modifications) | |
| 5013 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 5014 cell = cell._next; | |
| 5015 } | |
| 5016 }, | |
| 5017 $asIterableBase: null, | |
| 5018 $asIterable: null, | |
| 5019 $isEfficientLength: true | |
| 5020 }, | |
| 5021 | |
| 5022 LinkedHashMapKeyIterator: {"": "Object;_map,_modifications,_cell,_collection$_cu
rrent", | |
| 5023 get$current: function() { | |
| 5024 return this._collection$_current; | |
| 5025 }, | |
| 5026 moveNext$0: function() { | |
| 5027 var t1 = this._map; | |
| 5028 if (this._modifications !== t1._modifications) | |
| 5029 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 5030 else { | |
| 5031 t1 = this._cell; | |
| 5032 if (t1 == null) { | |
| 5033 this._collection$_current = null; | |
| 5034 return false; | |
| 5035 } else { | |
| 5036 this._collection$_current = t1._key; | |
| 5037 this._cell = this._cell._next; | |
| 5038 return true; | |
| 5039 } | |
| 5040 } | |
| 5041 } | |
| 5042 }, | |
| 5043 | |
| 5044 _HashSet: {"": "_HashSetBase;", | |
| 5045 get$iterator: function(_) { | |
| 5046 return new P.HashSetIterator(this, this._computeElements$0(), 0, null); | |
| 5047 }, | |
| 5048 get$length: function(_) { | |
| 5049 return this._collection$_length; | |
| 5050 }, | |
| 5051 contains$1: function(_, object) { | |
| 5052 var strings, nums, rest; | |
| 5053 if (typeof object === "string" && object !== "__proto__") { | |
| 5054 strings = this._strings; | |
| 5055 return strings == null ? false : strings[object] != null; | |
| 5056 } else if (typeof object === "number" && (object & 0x3ffffff) === object) { | |
| 5057 nums = this._nums; | |
| 5058 return nums == null ? false : nums[object] != null; | |
| 5059 } else { | |
| 5060 rest = this._rest; | |
| 5061 if (rest == null) | |
| 5062 return false; | |
| 5063 return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], obje
ct) >= 0; | |
| 5064 } | |
| 5065 }, | |
| 5066 lookup$1: function(object) { | |
| 5067 var t1, rest, bucket, index; | |
| 5068 if (!(typeof object === "string" && object !== "__proto__")) | |
| 5069 t1 = typeof object === "number" && (object & 0x3ffffff) === object; | |
| 5070 else | |
| 5071 t1 = true; | |
| 5072 if (t1) | |
| 5073 return this.contains$1(this, object) ? object : null; | |
| 5074 rest = this._rest; | |
| 5075 if (rest == null) | |
| 5076 return; | |
| 5077 bucket = rest[this._computeHashCode$1(object)]; | |
| 5078 index = this._findBucketIndex$2(bucket, object); | |
| 5079 if (index < 0) | |
| 5080 return; | |
| 5081 return J.$index$asx(bucket, index); | |
| 5082 }, | |
| 5083 add$1: function(_, element) { | |
| 5084 var rest, table, hash, bucket; | |
| 5085 rest = this._rest; | |
| 5086 if (rest == null) { | |
| 5087 table = Object.create(null); | |
| 5088 table["<non-identifier-key>"] = table; | |
| 5089 delete table["<non-identifier-key>"]; | |
| 5090 this._rest = table; | |
| 5091 rest = table; | |
| 5092 } | |
| 5093 hash = this._computeHashCode$1(element); | |
| 5094 bucket = rest[hash]; | |
| 5095 if (bucket == null) | |
| 5096 rest[hash] = [element]; | |
| 5097 else { | |
| 5098 if (this._findBucketIndex$2(bucket, element) >= 0) | |
| 5099 return false; | |
| 5100 bucket.push(element); | |
| 5101 } | |
| 5102 this._collection$_length = this._collection$_length + 1; | |
| 5103 this._elements = null; | |
| 5104 return true; | |
| 5105 }, | |
| 5106 remove$1: function(_, object) { | |
| 5107 var rest, bucket, index; | |
| 5108 rest = this._rest; | |
| 5109 if (rest == null) | |
| 5110 return false; | |
| 5111 bucket = rest[this._computeHashCode$1(object)]; | |
| 5112 index = this._findBucketIndex$2(bucket, object); | |
| 5113 if (index < 0) | |
| 5114 return false; | |
| 5115 this._collection$_length = this._collection$_length - 1; | |
| 5116 this._elements = null; | |
| 5117 bucket.splice(index, 1); | |
| 5118 return true; | |
| 5119 }, | |
| 5120 _computeElements$0: function() { | |
| 5121 var t1, result, strings, names, entries, index, i, nums, rest, bucket, $leng
th, i0; | |
| 5122 t1 = this._elements; | |
| 5123 if (t1 != null) | |
| 5124 return t1; | |
| 5125 result = P.List_List(this._collection$_length, null); | |
| 5126 strings = this._strings; | |
| 5127 if (strings != null) { | |
| 5128 names = Object.getOwnPropertyNames(strings); | |
| 5129 entries = names.length; | |
| 5130 for (index = 0, i = 0; i < entries; ++i) { | |
| 5131 result[index] = names[i]; | |
| 5132 ++index; | |
| 5133 } | |
| 5134 } else | |
| 5135 index = 0; | |
| 5136 nums = this._nums; | |
| 5137 if (nums != null) { | |
| 5138 names = Object.getOwnPropertyNames(nums); | |
| 5139 entries = names.length; | |
| 5140 for (i = 0; i < entries; ++i) { | |
| 5141 result[index] = +names[i]; | |
| 5142 ++index; | |
| 5143 } | |
| 5144 } | |
| 5145 rest = this._rest; | |
| 5146 if (rest != null) { | |
| 5147 names = Object.getOwnPropertyNames(rest); | |
| 5148 entries = names.length; | |
| 5149 for (i = 0; i < entries; ++i) { | |
| 5150 bucket = rest[names[i]]; | |
| 5151 $length = bucket.length; | |
| 5152 for (i0 = 0; i0 < $length; ++i0) { | |
| 5153 result[index] = bucket[i0]; | |
| 5154 ++index; | |
| 5155 } | |
| 5156 } | |
| 5157 } | |
| 5158 this._elements = result; | |
| 5159 return result; | |
| 5160 }, | |
| 5161 _computeHashCode$1: function(element) { | |
| 5162 return J.get$hashCode$(element) & 0x3ffffff; | |
| 5163 }, | |
| 5164 _findBucketIndex$2: function(bucket, element) { | |
| 5165 var $length, i; | |
| 5166 if (bucket == null) | |
| 5167 return -1; | |
| 5168 $length = bucket.length; | |
| 5169 for (i = 0; i < $length; ++i) | |
| 5170 if (J.$eq(bucket[i], element)) | |
| 5171 return i; | |
| 5172 return -1; | |
| 5173 }, | |
| 5174 $as_HashSetBase: null, | |
| 5175 $asIterable: null, | |
| 5176 $isEfficientLength: true, | |
| 5177 $isIterable: true | |
| 5178 }, | |
| 5179 | |
| 5180 _IdentityHashSet: {"": "_HashSet;_collection$_length,_strings,_nums,_rest,_eleme
nts", | |
| 5181 _computeHashCode$1: function(key) { | |
| 5182 return H.objectHashCode(key) & 0x3ffffff; | |
| 5183 }, | |
| 5184 _findBucketIndex$2: function(bucket, element) { | |
| 5185 var $length, i, t1; | |
| 5186 if (bucket == null) | |
| 5187 return -1; | |
| 5188 $length = bucket.length; | |
| 5189 for (i = 0; i < $length; ++i) { | |
| 5190 t1 = bucket[i]; | |
| 5191 if (t1 == null ? element == null : t1 === element) | |
| 5192 return i; | |
| 5193 } | |
| 5194 return -1; | |
| 5195 }, | |
| 5196 $as_HashSet: null, | |
| 5197 $asIterable: null | |
| 5198 }, | |
| 5199 | |
| 5200 HashSetIterator: {"": "Object;_set,_elements,_offset,_collection$_current", | |
| 5201 get$current: function() { | |
| 5202 return this._collection$_current; | |
| 5203 }, | |
| 5204 moveNext$0: function() { | |
| 5205 var elements, offset, t1; | |
| 5206 elements = this._elements; | |
| 5207 offset = this._offset; | |
| 5208 t1 = this._set; | |
| 5209 if (elements !== t1._elements) | |
| 5210 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
| 5211 else if (offset >= elements.length) { | |
| 5212 this._collection$_current = null; | |
| 5213 return false; | |
| 5214 } else { | |
| 5215 this._collection$_current = elements[offset]; | |
| 5216 this._offset = offset + 1; | |
| 5217 return true; | |
| 5218 } | |
| 5219 } | |
| 5220 }, | |
| 5221 | |
| 5222 _HashSetBase: {"": "IterableBase;", | |
| 5223 toString$0: function(_) { | |
| 5224 return H.IterableMixinWorkaround_toStringIterable(this, "{", "}"); | |
| 5225 }, | |
| 5226 $asIterableBase: null, | |
| 5227 $asIterable: null, | |
| 5228 $isEfficientLength: true, | |
| 5229 $isIterable: true | |
| 5230 }, | |
| 5231 | |
| 5232 IterableBase: {"": "Object;", | |
| 5233 map$1: function(_, f) { | |
| 5234 return H.MappedIterable_MappedIterable(this, f, H.getRuntimeTypeArgument(thi
s, "IterableBase", 0), null); | |
| 5235 }, | |
| 5236 forEach$1: function(_, f) { | |
| 5237 var t1; | |
| 5238 for (t1 = this.get$iterator(this); t1.moveNext$0();) | |
| 5239 f.call$1(t1.get$current()); | |
| 5240 }, | |
| 5241 get$length: function(_) { | |
| 5242 var it, count; | |
| 5243 it = this.get$iterator(this); | |
| 5244 for (count = 0; it.moveNext$0();) | |
| 5245 ++count; | |
| 5246 return count; | |
| 5247 }, | |
| 5248 elementAt$1: function(_, index) { | |
| 5249 var t1, remaining, element, t2; | |
| 5250 if (typeof index !== "number" || Math.floor(index) !== index || index < 0) | |
| 5251 throw H.wrapException(P.RangeError$value(index)); | |
| 5252 for (t1 = this.get$iterator(this), remaining = index; t1.moveNext$0();) { | |
| 5253 element = t1.get$current(); | |
| 5254 t2 = J.getInterceptor(remaining); | |
| 5255 if (t2.$eq(remaining, 0)) | |
| 5256 return element; | |
| 5257 remaining = t2.$sub(remaining, 1); | |
| 5258 } | |
| 5259 throw H.wrapException(P.RangeError$value(index)); | |
| 5260 }, | |
| 5261 toString$0: function(_) { | |
| 5262 return P._iterableToString(this); | |
| 5263 }, | |
| 5264 $isIterable: true, | |
| 5265 $asIterable: null | |
| 5266 }, | |
| 5267 | |
| 5268 ListMixin: {"": "Object;", | |
| 5269 get$iterator: function(receiver) { | |
| 5270 return new H.ListIterator(receiver, this.get$length(receiver), 0, null); | |
| 5271 }, | |
| 5272 elementAt$1: function(receiver, index) { | |
| 5273 return this.$index(receiver, index); | |
| 5274 }, | |
| 5275 forEach$1: function(receiver, action) { | |
| 5276 var $length, i; | |
| 5277 $length = this.get$length(receiver); | |
| 5278 if (typeof $length !== "number") | |
| 5279 throw H.iae($length); | |
| 5280 i = 0; | |
| 5281 for (; i < $length; ++i) { | |
| 5282 action.call$1(this.$index(receiver, i)); | |
| 5283 if ($length !== this.get$length(receiver)) | |
| 5284 throw H.wrapException(P.ConcurrentModificationError$(receiver)); | |
| 5285 } | |
| 5286 }, | |
| 5287 map$1: function(receiver, f) { | |
| 5288 var t1 = new H.MappedListIterable(receiver, f); | |
| 5289 H.setRuntimeTypeInfo(t1, [null, null]); | |
| 5290 return t1; | |
| 5291 }, | |
| 5292 toString$0: function(receiver) { | |
| 5293 var result, t1; | |
| 5294 t1 = $.get$_toStringVisiting(); | |
| 5295 if (t1.contains$1(t1, receiver)) | |
| 5296 return "[...]"; | |
| 5297 result = P.StringBuffer$(""); | |
| 5298 try { | |
| 5299 t1 = $.get$_toStringVisiting(); | |
| 5300 t1.add$1(t1, receiver); | |
| 5301 result.write$1("["); | |
| 5302 result.writeAll$2(receiver, ", "); | |
| 5303 result.write$1("]"); | |
| 5304 } finally { | |
| 5305 t1 = $.get$_toStringVisiting(); | |
| 5306 t1.remove$1(t1, receiver); | |
| 5307 } | |
| 5308 return result.get$_contents(); | |
| 5309 }, | |
| 5310 $isList: true, | |
| 5311 $asList: null, | |
| 5312 $isEfficientLength: true, | |
| 5313 $isIterable: true, | |
| 5314 $asIterable: null | |
| 5315 }, | |
| 5316 | |
| 5317 Maps_mapToString_closure: {"": "Closure;box_0,result_1", | |
| 5318 call$2: function(k, v) { | |
| 5319 var t1 = this.box_0; | |
| 5320 if (!t1.first_0) | |
| 5321 this.result_1.write$1(", "); | |
| 5322 t1.first_0 = false; | |
| 5323 t1 = this.result_1; | |
| 5324 t1.write$1(k); | |
| 5325 t1.write$1(": "); | |
| 5326 t1.write$1(v); | |
| 5327 }, | |
| 5328 "+call:2:0": 0, | |
| 5329 $isFunction: true, | |
| 5330 $is_args2: true | |
| 5331 }, | |
| 5332 | |
| 5333 ListQueue: {"": "IterableBase;_table,_head,_tail,_modificationCount", | |
| 5334 get$iterator: function(_) { | |
| 5335 return P._ListQueueIterator$(this); | |
| 5336 }, | |
| 5337 forEach$1: function(_, action) { | |
| 5338 var modificationCount, i, t1; | |
| 5339 modificationCount = this._modificationCount; | |
| 5340 for (i = this._head; i !== this._tail; i = (i + 1 & this._table.length - 1)
>>> 0) { | |
| 5341 t1 = this._table; | |
| 5342 if (i < 0 || i >= t1.length) | |
| 5343 throw H.ioore(t1, i); | |
| 5344 action.call$1(t1[i]); | |
| 5345 if (modificationCount !== this._modificationCount) | |
| 5346 H.throwExpression(P.ConcurrentModificationError$(this)); | |
| 5347 } | |
| 5348 }, | |
| 5349 get$length: function(_) { | |
| 5350 return (this._tail - this._head & this._table.length - 1) >>> 0; | |
| 5351 }, | |
| 5352 toString$0: function(_) { | |
| 5353 return H.IterableMixinWorkaround_toStringIterable(this, "{", "}"); | |
| 5354 }, | |
| 5355 removeFirst$0: function() { | |
| 5356 var t1, t2, t3, result; | |
| 5357 if (this._head === this._tail) | |
| 5358 throw H.wrapException(P.StateError$("No elements")); | |
| 5359 this._modificationCount = this._modificationCount + 1; | |
| 5360 t1 = this._table; | |
| 5361 t2 = this._head; | |
| 5362 t3 = t1.length; | |
| 5363 if (t2 < 0 || t2 >= t3) | |
| 5364 throw H.ioore(t1, t2); | |
| 5365 result = t1[t2]; | |
| 5366 this._head = (t2 + 1 & t3 - 1) >>> 0; | |
| 5367 return result; | |
| 5368 }, | |
| 5369 _add$1: function(element) { | |
| 5370 var t1, t2, t3; | |
| 5371 t1 = this._table; | |
| 5372 t2 = this._tail; | |
| 5373 t3 = t1.length; | |
| 5374 if (t2 < 0 || t2 >= t3) | |
| 5375 throw H.ioore(t1, t2); | |
| 5376 t1[t2] = element; | |
| 5377 this._tail = (t2 + 1 & t3 - 1) >>> 0; | |
| 5378 if (this._head === this._tail) | |
| 5379 this._grow$0(); | |
| 5380 this._modificationCount = this._modificationCount + 1; | |
| 5381 }, | |
| 5382 _grow$0: function() { | |
| 5383 var newTable, t1, t2, split; | |
| 5384 newTable = P.List_List(this._table.length * 2, H.getRuntimeTypeArgument(this
, "ListQueue", 0)); | |
| 5385 H.setRuntimeTypeInfo(newTable, [H.getRuntimeTypeArgument(this, "ListQueue",
0)]); | |
| 5386 t1 = this._table; | |
| 5387 t2 = this._head; | |
| 5388 split = t1.length - t2; | |
| 5389 H.IterableMixinWorkaround_setRangeList(newTable, 0, split, t1, t2); | |
| 5390 t1 = this._head; | |
| 5391 t2 = this._table; | |
| 5392 H.IterableMixinWorkaround_setRangeList(newTable, split, split + t1, t2, 0); | |
| 5393 this._head = 0; | |
| 5394 this._tail = this._table.length; | |
| 5395 this._table = newTable; | |
| 5396 }, | |
| 5397 ListQueue$1: function(initialCapacity, $E) { | |
| 5398 var t1 = P.List_List(8, $E); | |
| 5399 H.setRuntimeTypeInfo(t1, [$E]); | |
| 5400 this._table = t1; | |
| 5401 }, | |
| 5402 $asIterableBase: null, | |
| 5403 $asIterable: null, | |
| 5404 $isEfficientLength: true, | |
| 5405 $isIterable: true, | |
| 5406 static: { | |
| 5407 "": "ListQueue__INITIAL_CAPACITY", | |
| 5408 ListQueue$: function(initialCapacity, $E) { | |
| 5409 var t1 = new P.ListQueue(null, 0, 0, 0); | |
| 5410 H.setRuntimeTypeInfo(t1, [$E]); | |
| 5411 t1.ListQueue$1(initialCapacity, $E); | |
| 5412 return t1; | |
| 5413 }} | |
| 5414 | |
| 5415 }, | |
| 5416 | |
| 5417 _ListQueueIterator: {"": "Object;_queue,_end,_modificationCount,_position,_colle
ction$_current", | |
| 5418 get$current: function() { | |
| 5419 return this._collection$_current; | |
| 5420 }, | |
| 5421 moveNext$0: function() { | |
| 5422 var t1, t2, t3; | |
| 5423 t1 = this._queue; | |
| 5424 if (this._modificationCount !== t1._modificationCount) | |
| 5425 H.throwExpression(P.ConcurrentModificationError$(t1)); | |
| 5426 t2 = this._position; | |
| 5427 if (t2 === this._end) { | |
| 5428 this._collection$_current = null; | |
| 5429 return false; | |
| 5430 } | |
| 5431 t3 = t1._table; | |
| 5432 if (t2 < 0 || t2 >= t3.length) | |
| 5433 throw H.ioore(t3, t2); | |
| 5434 this._collection$_current = t3[t2]; | |
| 5435 this._position = (this._position + 1 & t1._table.length - 1) >>> 0; | |
| 5436 return true; | |
| 5437 }, | |
| 5438 static: { | |
| 5439 _ListQueueIterator$: function(queue) { | |
| 5440 return new P._ListQueueIterator(queue, queue._tail, queue._modificationCount,
queue._head, null); | |
| 5441 }} | |
| 5442 | |
| 5443 }}], | |
| 5444 ["dart.core", "dart:core", , P, { | |
| 5445 Function__toMangledNames: function(namedArguments) { | |
| 5446 return; | |
| 5447 }, | |
| 5448 | |
| 5449 Error_safeToString: function(object) { | |
| 5450 var buffer, t1, i, codeUnit, t2, charCodes; | |
| 5451 if (typeof object === "number" || typeof object === "boolean" || null == objec
t) | |
| 5452 return J.toString$0(object); | |
| 5453 if (typeof object === "string") { | |
| 5454 buffer = new P.StringBuffer(""); | |
| 5455 buffer._contents = "\""; | |
| 5456 for (t1 = object.length, i = 0; i < t1; ++i) { | |
| 5457 codeUnit = C.JSString_methods.codeUnitAt$1(object, i); | |
| 5458 if (codeUnit <= 31) | |
| 5459 if (codeUnit === 10) | |
| 5460 buffer._contents = buffer._contents + "\\n"; | |
| 5461 else if (codeUnit === 13) | |
| 5462 buffer._contents = buffer._contents + "\\r"; | |
| 5463 else if (codeUnit === 9) | |
| 5464 buffer._contents = buffer._contents + "\\t"; | |
| 5465 else { | |
| 5466 buffer._contents = buffer._contents + "\\x"; | |
| 5467 if (codeUnit < 16) | |
| 5468 buffer._contents = buffer._contents + "0"; | |
| 5469 else { | |
| 5470 buffer._contents = buffer._contents + "1"; | |
| 5471 codeUnit -= 16; | |
| 5472 } | |
| 5473 t2 = codeUnit < 10 ? 48 + codeUnit : 87 + codeUnit; | |
| 5474 charCodes = P.List_List$filled(1, t2, J.JSInt); | |
| 5475 charCodes.$builtinTypeInfo = [J.JSInt]; | |
| 5476 t2 = H.Primitives_stringFromCharCodes(charCodes); | |
| 5477 buffer._contents = buffer._contents + t2; | |
| 5478 } | |
| 5479 else if (codeUnit === 92) | |
| 5480 buffer._contents = buffer._contents + "\\\\"; | |
| 5481 else if (codeUnit === 34) | |
| 5482 buffer._contents = buffer._contents + "\\\""; | |
| 5483 else { | |
| 5484 charCodes = P.List_List$filled(1, codeUnit, J.JSInt); | |
| 5485 charCodes.$builtinTypeInfo = [J.JSInt]; | |
| 5486 t2 = H.Primitives_stringFromCharCodes(charCodes); | |
| 5487 buffer._contents = buffer._contents + t2; | |
| 5488 } | |
| 5489 } | |
| 5490 buffer._contents = buffer._contents + "\""; | |
| 5491 return buffer._contents; | |
| 5492 } | |
| 5493 return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
| 5494 }, | |
| 5495 | |
| 5496 Exception_Exception: function(message) { | |
| 5497 return new P._ExceptionImplementation(message); | |
| 5498 }, | |
| 5499 | |
| 5500 identical: function(a, b) { | |
| 5501 return a == null ? b == null : a === b; | |
| 5502 }, | |
| 5503 | |
| 5504 identityHashCode: function(object) { | |
| 5505 return H.objectHashCode(object); | |
| 5506 }, | |
| 5507 | |
| 5508 List_List: function($length, $E) { | |
| 5509 if ($length == null) | |
| 5510 return new Array(0); | |
| 5511 if (typeof $length !== "number" || Math.floor($length) !== $length || $length
< 0) | |
| 5512 throw H.wrapException(new P.ArgumentError("Length must be a positive integer
: " + H.S($length) + ".")); | |
| 5513 return H.Primitives_newFixedList($length); | |
| 5514 }, | |
| 5515 | |
| 5516 List_List$filled: function($length, fill, $E) { | |
| 5517 var result, t1, i; | |
| 5518 if ($length < 0) | |
| 5519 throw H.wrapException(new P.ArgumentError("Length must be a positive integer
: " + $length + ".")); | |
| 5520 result = H.Primitives_newFixedList($length); | |
| 5521 if ($length !== 0 && true) | |
| 5522 for (t1 = result.length, i = 0; i < t1; ++i) | |
| 5523 result[i] = fill; | |
| 5524 return result; | |
| 5525 }, | |
| 5526 | |
| 5527 List_List$from: function(other, growable, $E) { | |
| 5528 var list, t1, $length, fixedList, i; | |
| 5529 list = P.List_List(null, $E); | |
| 5530 H.setRuntimeTypeInfo(list, [$E]); | |
| 5531 for (t1 = J.get$iterator$ax(other); t1.moveNext$0();) | |
| 5532 list.push(t1.get$current()); | |
| 5533 if (growable) | |
| 5534 return list; | |
| 5535 $length = list.length; | |
| 5536 fixedList = P.List_List($length, $E); | |
| 5537 H.setRuntimeTypeInfo(fixedList, [$E]); | |
| 5538 for (t1 = list.length, i = 0; i < $length; ++i) { | |
| 5539 if (i >= t1) | |
| 5540 throw H.ioore(list, i); | |
| 5541 fixedList[i] = list[i]; | |
| 5542 } | |
| 5543 return fixedList; | |
| 5544 }, | |
| 5545 | |
| 5546 print: function(object) { | |
| 5547 var line = J.toString$0(object); | |
| 5548 H.printToConsole(line); | |
| 5549 }, | |
| 5550 | |
| 5551 Function__toMangledNames_closure: {"": "Closure;result_0", | |
| 5552 call$2: function(symbol, value) { | |
| 5553 var t1 = this.result_0; | |
| 5554 t1.$indexSet(t1, symbol.get$_name(), value); | |
| 5555 }, | |
| 5556 "+call:2:0": 0, | |
| 5557 $isFunction: true, | |
| 5558 $is_args2: true | |
| 5559 }, | |
| 5560 | |
| 5561 NoSuchMethodError_toString_closure: {"": "Closure;box_0", | |
| 5562 call$2: function(key, value) { | |
| 5563 var t1 = this.box_0; | |
| 5564 if (t1.i_1 > 0) | |
| 5565 t1.sb_0.write$1(", "); | |
| 5566 t1.sb_0.write$1(key.get$_name()); | |
| 5567 t1.sb_0.write$1(": "); | |
| 5568 t1.sb_0.write$1(P.Error_safeToString(value)); | |
| 5569 t1.i_1 = t1.i_1 + 1; | |
| 5570 }, | |
| 5571 "+call:2:0": 0, | |
| 5572 $isFunction: true, | |
| 5573 $is_args2: true | |
| 5574 }, | |
| 5575 | |
| 5576 DateTime: {"": "Object;millisecondsSinceEpoch,isUtc", | |
| 5577 $eq: function(_, other) { | |
| 5578 var t1; | |
| 5579 if (other == null) | |
| 5580 return false; | |
| 5581 t1 = J.getInterceptor(other); | |
| 5582 if (typeof other !== "object" || other === null || !t1.$isDateTime) | |
| 5583 return false; | |
| 5584 return this.millisecondsSinceEpoch === other.millisecondsSinceEpoch && this.
isUtc === other.isUtc; | |
| 5585 }, | |
| 5586 get$hashCode: function(_) { | |
| 5587 return this.millisecondsSinceEpoch; | |
| 5588 }, | |
| 5589 toString$0: function(_) { | |
| 5590 var t1, y, m, d, h, min, sec, ms; | |
| 5591 t1 = new P.DateTime_toString_twoDigits(); | |
| 5592 y = new P.DateTime_toString_fourDigits().call$1(H.Primitives_getYear(this)); | |
| 5593 m = t1.call$1(H.Primitives_getMonth(this)); | |
| 5594 d = t1.call$1(H.Primitives_getDay(this)); | |
| 5595 h = t1.call$1(H.Primitives_getHours(this)); | |
| 5596 min = t1.call$1(H.Primitives_getMinutes(this)); | |
| 5597 sec = t1.call$1(H.Primitives_getSeconds(this)); | |
| 5598 ms = new P.DateTime_toString_threeDigits().call$1(H.Primitives_getMillisecon
ds(this)); | |
| 5599 if (this.isUtc) | |
| 5600 return H.S(y) + "-" + H.S(m) + "-" + H.S(d) + " " + H.S(h) + ":" + H.S(min
) + ":" + H.S(sec) + "." + H.S(ms) + "Z"; | |
| 5601 else | |
| 5602 return H.S(y) + "-" + H.S(m) + "-" + H.S(d) + " " + H.S(h) + ":" + H.S(min
) + ":" + H.S(sec) + "." + H.S(ms); | |
| 5603 }, | |
| 5604 DateTime$fromMillisecondsSinceEpoch$2$isUtc: function(millisecondsSinceEpoch,
isUtc) { | |
| 5605 if (Math.abs(millisecondsSinceEpoch) > 8640000000000000) | |
| 5606 throw H.wrapException(new P.ArgumentError(millisecondsSinceEpoch)); | |
| 5607 }, | |
| 5608 $isDateTime: true, | |
| 5609 static: { | |
| 5610 "": "DateTime_MONDAY,DateTime_TUESDAY,DateTime_WEDNESDAY,DateTime_THURSDAY,DateT
ime_FRIDAY,DateTime_SATURDAY,DateTime_SUNDAY,DateTime_DAYS_PER_WEEK,DateTime_JAN
UARY,DateTime_FEBRUARY,DateTime_MARCH,DateTime_APRIL,DateTime_MAY,DateTime_JUNE,
DateTime_JULY,DateTime_AUGUST,DateTime_SEPTEMBER,DateTime_OCTOBER,DateTime_NOVEM
BER,DateTime_DECEMBER,DateTime_MONTHS_PER_YEAR,DateTime__MAX_MILLISECONDS_SINCE_
EPOCH", | |
| 5611 DateTime$fromMillisecondsSinceEpoch: function(millisecondsSinceEpoch, isUtc) { | |
| 5612 var t1 = new P.DateTime(millisecondsSinceEpoch, isUtc); | |
| 5613 t1.DateTime$fromMillisecondsSinceEpoch$2$isUtc(millisecondsSinceEpoch, isUtc); | |
| 5614 return t1; | |
| 5615 }} | |
| 5616 | |
| 5617 }, | |
| 5618 | |
| 5619 DateTime_toString_fourDigits: {"": "Closure;", | |
| 5620 call$1: function(n) { | |
| 5621 var t1, absN, sign; | |
| 5622 t1 = J.getInterceptor$n(n); | |
| 5623 absN = t1.abs$0(n); | |
| 5624 sign = t1.$lt(n, 0) ? "-" : ""; | |
| 5625 if (absN >= 1000) | |
| 5626 return H.S(n); | |
| 5627 if (absN >= 100) | |
| 5628 return sign + "0" + H.S(absN); | |
| 5629 if (absN >= 10) | |
| 5630 return sign + "00" + H.S(absN); | |
| 5631 return sign + "000" + H.S(absN); | |
| 5632 }, | |
| 5633 "+call:1:0": 0, | |
| 5634 $isFunction: true, | |
| 5635 $is_args1: true | |
| 5636 }, | |
| 5637 | |
| 5638 DateTime_toString_threeDigits: {"": "Closure;", | |
| 5639 call$1: function(n) { | |
| 5640 var t1 = J.getInterceptor$n(n); | |
| 5641 if (t1.$ge(n, 100)) | |
| 5642 return H.S(n); | |
| 5643 if (t1.$ge(n, 10)) | |
| 5644 return "0" + H.S(n); | |
| 5645 return "00" + H.S(n); | |
| 5646 }, | |
| 5647 "+call:1:0": 0, | |
| 5648 $isFunction: true, | |
| 5649 $is_args1: true | |
| 5650 }, | |
| 5651 | |
| 5652 DateTime_toString_twoDigits: {"": "Closure;", | |
| 5653 call$1: function(n) { | |
| 5654 if (J.$ge$n(n, 10)) | |
| 5655 return H.S(n); | |
| 5656 return "0" + H.S(n); | |
| 5657 }, | |
| 5658 "+call:1:0": 0, | |
| 5659 $isFunction: true, | |
| 5660 $is_args1: true | |
| 5661 }, | |
| 5662 | |
| 5663 Duration: {"": "Object;_duration<", | |
| 5664 $sub: function(_, other) { | |
| 5665 return P.Duration$(0, 0, C.JSNumber_methods.$sub(this._duration, other.get$_
duration()), 0, 0, 0); | |
| 5666 }, | |
| 5667 $lt: function(_, other) { | |
| 5668 return C.JSNumber_methods.$lt(this._duration, other.get$_duration()); | |
| 5669 }, | |
| 5670 $gt: function(_, other) { | |
| 5671 return this._duration > other.get$_duration(); | |
| 5672 }, | |
| 5673 $ge: function(_, other) { | |
| 5674 return this._duration >= other.get$_duration(); | |
| 5675 }, | |
| 5676 $eq: function(_, other) { | |
| 5677 var t1; | |
| 5678 if (other == null) | |
| 5679 return false; | |
| 5680 t1 = J.getInterceptor(other); | |
| 5681 if (typeof other !== "object" || other === null || !t1.$isDuration) | |
| 5682 return false; | |
| 5683 return this._duration === other._duration; | |
| 5684 }, | |
| 5685 get$hashCode: function(_) { | |
| 5686 return this._duration & 0x1FFFFFFF; | |
| 5687 }, | |
| 5688 toString$0: function(_) { | |
| 5689 var t1, t2, twoDigitMinutes, twoDigitSeconds, sixDigitUs; | |
| 5690 t1 = new P.Duration_toString_twoDigits(); | |
| 5691 t2 = this._duration; | |
| 5692 if (t2 < 0) | |
| 5693 return "-" + H.S(P.Duration$(0, 0, -t2, 0, 0, 0)); | |
| 5694 twoDigitMinutes = t1.call$1(C.JSNumber_methods.remainder$1(C.JSNumber_method
s.$tdiv(t2, 60000000), 60)); | |
| 5695 twoDigitSeconds = t1.call$1(C.JSNumber_methods.remainder$1(C.JSNumber_method
s.$tdiv(t2, 1000000), 60)); | |
| 5696 sixDigitUs = new P.Duration_toString_sixDigits().call$1(C.JSNumber_methods.r
emainder$1(t2, 1000000)); | |
| 5697 return H.S(C.JSNumber_methods.$tdiv(t2, 3600000000)) + ":" + H.S(twoDigitMin
utes) + ":" + H.S(twoDigitSeconds) + "." + H.S(sixDigitUs); | |
| 5698 }, | |
| 5699 $isDuration: true, | |
| 5700 static: { | |
| 5701 "": "Duration_MICROSECONDS_PER_MILLISECOND,Duration_MILLISECONDS_PER_SECOND,Dura
tion_SECONDS_PER_MINUTE,Duration_MINUTES_PER_HOUR,Duration_HOURS_PER_DAY,Duratio
n_MICROSECONDS_PER_SECOND,Duration_MICROSECONDS_PER_MINUTE,Duration_MICROSECONDS
_PER_HOUR,Duration_MICROSECONDS_PER_DAY,Duration_MILLISECONDS_PER_MINUTE,Duratio
n_MILLISECONDS_PER_HOUR,Duration_MILLISECONDS_PER_DAY,Duration_SECONDS_PER_HOUR,
Duration_SECONDS_PER_DAY,Duration_MINUTES_PER_DAY,Duration_ZERO", | |
| 5702 Duration$: function(days, hours, microseconds, milliseconds, minutes, seconds) { | |
| 5703 return new P.Duration(days * 86400000000 + hours * 3600000000 + minutes * 6000
0000 + seconds * 1000000 + milliseconds * 1000 + microseconds); | |
| 5704 }} | |
| 5705 | |
| 5706 }, | |
| 5707 | |
| 5708 Duration_toString_sixDigits: {"": "Closure;", | |
| 5709 call$1: function(n) { | |
| 5710 var t1 = J.getInterceptor$n(n); | |
| 5711 if (t1.$ge(n, 100000)) | |
| 5712 return H.S(n); | |
| 5713 if (t1.$ge(n, 10000)) | |
| 5714 return "0" + H.S(n); | |
| 5715 if (t1.$ge(n, 1000)) | |
| 5716 return "00" + H.S(n); | |
| 5717 if (t1.$ge(n, 100)) | |
| 5718 return "000" + H.S(n); | |
| 5719 if (t1.$gt(n, 10)) | |
| 5720 return "0000" + H.S(n); | |
| 5721 return "00000" + H.S(n); | |
| 5722 }, | |
| 5723 "+call:1:0": 0, | |
| 5724 $isFunction: true, | |
| 5725 $is_args1: true | |
| 5726 }, | |
| 5727 | |
| 5728 Duration_toString_twoDigits: {"": "Closure;", | |
| 5729 call$1: function(n) { | |
| 5730 if (J.$ge$n(n, 10)) | |
| 5731 return H.S(n); | |
| 5732 return "0" + H.S(n); | |
| 5733 }, | |
| 5734 "+call:1:0": 0, | |
| 5735 $isFunction: true, | |
| 5736 $is_args1: true | |
| 5737 }, | |
| 5738 | |
| 5739 Error: {"": "Object;", | |
| 5740 get$stackTrace: function() { | |
| 5741 return new H._StackTrace(this.$thrownJsError, null); | |
| 5742 }, | |
| 5743 $isError: true | |
| 5744 }, | |
| 5745 | |
| 5746 NullThrownError: {"": "Error;", | |
| 5747 toString$0: function(_) { | |
| 5748 return "Throw of null."; | |
| 5749 } | |
| 5750 }, | |
| 5751 | |
| 5752 ArgumentError: {"": "Error;message", | |
| 5753 toString$0: function(_) { | |
| 5754 var t1 = this.message; | |
| 5755 if (t1 != null) | |
| 5756 return "Illegal argument(s): " + H.S(t1); | |
| 5757 return "Illegal argument(s)"; | |
| 5758 }, | |
| 5759 static: { | |
| 5760 ArgumentError$: function(message) { | |
| 5761 return new P.ArgumentError(message); | |
| 5762 }} | |
| 5763 | |
| 5764 }, | |
| 5765 | |
| 5766 RangeError: {"": "ArgumentError;message", | |
| 5767 toString$0: function(_) { | |
| 5768 return "RangeError: " + H.S(this.message); | |
| 5769 }, | |
| 5770 static: { | |
| 5771 RangeError$value: function(value) { | |
| 5772 return new P.RangeError("value " + H.S(value)); | |
| 5773 }, | |
| 5774 | |
| 5775 RangeError$range: function(value, start, end) { | |
| 5776 return new P.RangeError("value " + H.S(value) + " not in range " + start + "..
" + H.S(end)); | |
| 5777 }} | |
| 5778 | |
| 5779 }, | |
| 5780 | |
| 5781 NoSuchMethodError: {"": "Error;_core$_receiver,_memberName,_core$_arguments,_nam
edArguments,_existingArgumentNames", | |
| 5782 toString$0: function(_) { | |
| 5783 var t1, t2, t3, t4, str; | |
| 5784 t1 = {}; | |
| 5785 t1.sb_0 = P.StringBuffer$(""); | |
| 5786 t1.i_1 = 0; | |
| 5787 for (t2 = this._core$_arguments; t3 = t1.i_1, t3 < t2.length; t1.i_1 = t1.i_
1 + 1) { | |
| 5788 if (t3 > 0) { | |
| 5789 t3 = t1.sb_0; | |
| 5790 t3._contents = t3._contents + ", "; | |
| 5791 } | |
| 5792 t3 = t1.sb_0; | |
| 5793 t4 = t1.i_1; | |
| 5794 if (t4 < 0 || t4 >= t2.length) | |
| 5795 throw H.ioore(t2, t4); | |
| 5796 str = P.Error_safeToString(t2[t4]); | |
| 5797 str = typeof str === "string" ? str : H.S(str); | |
| 5798 t3._contents = t3._contents + str; | |
| 5799 } | |
| 5800 t2 = this._namedArguments; | |
| 5801 t2.forEach$1(t2, new P.NoSuchMethodError_toString_closure(t1)); | |
| 5802 return "NoSuchMethodError : method not found: '" + H.S(this._memberName) + "
'\nReceiver: " + H.S(P.Error_safeToString(this._core$_receiver)) + "\nArguments:
[" + H.S(t1.sb_0) + "]"; | |
| 5803 }, | |
| 5804 static: { | |
| 5805 NoSuchMethodError$: function(receiver, memberName, positionalArguments, namedArg
uments, existingArgumentNames) { | |
| 5806 return new P.NoSuchMethodError(receiver, memberName, positionalArguments, name
dArguments, existingArgumentNames); | |
| 5807 }} | |
| 5808 | |
| 5809 }, | |
| 5810 | |
| 5811 UnsupportedError: {"": "Error;message", | |
| 5812 toString$0: function(_) { | |
| 5813 return "Unsupported operation: " + this.message; | |
| 5814 }, | |
| 5815 static: { | |
| 5816 UnsupportedError$: function(message) { | |
| 5817 return new P.UnsupportedError(message); | |
| 5818 }} | |
| 5819 | |
| 5820 }, | |
| 5821 | |
| 5822 UnimplementedError: {"": "Error;message", | |
| 5823 toString$0: function(_) { | |
| 5824 var t1 = this.message; | |
| 5825 return t1 != null ? "UnimplementedError: " + H.S(t1) : "UnimplementedError"; | |
| 5826 }, | |
| 5827 $isError: true, | |
| 5828 static: { | |
| 5829 UnimplementedError$: function(message) { | |
| 5830 return new P.UnimplementedError(message); | |
| 5831 }} | |
| 5832 | |
| 5833 }, | |
| 5834 | |
| 5835 StateError: {"": "Error;message", | |
| 5836 toString$0: function(_) { | |
| 5837 return "Bad state: " + this.message; | |
| 5838 }, | |
| 5839 static: { | |
| 5840 StateError$: function(message) { | |
| 5841 return new P.StateError(message); | |
| 5842 }} | |
| 5843 | |
| 5844 }, | |
| 5845 | |
| 5846 ConcurrentModificationError: {"": "Error;modifiedObject", | |
| 5847 toString$0: function(_) { | |
| 5848 var t1 = this.modifiedObject; | |
| 5849 if (t1 == null) | |
| 5850 return "Concurrent modification during iteration."; | |
| 5851 return "Concurrent modification during iteration: " + H.S(P.Error_safeToStri
ng(t1)) + "."; | |
| 5852 }, | |
| 5853 static: { | |
| 5854 ConcurrentModificationError$: function(modifiedObject) { | |
| 5855 return new P.ConcurrentModificationError(modifiedObject); | |
| 5856 }} | |
| 5857 | |
| 5858 }, | |
| 5859 | |
| 5860 StackOverflowError: {"": "Object;", | |
| 5861 toString$0: function(_) { | |
| 5862 return "Stack Overflow"; | |
| 5863 }, | |
| 5864 get$stackTrace: function() { | |
| 5865 return; | |
| 5866 }, | |
| 5867 $isError: true | |
| 5868 }, | |
| 5869 | |
| 5870 CyclicInitializationError: {"": "Error;variableName", | |
| 5871 toString$0: function(_) { | |
| 5872 return "Reading static variable '" + this.variableName + "' during its initi
alization"; | |
| 5873 }, | |
| 5874 static: { | |
| 5875 CyclicInitializationError$: function(variableName) { | |
| 5876 return new P.CyclicInitializationError(variableName); | |
| 5877 }} | |
| 5878 | |
| 5879 }, | |
| 5880 | |
| 5881 _ExceptionImplementation: {"": "Object;message", | |
| 5882 toString$0: function(_) { | |
| 5883 var t1 = this.message; | |
| 5884 if (t1 == null) | |
| 5885 return "Exception"; | |
| 5886 return "Exception: " + H.S(t1); | |
| 5887 } | |
| 5888 }, | |
| 5889 | |
| 5890 FormatException: {"": "Object;message", | |
| 5891 toString$0: function(_) { | |
| 5892 return "FormatException: " + H.S(this.message); | |
| 5893 }, | |
| 5894 static: { | |
| 5895 FormatException$: function(message) { | |
| 5896 return new P.FormatException(message); | |
| 5897 }} | |
| 5898 | |
| 5899 }, | |
| 5900 | |
| 5901 Expando: {"": "Object;name", | |
| 5902 toString$0: function(_) { | |
| 5903 return "Expando:" + H.S(this.name); | |
| 5904 }, | |
| 5905 $index: function(_, object) { | |
| 5906 var values = H.Primitives_getProperty(object, "expando$values"); | |
| 5907 return values == null ? null : H.Primitives_getProperty(values, this._getKey
$0()); | |
| 5908 }, | |
| 5909 $indexSet: function(_, object, value) { | |
| 5910 var values = H.Primitives_getProperty(object, "expando$values"); | |
| 5911 if (values == null) { | |
| 5912 values = new P.Object(); | |
| 5913 H.Primitives_setProperty(object, "expando$values", values); | |
| 5914 } | |
| 5915 H.Primitives_setProperty(values, this._getKey$0(), value); | |
| 5916 }, | |
| 5917 _getKey$0: function() { | |
| 5918 var key, t1; | |
| 5919 key = H.Primitives_getProperty(this, "expando$key"); | |
| 5920 if (key == null) { | |
| 5921 t1 = $.Expando__keyCount; | |
| 5922 $.Expando__keyCount = t1 + 1; | |
| 5923 key = "expando$key$" + t1; | |
| 5924 H.Primitives_setProperty(this, "expando$key", key); | |
| 5925 } | |
| 5926 return key; | |
| 5927 }, | |
| 5928 static: { | |
| 5929 "": "Expando__KEY_PROPERTY_NAME,Expando__EXPANDO_PROPERTY_NAME,Expando__keyCount
", | |
| 5930 } | |
| 5931 | |
| 5932 }, | |
| 5933 | |
| 5934 Function: {"": "Object;", $isFunction: true}, | |
| 5935 | |
| 5936 Iterator: {"": "Object;"}, | |
| 5937 | |
| 5938 Null: {"": "Object;", | |
| 5939 toString$0: function(_) { | |
| 5940 return "null"; | |
| 5941 } | |
| 5942 }, | |
| 5943 | |
| 5944 Object: {"": ";", | |
| 5945 $eq: function(_, other) { | |
| 5946 return this === other; | |
| 5947 }, | |
| 5948 get$hashCode: function(_) { | |
| 5949 return H.Primitives_objectHashCode(this); | |
| 5950 }, | |
| 5951 toString$0: function(_) { | |
| 5952 return H.Primitives_objectToString(this); | |
| 5953 }, | |
| 5954 noSuchMethod$1: function(_, invocation) { | |
| 5955 throw H.wrapException(P.NoSuchMethodError$(this, invocation.get$memberName()
, invocation.get$positionalArguments(), invocation.get$namedArguments(), null)); | |
| 5956 } | |
| 5957 }, | |
| 5958 | |
| 5959 StackTrace: {"": "Object;"}, | |
| 5960 | |
| 5961 StringBuffer: {"": "Object;_contents<", | |
| 5962 get$length: function(_) { | |
| 5963 return this._contents.length; | |
| 5964 }, | |
| 5965 write$1: function(obj) { | |
| 5966 var str = typeof obj === "string" ? obj : H.S(obj); | |
| 5967 this._contents = this._contents + str; | |
| 5968 }, | |
| 5969 writeAll$2: function(objects, separator) { | |
| 5970 var iterator, str; | |
| 5971 iterator = J.get$iterator$ax(objects); | |
| 5972 if (!iterator.moveNext$0()) | |
| 5973 return; | |
| 5974 if (separator.length === 0) | |
| 5975 do { | |
| 5976 str = iterator.get$current(); | |
| 5977 str = typeof str === "string" ? str : H.S(str); | |
| 5978 this._contents = this._contents + str; | |
| 5979 } while (iterator.moveNext$0()); | |
| 5980 else { | |
| 5981 this.write$1(iterator.get$current()); | |
| 5982 for (; iterator.moveNext$0();) { | |
| 5983 this._contents = this._contents + separator; | |
| 5984 str = iterator.get$current(); | |
| 5985 str = typeof str === "string" ? str : H.S(str); | |
| 5986 this._contents = this._contents + str; | |
| 5987 } | |
| 5988 } | |
| 5989 }, | |
| 5990 toString$0: function(_) { | |
| 5991 return this._contents; | |
| 5992 }, | |
| 5993 StringBuffer$1: function($content) { | |
| 5994 this._contents = $content; | |
| 5995 }, | |
| 5996 static: { | |
| 5997 StringBuffer$: function($content) { | |
| 5998 var t1 = new P.StringBuffer(""); | |
| 5999 t1.StringBuffer$1($content); | |
| 6000 return t1; | |
| 6001 }} | |
| 6002 | |
| 6003 }, | |
| 6004 | |
| 6005 Symbol: {"": "Object;"}}], | |
| 6006 ["dart.dom.html", "dart:html", , W, { | |
| 6007 _wrapZone: function(callback) { | |
| 6008 var t1 = $.Zone__current; | |
| 6009 if (t1 === C.C__RootZone) | |
| 6010 return callback; | |
| 6011 return t1.bindUnaryCallback$2$runGuarded(callback, true); | |
| 6012 }, | |
| 6013 | |
| 6014 HtmlElement: {"": "Element;", "%": "HTMLAppletElement|HTMLAreaElement|HTMLBRElem
ent|HTMLBaseElement|HTMLBaseFontElement|HTMLBodyElement|HTMLCanvasElement|HTMLCo
ntentElement|HTMLDListElement|HTMLDataListElement|HTMLDetailsElement|HTMLDialogE
lement|HTMLDirectoryElement|HTMLDivElement|HTMLEmbedElement|HTMLFieldSetElement|
HTMLFontElement|HTMLFrameElement|HTMLFrameSetElement|HTMLHRElement|HTMLHeadEleme
nt|HTMLHeadingElement|HTMLHtmlElement|HTMLIFrameElement|HTMLImageElement|HTMLKey
genElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTM
LMarqueeElement|HTMLMenuElement|HTMLMetaElement|HTMLModElement|HTMLOListElement|
HTMLObjectElement|HTMLOptGroupElement|HTMLParagraphElement|HTMLPreElement|HTMLQu
oteElement|HTMLScriptElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement
|HTMLStyleElement|HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColEleme
nt|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement|HTMLTabl
eRowElement|HTMLTableSectionElement|HTMLTemplateElement|HTMLTitleElement|HTMLTra
ckElement|HTMLUListElement|HTMLUnknownElement;HTMLElement"}, | |
| 6015 | |
| 6016 AnchorElement: {"": "HtmlElement;", | |
| 6017 toString$0: function(receiver) { | |
| 6018 return receiver.toString(); | |
| 6019 }, | |
| 6020 "%": "HTMLAnchorElement" | |
| 6021 }, | |
| 6022 | |
| 6023 Blob: {"": "Interceptor;", $isBlob: true, "%": "Blob|File"}, | |
| 6024 | |
| 6025 ButtonElement: {"": "HtmlElement;value=", "%": "HTMLButtonElement"}, | |
| 6026 | |
| 6027 CharacterData: {"": "Node;length=", "%": "CDATASection|CharacterData|Comment|Pro
cessingInstruction|Text"}, | |
| 6028 | |
| 6029 DomException: {"": "Interceptor;", | |
| 6030 toString$0: function(receiver) { | |
| 6031 return receiver.toString(); | |
| 6032 }, | |
| 6033 "%": "DOMException" | |
| 6034 }, | |
| 6035 | |
| 6036 Element: {"": "Node;", | |
| 6037 toString$0: function(receiver) { | |
| 6038 return receiver.localName; | |
| 6039 }, | |
| 6040 "%": "SVGAElement|SVGAltGlyphDefElement|SVGAltGlyphElement|SVGAltGlyphItemElem
ent|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement|SVGAnimateT
ransformElement|SVGAnimationElement|SVGCircleElement|SVGClipPathElement|SVGCompo
nentTransferFunctionElement|SVGCursorElement|SVGDefsElement|SVGDescElement|SVGEl
ement|SVGEllipseElement|SVGFEBlendElement|SVGFEColorMatrixElement|SVGFEComponent
TransferElement|SVGFECompositeElement|SVGFEConvolveMatrixElement|SVGFEDiffuseLig
htingElement|SVGFEDisplacementMapElement|SVGFEDistantLightElement|SVGFEDropShado
wElement|SVGFEFloodElement|SVGFEFuncAElement|SVGFEFuncBElement|SVGFEFuncGElement
|SVGFEFuncRElement|SVGFEGaussianBlurElement|SVGFEImageElement|SVGFEMergeElement|
SVGFEMergeNodeElement|SVGFEMorphologyElement|SVGFEOffsetElement|SVGFEPointLightE
lement|SVGFESpecularLightingElement|SVGFESpotLightElement|SVGFETileElement|SVGFE
TurbulenceElement|SVGFilterElement|SVGFontElement|SVGFontFaceElement|SVGFontFace
FormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement
|SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGlyphRefElement|SVGGradi
entElement|SVGGraphicsElement|SVGHKernElement|SVGImageElement|SVGLineElement|SVG
LinearGradientElement|SVGMPathElement|SVGMarkerElement|SVGMaskElement|SVGMetadat
aElement|SVGMissingGlyphElement|SVGPathElement|SVGPatternElement|SVGPolygonEleme
nt|SVGPolylineElement|SVGRadialGradientElement|SVGRectElement|SVGSVGElement|SVGS
criptElement|SVGSetElement|SVGStopElement|SVGStyleElement|SVGSwitchElement|SVGSy
mbolElement|SVGTSpanElement|SVGTextContentElement|SVGTextElement|SVGTextPathElem
ent|SVGTextPositioningElement|SVGTitleElement|SVGUseElement|SVGVKernElement|SVGV
iewElement;Element" | |
| 6041 }, | |
| 6042 | |
| 6043 ErrorEvent: {"": "Event;error=", "%": "ErrorEvent"}, | |
| 6044 | |
| 6045 Event: {"": "Interceptor;", $isEvent: true, "%": "AudioProcessingEvent|Autocompl
eteErrorEvent|BeforeLoadEvent|BeforeUnloadEvent|CSSFontFaceLoadEvent|CloseEvent|
CompositionEvent|CustomEvent|DeviceMotionEvent|DeviceOrientationEvent|DragEvent|
FocusEvent|HashChangeEvent|IDBVersionChangeEvent|KeyboardEvent|MIDIConnectionEve
nt|MIDIMessageEvent|MSPointerEvent|MediaKeyEvent|MediaKeyMessageEvent|MediaKeyNe
ededEvent|MediaStreamEvent|MediaStreamTrackEvent|MessageEvent|MouseEvent|MouseSc
rollEvent|MouseWheelEvent|MutationEvent|OfflineAudioCompletionEvent|OverflowEven
t|PageTransitionEvent|PointerEvent|PopStateEvent|ProgressEvent|RTCDTMFToneChange
Event|RTCDataChannelEvent|RTCIceCandidateEvent|ResourceProgressEvent|SVGZoomEven
t|SecurityPolicyViolationEvent|SpeechInputEvent|SpeechRecognitionEvent|SpeechSyn
thesisEvent|StorageEvent|TextEvent|TouchEvent|TrackEvent|TransitionEvent|UIEvent
|WebGLContextEvent|WebKitAnimationEvent|WebKitTransitionEvent|WheelEvent|XMLHttp
RequestProgressEvent;Event"}, | |
| 6046 | |
| 6047 EventTarget: {"": "Interceptor;", | |
| 6048 addEventListener$3: function(receiver, type, listener, useCapture) { | |
| 6049 return receiver.addEventListener(type, H.convertDartClosureToJS(listener, 1)
, useCapture); | |
| 6050 }, | |
| 6051 removeEventListener$3: function(receiver, type, listener, useCapture) { | |
| 6052 return receiver.removeEventListener(type, H.convertDartClosureToJS(listener,
1), useCapture); | |
| 6053 }, | |
| 6054 "%": "MediaStream;EventTarget" | |
| 6055 }, | |
| 6056 | |
| 6057 FormElement: {"": "HtmlElement;length=", "%": "HTMLFormElement"}, | |
| 6058 | |
| 6059 ImageData: {"": "Interceptor;", $isImageData: true, "%": "ImageData"}, | |
| 6060 | |
| 6061 InputElement: {"": "HtmlElement;value=", $isNode: true, "%": "HTMLInputElement"}
, | |
| 6062 | |
| 6063 LIElement: {"": "HtmlElement;value=", "%": "HTMLLIElement"}, | |
| 6064 | |
| 6065 MediaElement: {"": "HtmlElement;error=", "%": "HTMLAudioElement|HTMLMediaElement
|HTMLVideoElement"}, | |
| 6066 | |
| 6067 MeterElement: {"": "HtmlElement;value=", "%": "HTMLMeterElement"}, | |
| 6068 | |
| 6069 Node: {"": "EventTarget;", | |
| 6070 toString$0: function(receiver) { | |
| 6071 var t1 = receiver.nodeValue; | |
| 6072 return t1 == null ? J.Interceptor.prototype.toString$0.call(this, receiver)
: t1; | |
| 6073 }, | |
| 6074 $isNode: true, | |
| 6075 "%": "Attr|Document|DocumentFragment|DocumentType|Entity|HTMLDocument|Notation
|SVGDocument|ShadowRoot;Node" | |
| 6076 }, | |
| 6077 | |
| 6078 OptionElement: {"": "HtmlElement;value=", "%": "HTMLOptionElement"}, | |
| 6079 | |
| 6080 OutputElement: {"": "HtmlElement;value=", "%": "HTMLOutputElement"}, | |
| 6081 | |
| 6082 ParamElement: {"": "HtmlElement;value=", "%": "HTMLParamElement"}, | |
| 6083 | |
| 6084 ProgressElement: {"": "HtmlElement;value=", "%": "HTMLProgressElement"}, | |
| 6085 | |
| 6086 SelectElement: {"": "HtmlElement;length=,value=", "%": "HTMLSelectElement"}, | |
| 6087 | |
| 6088 SpeechRecognitionError: {"": "Event;error=", "%": "SpeechRecognitionError"}, | |
| 6089 | |
| 6090 TextAreaElement: {"": "HtmlElement;value=", "%": "HTMLTextAreaElement"}, | |
| 6091 | |
| 6092 Window: {"": "EventTarget;", | |
| 6093 toString$0: function(receiver) { | |
| 6094 return receiver.toString(); | |
| 6095 }, | |
| 6096 $isWindow: true, | |
| 6097 "%": "DOMWindow|Window" | |
| 6098 }, | |
| 6099 | |
| 6100 EventStreamProvider: {"": "Object;_eventType"}, | |
| 6101 | |
| 6102 _EventStream: {"": "Stream;", | |
| 6103 listen$4$cancelOnError$onDone$onError: function(onData, cancelOnError, onDone,
onError) { | |
| 6104 var t1 = new W._EventStreamSubscription(0, this._target, this._eventType, W.
_wrapZone(onData), this._useCapture); | |
| 6105 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_EventStream", 0)]
); | |
| 6106 t1._tryResume$0(); | |
| 6107 return t1; | |
| 6108 }, | |
| 6109 listen$3$onDone$onError: function(onData, onDone, onError) { | |
| 6110 return this.listen$4$cancelOnError$onDone$onError(onData, null, onDone, onEr
ror); | |
| 6111 }, | |
| 6112 $asStream: null | |
| 6113 }, | |
| 6114 | |
| 6115 _ElementEventStreamImpl: {"": "_EventStream;_target,_eventType,_useCapture", $as
_EventStream: null}, | |
| 6116 | |
| 6117 _EventStreamSubscription: {"": "StreamSubscription;_pauseCount,_target,_eventTyp
e,_onData,_useCapture", | |
| 6118 cancel$0: function() { | |
| 6119 if (this._target == null) | |
| 6120 return; | |
| 6121 this._unlisten$0(); | |
| 6122 this._target = null; | |
| 6123 this._onData = null; | |
| 6124 }, | |
| 6125 pause$1: function(_, resumeSignal) { | |
| 6126 if (this._target == null) | |
| 6127 return; | |
| 6128 this._pauseCount = this._pauseCount + 1; | |
| 6129 this._unlisten$0(); | |
| 6130 }, | |
| 6131 pause$0: function($receiver) { | |
| 6132 return this.pause$1($receiver, null); | |
| 6133 }, | |
| 6134 resume$0: function() { | |
| 6135 if (this._target == null || this._pauseCount <= 0) | |
| 6136 return; | |
| 6137 this._pauseCount = this._pauseCount - 1; | |
| 6138 this._tryResume$0(); | |
| 6139 }, | |
| 6140 _tryResume$0: function() { | |
| 6141 var t1 = this._onData; | |
| 6142 if (t1 != null && this._pauseCount <= 0) | |
| 6143 J.addEventListener$3$x(this._target, this._eventType, t1, this._useCapture
); | |
| 6144 }, | |
| 6145 _unlisten$0: function() { | |
| 6146 var t1 = this._onData; | |
| 6147 if (t1 != null) | |
| 6148 J.removeEventListener$3$x(this._target, this._eventType, t1, this._useCapt
ure); | |
| 6149 }, | |
| 6150 $asStreamSubscription: null | |
| 6151 }}], | |
| 6152 ["dart.dom.indexed_db", "dart:indexed_db", , P, { | |
| 6153 KeyRange: {"": "Interceptor;", $isKeyRange: true, "%": "IDBKeyRange"}}], | |
| 6154 ["dart.isolate", "dart:isolate", , P, { | |
| 6155 ReceivePort: {"": "Object;"}}], | |
| 6156 ["dart.js", "dart:js", , P, { | |
| 6157 _convertDartFunction: function(f, captureThis) { | |
| 6158 return function(_call, f, captureThis) {return function() {return _call(f, cap
tureThis, this, Array.prototype.slice.apply(arguments));}}(P._callDartFunction$c
losure.call$4, f, captureThis); | |
| 6159 }, | |
| 6160 | |
| 6161 _callDartFunction: function(callback, captureThis, $self, $arguments) { | |
| 6162 var arguments0; | |
| 6163 if (captureThis === true) { | |
| 6164 arguments0 = [$self]; | |
| 6165 C.JSArray_methods.addAll$1(arguments0, $arguments); | |
| 6166 $arguments = arguments0; | |
| 6167 } | |
| 6168 return P._convertToJS(H.Primitives_applyFunction(callback, P.List_List$from(J.
map$1$ax($arguments, P._convertToDart$closure), true, null), P.Function__toMangl
edNames(null))); | |
| 6169 }, | |
| 6170 | |
| 6171 _defineProperty: function(o, $name, value) { | |
| 6172 var exception; | |
| 6173 if (Object.isExtensible(o)) | |
| 6174 try { | |
| 6175 Object.defineProperty(o, $name, { value: value}); | |
| 6176 return true; | |
| 6177 } catch (exception) { | |
| 6178 H.unwrapException(exception); | |
| 6179 } | |
| 6180 | |
| 6181 return false; | |
| 6182 }, | |
| 6183 | |
| 6184 _convertToJS: function(o) { | |
| 6185 var t1; | |
| 6186 if (o == null) | |
| 6187 return; | |
| 6188 else { | |
| 6189 if (typeof o !== "string") | |
| 6190 if (typeof o !== "number") | |
| 6191 if (typeof o !== "boolean") { | |
| 6192 t1 = J.getInterceptor(o); | |
| 6193 t1 = typeof o === "object" && o !== null && !!t1.$isBlob || typeof o =
== "object" && o !== null && !!t1.$isEvent || typeof o === "object" && o !== nul
l && !!t1.$isKeyRange || typeof o === "object" && o !== null && !!t1.$isImageDat
a || typeof o === "object" && o !== null && !!t1.$isNode || typeof o === "object
" && o !== null && !!t1.$isTypedData || typeof o === "object" && o !== null && !
!t1.$isWindow; | |
| 6194 } else | |
| 6195 t1 = true; | |
| 6196 else | |
| 6197 t1 = true; | |
| 6198 else | |
| 6199 t1 = true; | |
| 6200 if (t1) | |
| 6201 return o; | |
| 6202 else { | |
| 6203 t1 = J.getInterceptor(o); | |
| 6204 if (typeof o === "object" && o !== null && !!t1.$isDateTime) | |
| 6205 return H.Primitives_lazyAsJsDate(o); | |
| 6206 else if (typeof o === "object" && o !== null && !!t1.$isJsObject) | |
| 6207 return o._jsObject; | |
| 6208 else if (typeof o === "object" && o !== null && !!t1.$isFunction) | |
| 6209 return P._getJsProxy(o, "$dart_jsFunction", new P._convertToJS_closure()
); | |
| 6210 else | |
| 6211 return P._getJsProxy(o, "_$dart_jsObject", new P._convertToJS_closure0()
); | |
| 6212 } | |
| 6213 } | |
| 6214 }, | |
| 6215 | |
| 6216 _getJsProxy: function(o, propertyName, createProxy) { | |
| 6217 var jsProxy = o[propertyName]; | |
| 6218 if (jsProxy == null) { | |
| 6219 jsProxy = createProxy.call$1(o); | |
| 6220 P._defineProperty(o, propertyName, jsProxy); | |
| 6221 } | |
| 6222 return jsProxy; | |
| 6223 }, | |
| 6224 | |
| 6225 _convertToDart: function(o) { | |
| 6226 var t1; | |
| 6227 if (o == null || typeof o == "string" || typeof o == "number" || typeof o == "
boolean") | |
| 6228 return o; | |
| 6229 else { | |
| 6230 if (o instanceof Object) { | |
| 6231 t1 = J.getInterceptor(o); | |
| 6232 t1 = typeof o === "object" && o !== null && !!t1.$isBlob || typeof o === "
object" && o !== null && !!t1.$isEvent || typeof o === "object" && o !== null &&
!!t1.$isKeyRange || typeof o === "object" && o !== null && !!t1.$isImageData ||
typeof o === "object" && o !== null && !!t1.$isNode || typeof o === "object" &&
o !== null && !!t1.$isTypedData || typeof o === "object" && o !== null && !!t1.
$isWindow; | |
| 6233 } else | |
| 6234 t1 = false; | |
| 6235 if (t1) | |
| 6236 return o; | |
| 6237 else if (o instanceof Date) | |
| 6238 return P.DateTime$fromMillisecondsSinceEpoch(o.getMilliseconds(), false); | |
| 6239 else if (o.constructor === DartObject) | |
| 6240 return o.o; | |
| 6241 else | |
| 6242 return P._wrapToDart(o); | |
| 6243 } | |
| 6244 }, | |
| 6245 | |
| 6246 _wrapToDart: function(o) { | |
| 6247 if (typeof o == "function") | |
| 6248 return P._getDartProxy(o, "_$dart_dartClosure", new P._wrapToDart_closure())
; | |
| 6249 else if (o instanceof Array) | |
| 6250 return P._getDartProxy(o, "_$dart_dartObject", new P._wrapToDart_closure0())
; | |
| 6251 else | |
| 6252 return P._getDartProxy(o, "_$dart_dartObject", new P._wrapToDart_closure1())
; | |
| 6253 }, | |
| 6254 | |
| 6255 _getDartProxy: function(o, propertyName, createProxy) { | |
| 6256 var dartProxy = o[propertyName]; | |
| 6257 if (dartProxy == null) { | |
| 6258 dartProxy = createProxy.call$1(o); | |
| 6259 P._defineProperty(o, propertyName, dartProxy); | |
| 6260 } | |
| 6261 return dartProxy; | |
| 6262 }, | |
| 6263 | |
| 6264 JsObject: {"": "Object;_jsObject", | |
| 6265 $index: function(_, property) { | |
| 6266 if (typeof property !== "string" && typeof property !== "number") | |
| 6267 throw H.wrapException(new P.ArgumentError("property is not a String or num
")); | |
| 6268 return P._convertToDart(this._jsObject[property]); | |
| 6269 }, | |
| 6270 $indexSet: function(_, property, value) { | |
| 6271 if (typeof property !== "string" && typeof property !== "number") | |
| 6272 throw H.wrapException(new P.ArgumentError("property is not a String or num
")); | |
| 6273 this._jsObject[property] = P._convertToJS(value); | |
| 6274 }, | |
| 6275 get$hashCode: function(_) { | |
| 6276 return 0; | |
| 6277 }, | |
| 6278 $eq: function(_, other) { | |
| 6279 var t1; | |
| 6280 if (other == null) | |
| 6281 return false; | |
| 6282 t1 = J.getInterceptor(other); | |
| 6283 return typeof other === "object" && other !== null && !!t1.$isJsObject && th
is._jsObject === other._jsObject; | |
| 6284 }, | |
| 6285 toString$0: function(_) { | |
| 6286 var t1, exception; | |
| 6287 try { | |
| 6288 t1 = String(this._jsObject); | |
| 6289 return t1; | |
| 6290 } catch (exception) { | |
| 6291 H.unwrapException(exception); | |
| 6292 return P.Object.prototype.toString$0.call(this, this); | |
| 6293 } | |
| 6294 | |
| 6295 }, | |
| 6296 callMethod$2: function(method, args) { | |
| 6297 var t1, t2; | |
| 6298 t1 = this._jsObject; | |
| 6299 if (args == null) | |
| 6300 t2 = null; | |
| 6301 else { | |
| 6302 args.toString; | |
| 6303 t2 = new H.MappedListIterable(args, P._convertToJS$closure); | |
| 6304 H.setRuntimeTypeInfo(t2, [null, null]); | |
| 6305 t2 = P.List_List$from(t2, true, null); | |
| 6306 } | |
| 6307 return P._convertToDart(t1[method].apply(t1, t2)); | |
| 6308 }, | |
| 6309 $isJsObject: true, | |
| 6310 static: { | |
| 6311 JsObject_JsObject: function($constructor, $arguments) { | |
| 6312 var constr, args, t1, factoryFunction; | |
| 6313 constr = P._convertToJS($constructor); | |
| 6314 args = [null]; | |
| 6315 t1 = new H.MappedListIterable($arguments, P._convertToJS$closure); | |
| 6316 H.setRuntimeTypeInfo(t1, [null, null]); | |
| 6317 C.JSArray_methods.addAll$1(args, t1); | |
| 6318 factoryFunction = constr.bind.apply(constr, args); | |
| 6319 String(factoryFunction); | |
| 6320 return P._wrapToDart(new factoryFunction()); | |
| 6321 }, | |
| 6322 | |
| 6323 JsObject_JsObject$jsify: function(object) { | |
| 6324 var t1 = J.getInterceptor(object); | |
| 6325 if (!t1.$isMap && (typeof object !== "object" || object === null || object.con
structor !== Array && !t1.$isIterable)) | |
| 6326 throw H.wrapException(new P.ArgumentError("object must be a Map or Iterable"
)); | |
| 6327 return P._wrapToDart(P.JsObject__convertDataTree(object)); | |
| 6328 }, | |
| 6329 | |
| 6330 JsObject__convertDataTree: function(data) { | |
| 6331 return new P.JsObject__convertDataTree__convert(P.HashMap_HashMap$identity(nul
l, null)).call$1(data); | |
| 6332 }} | |
| 6333 | |
| 6334 }, | |
| 6335 | |
| 6336 JsObject__convertDataTree__convert: {"": "Closure;_convertedObjects_0", | |
| 6337 call$1: function(o) { | |
| 6338 var t1, t2, convertedMap, key, convertedList; | |
| 6339 t1 = this._convertedObjects_0; | |
| 6340 if (t1.containsKey$1(o)) | |
| 6341 return t1.$index(t1, o); | |
| 6342 t2 = J.getInterceptor(o); | |
| 6343 if (typeof o === "object" && o !== null && !!t2.$isMap) { | |
| 6344 convertedMap = {}; | |
| 6345 t1.$indexSet(t1, o, convertedMap); | |
| 6346 for (t1 = o.get$keys(), t1 = t1.get$iterator(t1); t1.moveNext$0();) { | |
| 6347 key = t1.get$current(); | |
| 6348 convertedMap[key] = this.call$1(t2.$index(o, key)); | |
| 6349 } | |
| 6350 return convertedMap; | |
| 6351 } else if (typeof o === "object" && o !== null && (o.constructor === Array |
| !!t2.$isIterable)) { | |
| 6352 convertedList = []; | |
| 6353 t1.$indexSet(t1, o, convertedList); | |
| 6354 C.JSArray_methods.addAll$1(convertedList, t2.map$1(o, this)); | |
| 6355 return convertedList; | |
| 6356 } else | |
| 6357 return P._convertToJS(o); | |
| 6358 }, | |
| 6359 "+call:1:0": 0, | |
| 6360 $isFunction: true, | |
| 6361 $is_args1: true | |
| 6362 }, | |
| 6363 | |
| 6364 JsFunction: {"": "JsObject;_jsObject", static: { | |
| 6365 JsFunction_JsFunction$withThis: function(f) { | |
| 6366 return new P.JsFunction(P._convertDartFunction(f, true)); | |
| 6367 }} | |
| 6368 }, | |
| 6369 | |
| 6370 JsArray: {"": "JsObject_ListMixin;_jsObject", | |
| 6371 $index: function(_, index) { | |
| 6372 var t1; | |
| 6373 if (typeof index === "number" && index === C.JSNumber_methods.toInt$0(index)
) { | |
| 6374 if (typeof index === "number" && Math.floor(index) === index) | |
| 6375 if (!(index < 0)) { | |
| 6376 t1 = P.JsObject.prototype.$index.call(this, this, "length"); | |
| 6377 if (typeof t1 !== "number") | |
| 6378 throw H.iae(t1); | |
| 6379 t1 = index >= t1; | |
| 6380 } else | |
| 6381 t1 = true; | |
| 6382 else | |
| 6383 t1 = false; | |
| 6384 if (t1) | |
| 6385 H.throwExpression(P.RangeError$range(index, 0, P.JsObject.prototype.$ind
ex.call(this, this, "length"))); | |
| 6386 } | |
| 6387 return P.JsObject.prototype.$index.call(this, this, index); | |
| 6388 }, | |
| 6389 $indexSet: function(_, index, value) { | |
| 6390 var t1; | |
| 6391 if (typeof index === "number" && index === C.JSNumber_methods.toInt$0(index)
) { | |
| 6392 if (typeof index === "number" && Math.floor(index) === index) | |
| 6393 if (!(index < 0)) { | |
| 6394 t1 = P.JsObject.prototype.$index.call(this, this, "length"); | |
| 6395 if (typeof t1 !== "number") | |
| 6396 throw H.iae(t1); | |
| 6397 t1 = index >= t1; | |
| 6398 } else | |
| 6399 t1 = true; | |
| 6400 else | |
| 6401 t1 = false; | |
| 6402 if (t1) | |
| 6403 H.throwExpression(P.RangeError$range(index, 0, P.JsObject.prototype.$ind
ex.call(this, this, "length"))); | |
| 6404 } | |
| 6405 P.JsObject.prototype.$indexSet.call(this, this, index, value); | |
| 6406 }, | |
| 6407 get$length: function(_) { | |
| 6408 return P.JsObject.prototype.$index.call(this, this, "length"); | |
| 6409 }, | |
| 6410 $asList: null, | |
| 6411 $asIterable: null | |
| 6412 }, | |
| 6413 | |
| 6414 JsObject_ListMixin: {"": "JsObject+ListMixin;", $isList: true, $asList: null, $i
sEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6415 | |
| 6416 _convertToJS_closure: {"": "Closure;", | |
| 6417 call$1: function(o) { | |
| 6418 var jsFunction = P._convertDartFunction(o, false); | |
| 6419 P._defineProperty(jsFunction, "_$dart_dartClosure", o); | |
| 6420 return jsFunction; | |
| 6421 }, | |
| 6422 "+call:1:0": 0, | |
| 6423 $isFunction: true, | |
| 6424 $is_args1: true | |
| 6425 }, | |
| 6426 | |
| 6427 _convertToJS_closure0: {"": "Closure;", | |
| 6428 call$1: function(o) { | |
| 6429 return new DartObject(o); | |
| 6430 }, | |
| 6431 "+call:1:0": 0, | |
| 6432 $isFunction: true, | |
| 6433 $is_args1: true | |
| 6434 }, | |
| 6435 | |
| 6436 _wrapToDart_closure: {"": "Closure;", | |
| 6437 call$1: function(o) { | |
| 6438 return new P.JsFunction(o); | |
| 6439 }, | |
| 6440 "+call:1:0": 0, | |
| 6441 $isFunction: true, | |
| 6442 $is_args1: true | |
| 6443 }, | |
| 6444 | |
| 6445 _wrapToDart_closure0: {"": "Closure;", | |
| 6446 call$1: function(o) { | |
| 6447 var t1 = new P.JsArray(o); | |
| 6448 H.setRuntimeTypeInfo(t1, [null]); | |
| 6449 return t1; | |
| 6450 }, | |
| 6451 "+call:1:0": 0, | |
| 6452 $isFunction: true, | |
| 6453 $is_args1: true | |
| 6454 }, | |
| 6455 | |
| 6456 _wrapToDart_closure1: {"": "Closure;", | |
| 6457 call$1: function(o) { | |
| 6458 return new P.JsObject(o); | |
| 6459 }, | |
| 6460 "+call:1:0": 0, | |
| 6461 $isFunction: true, | |
| 6462 $is_args1: true | |
| 6463 }}], | |
| 6464 ["dart.typed_data", "dart:typed_data", , P, { | |
| 6465 TypedData: {"": "Interceptor;", | |
| 6466 _invalidIndex$2: function(receiver, index, $length) { | |
| 6467 var t1 = J.getInterceptor$n(index); | |
| 6468 if (t1.$lt(index, 0) || t1.$ge(index, $length)) | |
| 6469 throw H.wrapException(P.RangeError$range(index, 0, $length)); | |
| 6470 else | |
| 6471 throw H.wrapException(new P.ArgumentError("Invalid list index " + H.S(inde
x))); | |
| 6472 }, | |
| 6473 $isTypedData: true, | |
| 6474 "%": "DataView;ArrayBufferView;TypedData_ListMixin|TypedData_ListMixin_FixedLe
ngthListMixin|TypedData_ListMixin0|TypedData_ListMixin_FixedLengthListMixin0|Typ
edData_ListMixin1|TypedData_ListMixin_FixedLengthListMixin1|TypedData_ListMixin2
|TypedData_ListMixin_FixedLengthListMixin2|TypedData_ListMixin3|TypedData_ListMi
xin_FixedLengthListMixin3|TypedData_ListMixin4|TypedData_ListMixin_FixedLengthLi
stMixin4|TypedData_ListMixin5|TypedData_ListMixin_FixedLengthListMixin5|TypedDat
a_ListMixin6|TypedData_ListMixin_FixedLengthListMixin6|TypedData_ListMixin7|Type
dData_ListMixin_FixedLengthListMixin7|Int64List|Uint64List" | |
| 6475 }, | |
| 6476 | |
| 6477 Float32List: {"": "TypedData_ListMixin_FixedLengthListMixin;", | |
| 6478 get$length: function(receiver) { | |
| 6479 return C.JS_CONST_ZYJ(receiver); | |
| 6480 }, | |
| 6481 $index: function(receiver, index) { | |
| 6482 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6483 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6484 this._invalidIndex$2(receiver, index, t1); | |
| 6485 return receiver[index]; | |
| 6486 }, | |
| 6487 $indexSet: function(receiver, index, value) { | |
| 6488 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6489 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6490 this._invalidIndex$2(receiver, index, t1); | |
| 6491 receiver[index] = value; | |
| 6492 }, | |
| 6493 $asList: function() { | |
| 6494 return [J.JSDouble]; | |
| 6495 }, | |
| 6496 $asIterable: function() { | |
| 6497 return [J.JSDouble]; | |
| 6498 }, | |
| 6499 $isList: true, | |
| 6500 $isEfficientLength: true, | |
| 6501 $isIterable: true, | |
| 6502 $isJavaScriptIndexingBehavior: true, | |
| 6503 "%": "Float32Array" | |
| 6504 }, | |
| 6505 | |
| 6506 Float64List: {"": "TypedData_ListMixin_FixedLengthListMixin0;", | |
| 6507 get$length: function(receiver) { | |
| 6508 return C.JS_CONST_ZYJ(receiver); | |
| 6509 }, | |
| 6510 $index: function(receiver, index) { | |
| 6511 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6512 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6513 this._invalidIndex$2(receiver, index, t1); | |
| 6514 return receiver[index]; | |
| 6515 }, | |
| 6516 $indexSet: function(receiver, index, value) { | |
| 6517 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6518 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6519 this._invalidIndex$2(receiver, index, t1); | |
| 6520 receiver[index] = value; | |
| 6521 }, | |
| 6522 $asList: function() { | |
| 6523 return [J.JSDouble]; | |
| 6524 }, | |
| 6525 $asIterable: function() { | |
| 6526 return [J.JSDouble]; | |
| 6527 }, | |
| 6528 $isList: true, | |
| 6529 $isEfficientLength: true, | |
| 6530 $isIterable: true, | |
| 6531 $isJavaScriptIndexingBehavior: true, | |
| 6532 "%": "Float64Array" | |
| 6533 }, | |
| 6534 | |
| 6535 Int16List: {"": "TypedData_ListMixin_FixedLengthListMixin1;", | |
| 6536 get$length: function(receiver) { | |
| 6537 return C.JS_CONST_ZYJ(receiver); | |
| 6538 }, | |
| 6539 $index: function(receiver, index) { | |
| 6540 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6541 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6542 this._invalidIndex$2(receiver, index, t1); | |
| 6543 return receiver[index]; | |
| 6544 }, | |
| 6545 $indexSet: function(receiver, index, value) { | |
| 6546 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6547 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6548 this._invalidIndex$2(receiver, index, t1); | |
| 6549 receiver[index] = value; | |
| 6550 }, | |
| 6551 $asList: function() { | |
| 6552 return [J.JSInt]; | |
| 6553 }, | |
| 6554 $asIterable: function() { | |
| 6555 return [J.JSInt]; | |
| 6556 }, | |
| 6557 $isList: true, | |
| 6558 $isEfficientLength: true, | |
| 6559 $isIterable: true, | |
| 6560 $isJavaScriptIndexingBehavior: true, | |
| 6561 "%": "Int16Array" | |
| 6562 }, | |
| 6563 | |
| 6564 Int32List: {"": "TypedData_ListMixin_FixedLengthListMixin2;", | |
| 6565 get$length: function(receiver) { | |
| 6566 return C.JS_CONST_ZYJ(receiver); | |
| 6567 }, | |
| 6568 $index: function(receiver, index) { | |
| 6569 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6570 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6571 this._invalidIndex$2(receiver, index, t1); | |
| 6572 return receiver[index]; | |
| 6573 }, | |
| 6574 $indexSet: function(receiver, index, value) { | |
| 6575 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6576 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6577 this._invalidIndex$2(receiver, index, t1); | |
| 6578 receiver[index] = value; | |
| 6579 }, | |
| 6580 $asList: function() { | |
| 6581 return [J.JSInt]; | |
| 6582 }, | |
| 6583 $asIterable: function() { | |
| 6584 return [J.JSInt]; | |
| 6585 }, | |
| 6586 $isList: true, | |
| 6587 $isEfficientLength: true, | |
| 6588 $isIterable: true, | |
| 6589 $isJavaScriptIndexingBehavior: true, | |
| 6590 "%": "Int32Array" | |
| 6591 }, | |
| 6592 | |
| 6593 Int8List: {"": "TypedData_ListMixin_FixedLengthListMixin3;", | |
| 6594 get$length: function(receiver) { | |
| 6595 return C.JS_CONST_ZYJ(receiver); | |
| 6596 }, | |
| 6597 $index: function(receiver, index) { | |
| 6598 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6599 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6600 this._invalidIndex$2(receiver, index, t1); | |
| 6601 return receiver[index]; | |
| 6602 }, | |
| 6603 $indexSet: function(receiver, index, value) { | |
| 6604 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6605 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6606 this._invalidIndex$2(receiver, index, t1); | |
| 6607 receiver[index] = value; | |
| 6608 }, | |
| 6609 $asList: function() { | |
| 6610 return [J.JSInt]; | |
| 6611 }, | |
| 6612 $asIterable: function() { | |
| 6613 return [J.JSInt]; | |
| 6614 }, | |
| 6615 $isList: true, | |
| 6616 $isEfficientLength: true, | |
| 6617 $isIterable: true, | |
| 6618 $isJavaScriptIndexingBehavior: true, | |
| 6619 "%": "Int8Array" | |
| 6620 }, | |
| 6621 | |
| 6622 Uint16List: {"": "TypedData_ListMixin_FixedLengthListMixin4;", | |
| 6623 get$length: function(receiver) { | |
| 6624 return C.JS_CONST_ZYJ(receiver); | |
| 6625 }, | |
| 6626 $index: function(receiver, index) { | |
| 6627 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6628 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6629 this._invalidIndex$2(receiver, index, t1); | |
| 6630 return receiver[index]; | |
| 6631 }, | |
| 6632 $indexSet: function(receiver, index, value) { | |
| 6633 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6634 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6635 this._invalidIndex$2(receiver, index, t1); | |
| 6636 receiver[index] = value; | |
| 6637 }, | |
| 6638 $asList: function() { | |
| 6639 return [J.JSInt]; | |
| 6640 }, | |
| 6641 $asIterable: function() { | |
| 6642 return [J.JSInt]; | |
| 6643 }, | |
| 6644 $isList: true, | |
| 6645 $isEfficientLength: true, | |
| 6646 $isIterable: true, | |
| 6647 $isJavaScriptIndexingBehavior: true, | |
| 6648 "%": "Uint16Array" | |
| 6649 }, | |
| 6650 | |
| 6651 Uint32List: {"": "TypedData_ListMixin_FixedLengthListMixin5;", | |
| 6652 get$length: function(receiver) { | |
| 6653 return C.JS_CONST_ZYJ(receiver); | |
| 6654 }, | |
| 6655 $index: function(receiver, index) { | |
| 6656 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6657 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6658 this._invalidIndex$2(receiver, index, t1); | |
| 6659 return receiver[index]; | |
| 6660 }, | |
| 6661 $indexSet: function(receiver, index, value) { | |
| 6662 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6663 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6664 this._invalidIndex$2(receiver, index, t1); | |
| 6665 receiver[index] = value; | |
| 6666 }, | |
| 6667 $asList: function() { | |
| 6668 return [J.JSInt]; | |
| 6669 }, | |
| 6670 $asIterable: function() { | |
| 6671 return [J.JSInt]; | |
| 6672 }, | |
| 6673 $isList: true, | |
| 6674 $isEfficientLength: true, | |
| 6675 $isIterable: true, | |
| 6676 $isJavaScriptIndexingBehavior: true, | |
| 6677 "%": "Uint32Array" | |
| 6678 }, | |
| 6679 | |
| 6680 Uint8ClampedList: {"": "TypedData_ListMixin_FixedLengthListMixin6;", | |
| 6681 get$length: function(receiver) { | |
| 6682 return C.JS_CONST_ZYJ(receiver); | |
| 6683 }, | |
| 6684 $index: function(receiver, index) { | |
| 6685 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6686 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6687 this._invalidIndex$2(receiver, index, t1); | |
| 6688 return receiver[index]; | |
| 6689 }, | |
| 6690 $indexSet: function(receiver, index, value) { | |
| 6691 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6692 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6693 this._invalidIndex$2(receiver, index, t1); | |
| 6694 receiver[index] = value; | |
| 6695 }, | |
| 6696 $asList: function() { | |
| 6697 return [J.JSInt]; | |
| 6698 }, | |
| 6699 $asIterable: function() { | |
| 6700 return [J.JSInt]; | |
| 6701 }, | |
| 6702 $isList: true, | |
| 6703 $isEfficientLength: true, | |
| 6704 $isIterable: true, | |
| 6705 $isJavaScriptIndexingBehavior: true, | |
| 6706 "%": "CanvasPixelArray|Uint8ClampedArray" | |
| 6707 }, | |
| 6708 | |
| 6709 Uint8List: {"": "TypedData_ListMixin_FixedLengthListMixin7;", | |
| 6710 get$length: function(receiver) { | |
| 6711 return C.JS_CONST_ZYJ(receiver); | |
| 6712 }, | |
| 6713 $index: function(receiver, index) { | |
| 6714 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6715 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6716 this._invalidIndex$2(receiver, index, t1); | |
| 6717 return receiver[index]; | |
| 6718 }, | |
| 6719 $indexSet: function(receiver, index, value) { | |
| 6720 var t1 = C.JS_CONST_ZYJ(receiver); | |
| 6721 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
| 6722 this._invalidIndex$2(receiver, index, t1); | |
| 6723 receiver[index] = value; | |
| 6724 }, | |
| 6725 $asList: function() { | |
| 6726 return [J.JSInt]; | |
| 6727 }, | |
| 6728 $asIterable: function() { | |
| 6729 return [J.JSInt]; | |
| 6730 }, | |
| 6731 $isList: true, | |
| 6732 $isEfficientLength: true, | |
| 6733 $isIterable: true, | |
| 6734 $isJavaScriptIndexingBehavior: true, | |
| 6735 "%": ";Uint8Array" | |
| 6736 }, | |
| 6737 | |
| 6738 TypedData_ListMixin: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6739 | |
| 6740 TypedData_ListMixin_FixedLengthListMixin: {"": "TypedData_ListMixin+FixedLengthL
istMixin;", $asList: null, $asIterable: null}, | |
| 6741 | |
| 6742 TypedData_ListMixin0: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6743 | |
| 6744 TypedData_ListMixin_FixedLengthListMixin0: {"": "TypedData_ListMixin0+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6745 | |
| 6746 TypedData_ListMixin1: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6747 | |
| 6748 TypedData_ListMixin_FixedLengthListMixin1: {"": "TypedData_ListMixin1+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6749 | |
| 6750 TypedData_ListMixin2: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6751 | |
| 6752 TypedData_ListMixin_FixedLengthListMixin2: {"": "TypedData_ListMixin2+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6753 | |
| 6754 TypedData_ListMixin3: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6755 | |
| 6756 TypedData_ListMixin_FixedLengthListMixin3: {"": "TypedData_ListMixin3+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6757 | |
| 6758 TypedData_ListMixin4: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6759 | |
| 6760 TypedData_ListMixin_FixedLengthListMixin4: {"": "TypedData_ListMixin4+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6761 | |
| 6762 TypedData_ListMixin5: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6763 | |
| 6764 TypedData_ListMixin_FixedLengthListMixin5: {"": "TypedData_ListMixin5+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6765 | |
| 6766 TypedData_ListMixin6: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6767 | |
| 6768 TypedData_ListMixin_FixedLengthListMixin6: {"": "TypedData_ListMixin6+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6769 | |
| 6770 TypedData_ListMixin7: {"": "TypedData+ListMixin;", $isList: true, $asList: null,
$isEfficientLength: true, $isIterable: true, $asIterable: null}, | |
| 6771 | |
| 6772 TypedData_ListMixin_FixedLengthListMixin7: {"": "TypedData_ListMixin7+FixedLengt
hListMixin;", $asList: null, $asIterable: null}, | |
| 6773 | |
| 6774 Int64List: {"": "TypedData;", $isList: true, | |
| 6775 $asList: function() { | |
| 6776 return [J.JSInt]; | |
| 6777 }, | |
| 6778 $isEfficientLength: true, | |
| 6779 $isIterable: true, | |
| 6780 $asIterable: function() { | |
| 6781 return [J.JSInt]; | |
| 6782 }, | |
| 6783 $isJavaScriptIndexingBehavior: true, | |
| 6784 static: { | |
| 6785 "": "Int64List_BYTES_PER_ELEMENT", | |
| 6786 } | |
| 6787 | |
| 6788 }, | |
| 6789 | |
| 6790 Uint64List: {"": "TypedData;", $isList: true, | |
| 6791 $asList: function() { | |
| 6792 return [J.JSInt]; | |
| 6793 }, | |
| 6794 $isEfficientLength: true, | |
| 6795 $isIterable: true, | |
| 6796 $asIterable: function() { | |
| 6797 return [J.JSInt]; | |
| 6798 }, | |
| 6799 $isJavaScriptIndexingBehavior: true, | |
| 6800 static: { | |
| 6801 "": "Uint64List_BYTES_PER_ELEMENT", | |
| 6802 } | |
| 6803 | |
| 6804 }}], | |
| 6805 ["", "gauge.dart", , Y, { | |
| 6806 main: function() { | |
| 6807 Y.Gauge_load().then$1(new Y.main_closure()); | |
| 6808 }, | |
| 6809 | |
| 6810 Gauge: {"": "Object;jsOptions,jsTable,jsChart,_gauge$_value", | |
| 6811 draw$0: function() { | |
| 6812 this.jsTable.callMethod$2("setValue", [0, 1, this._gauge$_value]); | |
| 6813 this.jsChart.callMethod$2("draw", [this.jsTable, this.jsOptions]); | |
| 6814 }, | |
| 6815 Gauge$4: function(element, title, _value, options) { | |
| 6816 var t1, vis; | |
| 6817 t1 = this._gauge$_value; | |
| 6818 vis = J.$index$asx(J.$index$asx($.get$context(), "google"), "visualization")
; | |
| 6819 this.jsTable = vis.callMethod$2("arrayToDataTable", [P.JsObject_JsObject$jsi
fy([["Label", "Value"], [title, t1]])]); | |
| 6820 this.jsChart = P.JsObject_JsObject(J.$index$asx(vis, "Gauge"), [element]); | |
| 6821 this.jsOptions = P.JsObject_JsObject$jsify(options); | |
| 6822 this.draw$0(); | |
| 6823 }, | |
| 6824 static: { | |
| 6825 Gauge$: function(element, title, _value, options) { | |
| 6826 var t1 = new Y.Gauge(null, null, null, _value); | |
| 6827 t1.Gauge$4(element, title, _value, options); | |
| 6828 return t1; | |
| 6829 }, | |
| 6830 | |
| 6831 Gauge_load: function() { | |
| 6832 var t1, c; | |
| 6833 t1 = null; | |
| 6834 c = new P._AsyncCompleter(P._Future$(t1)); | |
| 6835 H.setRuntimeTypeInfo(c, [t1]); | |
| 6836 J.$index$asx($.get$context(), "google").callMethod$2("load", ["visualization",
"1", P.JsObject_JsObject$jsify(H.fillLiteralMap(["packages", ["gauge"], "callba
ck", P.JsFunction_JsFunction$withThis(c.get$complete(c))], P.LinkedHashMap_Linke
dHashMap(null, null, null, null, null)))]); | |
| 6837 return c.future; | |
| 6838 }} | |
| 6839 | |
| 6840 }, | |
| 6841 | |
| 6842 main_closure: {"": "Closure;", | |
| 6843 call$1: function(_) { | |
| 6844 var t1, gauge, t2; | |
| 6845 t1 = new Y.main__sliderValue(); | |
| 6846 gauge = Y.Gauge$($.get$visualization(), "Slider", t1.call$0(), H.fillLiteral
Map(["min", 0, "max", 280, "yellowFrom", 200, "yellowTo", 250, "redFrom", 250, "
redTo", 280, "minorTicks", 5], P.LinkedHashMap_LinkedHashMap(null, null, null, n
ull, null))); | |
| 6847 t2 = $.get$slider(); | |
| 6848 t2.toString; | |
| 6849 t2 = new W._ElementEventStreamImpl(t2, C.EventStreamProvider_change._eventTy
pe, false); | |
| 6850 H.setRuntimeTypeInfo(t2, [null]); | |
| 6851 t1 = new W._EventStreamSubscription(0, t2._target, t2._eventType, W._wrapZon
e(new Y.main__closure(t1, gauge)), t2._useCapture); | |
| 6852 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(t2, "_EventStream", 0)]); | |
| 6853 t1._tryResume$0(); | |
| 6854 }, | |
| 6855 "+call:1:0": 0, | |
| 6856 $isFunction: true, | |
| 6857 $is_args1: true | |
| 6858 }, | |
| 6859 | |
| 6860 main__sliderValue: {"": "Closure;", | |
| 6861 call$0: function() { | |
| 6862 return H.Primitives_parseInt(J.get$value$x($.get$slider()), null, null); | |
| 6863 }, | |
| 6864 "+call:0:0": 0, | |
| 6865 $isFunction: true | |
| 6866 }, | |
| 6867 | |
| 6868 main__closure: {"": "Closure;sliderValue_0,gauge_1", | |
| 6869 call$1: function(_) { | |
| 6870 var t1, t2; | |
| 6871 t1 = this.gauge_1; | |
| 6872 t2 = this.sliderValue_0.call$0(); | |
| 6873 t1._gauge$_value = t2; | |
| 6874 t1.draw$0(); | |
| 6875 return t2; | |
| 6876 }, | |
| 6877 "+call:1:0": 0, | |
| 6878 $isFunction: true, | |
| 6879 $is_args1: true | |
| 6880 }}, | |
| 6881 1], | |
| 6882 ]); | |
| 6883 Isolate.$finishClasses($$, $, null); | |
| 6884 $$ = null; | |
| 6885 | |
| 6886 // Static function getters | |
| 6887 init.globalFunctions.IsolateNatives__processWorkerMessage$closure = H.IsolateNat
ives__processWorkerMessage$closure = new H.Closure$2(H.IsolateNatives__processWo
rkerMessage, "IsolateNatives__processWorkerMessage$closure"); | |
| 6888 init.globalFunctions.Primitives__throwFormatException$closure = H.Primitives__th
rowFormatException$closure = new H.Closure$1(H.Primitives__throwFormatException,
"Primitives__throwFormatException$closure"); | |
| 6889 init.globalFunctions.toStringWrapper$closure = H.toStringWrapper$closure = new H
.Closure$0(H.toStringWrapper, "toStringWrapper$closure"); | |
| 6890 init.globalFunctions.invokeClosure$closure = H.invokeClosure$closure = new H.Clo
sure$7(H.invokeClosure, "invokeClosure$closure"); | |
| 6891 init.globalFunctions._asyncRunCallback$closure = P._asyncRunCallback$closure = n
ew H.Closure$0(P._asyncRunCallback, "_asyncRunCallback$closure"); | |
| 6892 init.globalFunctions._nullDataHandler$closure = P._nullDataHandler$closure = new
H.Closure$1(P._nullDataHandler, "_nullDataHandler$closure"); | |
| 6893 init.globalFunctions._nullErrorHandler$closure = P._nullErrorHandler$closure = n
ew P.Closure$20(P._nullErrorHandler, "_nullErrorHandler$closure"); | |
| 6894 init.globalFunctions._nullDoneHandler$closure = P._nullDoneHandler$closure = new
H.Closure$0(P._nullDoneHandler, "_nullDoneHandler$closure"); | |
| 6895 init.globalFunctions._defaultEquals$closure = P._defaultEquals$closure = new H.C
losure$2(P._defaultEquals, "_defaultEquals$closure"); | |
| 6896 init.globalFunctions._defaultHashCode$closure = P._defaultHashCode$closure = new
H.Closure$1(P._defaultHashCode, "_defaultHashCode$closure"); | |
| 6897 init.globalFunctions.identical$closure = P.identical$closure = new H.Closure$2(P
.identical, "identical$closure"); | |
| 6898 init.globalFunctions.identityHashCode$closure = P.identityHashCode$closure = new
H.Closure$1(P.identityHashCode, "identityHashCode$closure"); | |
| 6899 init.globalFunctions._callDartFunction$closure = P._callDartFunction$closure = n
ew P.Closure$4(P._callDartFunction, "_callDartFunction$closure"); | |
| 6900 init.globalFunctions._convertToJS$closure = P._convertToJS$closure = new H.Closu
re$1(P._convertToJS, "_convertToJS$closure"); | |
| 6901 init.globalFunctions._convertToDart$closure = P._convertToDart$closure = new H.C
losure$1(P._convertToDart, "_convertToDart$closure"); | |
| 6902 init.globalFunctions.main$closure = Y.main$closure = new H.Closure$0(Y.main, "ma
in$closure"); | |
| 6903 // Runtime type support | |
| 6904 J.JSInt.$isint = true; | |
| 6905 J.JSInt.$isObject = true; | |
| 6906 J.JSDouble.$isObject = true; | |
| 6907 J.JSString.$isString = true; | |
| 6908 J.JSString.$isObject = true; | |
| 6909 J.JSNumber.$isObject = true; | |
| 6910 P.Duration.$isObject = true; | |
| 6911 W.Event.$isObject = true; | |
| 6912 P.Symbol.$isSymbol = true; | |
| 6913 P.Symbol.$isObject = true; | |
| 6914 P.ReceivePort.$isObject = true; | |
| 6915 H._IsolateEvent.$isObject = true; | |
| 6916 H._IsolateContext.$isObject = true; | |
| 6917 J.JSArray.$isList = true; | |
| 6918 J.JSArray.$isObject = true; | |
| 6919 P.StackTrace.$isStackTrace = true; | |
| 6920 P.StackTrace.$isObject = true; | |
| 6921 P.Object.$isObject = true; | |
| 6922 P.Function.$isFunction = true; | |
| 6923 P.Function.$isObject = true; | |
| 6924 J.JSBool.$isbool = true; | |
| 6925 J.JSBool.$isObject = true; | |
| 6926 P._EventSink.$is_EventSink = true; | |
| 6927 P._EventSink.$isObject = true; | |
| 6928 P.Future.$isFuture = true; | |
| 6929 P.Future.$isObject = true; | |
| 6930 P.StreamSubscription.$isStreamSubscription = true; | |
| 6931 P.StreamSubscription.$isObject = true; | |
| 6932 // getInterceptor methods | |
| 6933 J.getInterceptor = function(receiver) { | |
| 6934 if (typeof receiver == "number") { | |
| 6935 if (Math.floor(receiver) == receiver) | |
| 6936 return J.JSInt.prototype; | |
| 6937 return J.JSDouble.prototype; | |
| 6938 } | |
| 6939 if (typeof receiver == "string") | |
| 6940 return J.JSString.prototype; | |
| 6941 if (receiver == null) | |
| 6942 return J.JSNull.prototype; | |
| 6943 if (typeof receiver == "boolean") | |
| 6944 return J.JSBool.prototype; | |
| 6945 if (receiver.constructor == Array) | |
| 6946 return J.JSArray.prototype; | |
| 6947 if (typeof receiver != "object") | |
| 6948 return receiver; | |
| 6949 if (receiver instanceof P.Object) | |
| 6950 return receiver; | |
| 6951 return J.getNativeInterceptor(receiver); | |
| 6952 }; | |
| 6953 J.getInterceptor$asx = function(receiver) { | |
| 6954 if (typeof receiver == "string") | |
| 6955 return J.JSString.prototype; | |
| 6956 if (receiver == null) | |
| 6957 return receiver; | |
| 6958 if (receiver.constructor == Array) | |
| 6959 return J.JSArray.prototype; | |
| 6960 if (typeof receiver != "object") | |
| 6961 return receiver; | |
| 6962 if (receiver instanceof P.Object) | |
| 6963 return receiver; | |
| 6964 return J.getNativeInterceptor(receiver); | |
| 6965 }; | |
| 6966 J.getInterceptor$ax = function(receiver) { | |
| 6967 if (receiver == null) | |
| 6968 return receiver; | |
| 6969 if (receiver.constructor == Array) | |
| 6970 return J.JSArray.prototype; | |
| 6971 if (typeof receiver != "object") | |
| 6972 return receiver; | |
| 6973 if (receiver instanceof P.Object) | |
| 6974 return receiver; | |
| 6975 return J.getNativeInterceptor(receiver); | |
| 6976 }; | |
| 6977 J.getInterceptor$n = function(receiver) { | |
| 6978 if (typeof receiver == "number") | |
| 6979 return J.JSNumber.prototype; | |
| 6980 if (receiver == null) | |
| 6981 return receiver; | |
| 6982 if (!(receiver instanceof P.Object)) | |
| 6983 return J.UnknownJavaScriptObject.prototype; | |
| 6984 return receiver; | |
| 6985 }; | |
| 6986 J.getInterceptor$s = function(receiver) { | |
| 6987 if (typeof receiver == "string") | |
| 6988 return J.JSString.prototype; | |
| 6989 if (receiver == null) | |
| 6990 return receiver; | |
| 6991 if (!(receiver instanceof P.Object)) | |
| 6992 return J.UnknownJavaScriptObject.prototype; | |
| 6993 return receiver; | |
| 6994 }; | |
| 6995 J.getInterceptor$x = function(receiver) { | |
| 6996 if (receiver == null) | |
| 6997 return receiver; | |
| 6998 if (typeof receiver != "object") | |
| 6999 return receiver; | |
| 7000 if (receiver instanceof P.Object) | |
| 7001 return receiver; | |
| 7002 return J.getNativeInterceptor(receiver); | |
| 7003 }; | |
| 7004 C.C__DelayedDone = new P._DelayedDone(); | |
| 7005 C.C__RootZone = new P._RootZone(); | |
| 7006 C.Duration_0 = new P.Duration(0); | |
| 7007 C.EventStreamProvider_change = new W.EventStreamProvider("change"); | |
| 7008 C.JSArray_methods = J.JSArray.prototype; | |
| 7009 C.JSInt_methods = J.JSInt.prototype; | |
| 7010 C.JSNumber_methods = J.JSNumber.prototype; | |
| 7011 C.JSString_methods = J.JSString.prototype; | |
| 7012 C.JS_CONST_0 = function(hooks) { | |
| 7013 if (typeof dartExperimentalFixupGetTag != "function") return hooks; | |
| 7014 hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); | |
| 7015 }; | |
| 7016 C.JS_CONST_6qb = function(hooks) { | |
| 7017 var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
| 7018 if (userAgent.indexOf("Firefox") == -1) return hooks; | |
| 7019 var getTag = hooks.getTag; | |
| 7020 var quickMap = { | |
| 7021 "BeforeUnloadEvent": "Event", | |
| 7022 "DataTransfer": "Clipboard", | |
| 7023 "GeoGeolocation": "Geolocation", | |
| 7024 "WorkerMessageEvent": "MessageEvent", | |
| 7025 "XMLDocument": "Document"}; | |
| 7026 function getTagFirefox(o) { | |
| 7027 var tag = getTag(o); | |
| 7028 return quickMap[tag] || tag; | |
| 7029 } | |
| 7030 hooks.getTag = getTagFirefox; | |
| 7031 }; | |
| 7032 C.JS_CONST_86y = function getTagFallback(o) { | |
| 7033 if (o == null) return "Null"; | |
| 7034 var constructor = o.constructor; | |
| 7035 if (typeof constructor == "function") { | |
| 7036 var name = constructor.builtin$cls; | |
| 7037 if (typeof name == "string") return name; | |
| 7038 name = constructor.name; | |
| 7039 if (typeof name == "string" | |
| 7040 && name !== "" | |
| 7041 && name !== "Object" | |
| 7042 && name !== "Function.prototype") { | |
| 7043 return name; | |
| 7044 } | |
| 7045 } | |
| 7046 var s = Object.prototype.toString.call(o); | |
| 7047 return s.substring(8, s.length - 1); | |
| 7048 }; | |
| 7049 C.JS_CONST_Cbr = function(getTagFallback) { | |
| 7050 return function(hooks) { | |
| 7051 if (typeof navigator != "object") return hooks; | |
| 7052 var userAgent = navigator.userAgent; | |
| 7053 if (userAgent.indexOf("Chrome") >= 0 || | |
| 7054 userAgent.indexOf("DumpRenderTree") >= 0) { | |
| 7055 return hooks; | |
| 7056 } | |
| 7057 hooks.getTag = getTagFallback; | |
| 7058 }; | |
| 7059 }; | |
| 7060 C.JS_CONST_Fs4 = function(hooks) { return hooks; } | |
| 7061 ; | |
| 7062 C.JS_CONST_TtD = function() { | |
| 7063 function typeNameInChrome(obj) { return obj.constructor.name; } | |
| 7064 function getUnknownTag(object, tag) { | |
| 7065 if (/^HTML[A-Z].*Element$/.test(tag)) { | |
| 7066 var name = Object.prototype.toString.call(object); | |
| 7067 if (name == "[object Object]") return null; | |
| 7068 return "HTMLElement"; | |
| 7069 } | |
| 7070 } | |
| 7071 function getUnknownTagGenericBrowser(object, tag) { | |
| 7072 if (object instanceof HTMLElement) return "HTMLElement"; | |
| 7073 return getUnknownTag(object, tag); | |
| 7074 } | |
| 7075 function prototypeForTag(tag) { | |
| 7076 if (typeof window == "undefined") return null; | |
| 7077 if (typeof window[tag] == "undefined") return null; | |
| 7078 var constructor = window[tag]; | |
| 7079 if (typeof constructor != "function") return null; | |
| 7080 return constructor.prototype; | |
| 7081 } | |
| 7082 function discriminator(tag) { return null; } | |
| 7083 var isBrowser = typeof navigator == "object"; | |
| 7084 return { | |
| 7085 getTag: typeNameInChrome, | |
| 7086 getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, | |
| 7087 prototypeForTag: prototypeForTag, | |
| 7088 discriminator: discriminator }; | |
| 7089 }; | |
| 7090 C.JS_CONST_ZYJ = ((typeof version == "function" && typeof os == "object" &&
"system" in os) | |
| 7091 || (typeof navigator == "object" | |
| 7092 && navigator.userAgent.indexOf('Chrome') != -1)) | |
| 7093 ? function(x) { return x.$dartCachedLength || x.length; } | |
| 7094 : function(x) { return x.length; }; | |
| 7095 ; | |
| 7096 C.JS_CONST_rD3 = function(hooks) { | |
| 7097 var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
| 7098 if (userAgent.indexOf("Trident/") == -1) return hooks; | |
| 7099 var getTag = hooks.getTag; | |
| 7100 var quickMap = { | |
| 7101 "BeforeUnloadEvent": "Event", | |
| 7102 "DataTransfer": "Clipboard", | |
| 7103 "HTMLDDElement": "HTMLElement", | |
| 7104 "HTMLDTElement": "HTMLElement", | |
| 7105 "HTMLPhraseElement": "HTMLElement", | |
| 7106 "Position": "Geoposition" | |
| 7107 }; | |
| 7108 function getTagIE(o) { | |
| 7109 var tag = getTag(o); | |
| 7110 var newTag = quickMap[tag]; | |
| 7111 if (newTag) return newTag; | |
| 7112 if (tag == "Document") { | |
| 7113 if (!!o.xmlVersion) return "!Document"; | |
| 7114 return "!HTMLDocument"; | |
| 7115 } | |
| 7116 if (tag == "Object") { | |
| 7117 if (window.DataView && (o instanceof window.DataView)) return "DataView"; | |
| 7118 } | |
| 7119 return tag; | |
| 7120 } | |
| 7121 function prototypeForTagIE(tag) { | |
| 7122 if (tag == "Document") return null; | |
| 7123 var constructor = window[tag]; | |
| 7124 if (constructor == null) return null; | |
| 7125 return constructor.prototype; | |
| 7126 } | |
| 7127 hooks.getTag = getTagIE; | |
| 7128 hooks.prototypeForTag = prototypeForTagIE; | |
| 7129 }; | |
| 7130 Isolate.makeConstantList = function(list) { | |
| 7131 list.immutable$list = true; | |
| 7132 list.fixed$length = true; | |
| 7133 return list; | |
| 7134 }; | |
| 7135 C.List_empty = Isolate.makeConstantList([]); | |
| 7136 C.Symbol_call = new H.Symbol0("call"); | |
| 7137 C.Type_oqh = H.createRuntimeType('Uint64List'); | |
| 7138 C.Type_qxd = H.createRuntimeType('Int64List'); | |
| 7139 C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; | |
| 7140 $.lazyPort = null; | |
| 7141 $.ReceivePortImpl__nextFreeId = 1; | |
| 7142 $.Primitives_mirrorFunctionCacheName = "$cachedFunction"; | |
| 7143 $.Primitives_mirrorInvokeCacheName = "$cachedInvocation"; | |
| 7144 $.getTagFunction = null; | |
| 7145 $.alternateTagFunction = null; | |
| 7146 $.prototypeForTagFunction = null; | |
| 7147 $.dispatchRecordsForInstanceTags = null; | |
| 7148 $.interceptorsForUncacheableTags = null; | |
| 7149 $.initNativeDispatchFlag = null; | |
| 7150 $.printToZone = null; | |
| 7151 $._callbacksAreEnqueued = false; | |
| 7152 $.Zone__current = C.C__RootZone; | |
| 7153 $.Expando__keyCount = 0; | |
| 7154 $.Device__isOpera = null; | |
| 7155 $.Device__isWebKit = null; | |
| 7156 J.$eq = function(receiver, a0) { | |
| 7157 if (receiver == null) | |
| 7158 return a0 == null; | |
| 7159 if (typeof receiver != "object") | |
| 7160 return a0 != null && receiver === a0; | |
| 7161 return J.getInterceptor(receiver).$eq(receiver, a0); | |
| 7162 }; | |
| 7163 J.$ge$n = function(receiver, a0) { | |
| 7164 if (typeof receiver == "number" && typeof a0 == "number") | |
| 7165 return receiver >= a0; | |
| 7166 return J.getInterceptor$n(receiver).$ge(receiver, a0); | |
| 7167 }; | |
| 7168 J.$gt$n = function(receiver, a0) { | |
| 7169 if (typeof receiver == "number" && typeof a0 == "number") | |
| 7170 return receiver > a0; | |
| 7171 return J.getInterceptor$n(receiver).$gt(receiver, a0); | |
| 7172 }; | |
| 7173 J.$index$asx = function(receiver, a0) { | |
| 7174 if (receiver.constructor == Array || typeof receiver == "string" || H.isJsInde
xable(receiver, receiver[init.dispatchPropertyName])) | |
| 7175 if (a0 >>> 0 === a0 && a0 < receiver.length) | |
| 7176 return receiver[a0]; | |
| 7177 return J.getInterceptor$asx(receiver).$index(receiver, a0); | |
| 7178 }; | |
| 7179 J.$indexSet$ax = function(receiver, a0, a1) { | |
| 7180 if ((receiver.constructor == Array || H.isJsIndexable(receiver, receiver[init.
dispatchPropertyName])) && !receiver.immutable$list && a0 >>> 0 === a0 && a0 < r
eceiver.length) | |
| 7181 return receiver[a0] = a1; | |
| 7182 return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); | |
| 7183 }; | |
| 7184 J.$shl$n = function(receiver, a0) { | |
| 7185 return J.getInterceptor$n(receiver).$shl(receiver, a0); | |
| 7186 }; | |
| 7187 J.addEventListener$3$x = function(receiver, a0, a1, a2) { | |
| 7188 return J.getInterceptor$x(receiver).addEventListener$3(receiver, a0, a1, a2); | |
| 7189 }; | |
| 7190 J.elementAt$1$ax = function(receiver, a0) { | |
| 7191 return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); | |
| 7192 }; | |
| 7193 J.forEach$1$ax = function(receiver, a0) { | |
| 7194 return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); | |
| 7195 }; | |
| 7196 J.get$error$x = function(receiver) { | |
| 7197 return J.getInterceptor$x(receiver).get$error(receiver); | |
| 7198 }; | |
| 7199 J.get$hashCode$ = function(receiver) { | |
| 7200 return J.getInterceptor(receiver).get$hashCode(receiver); | |
| 7201 }; | |
| 7202 J.get$iterator$ax = function(receiver) { | |
| 7203 return J.getInterceptor$ax(receiver).get$iterator(receiver); | |
| 7204 }; | |
| 7205 J.get$length$asx = function(receiver) { | |
| 7206 return J.getInterceptor$asx(receiver).get$length(receiver); | |
| 7207 }; | |
| 7208 J.get$value$x = function(receiver) { | |
| 7209 return J.getInterceptor$x(receiver).get$value(receiver); | |
| 7210 }; | |
| 7211 J.map$1$ax = function(receiver, a0) { | |
| 7212 return J.getInterceptor$ax(receiver).map$1(receiver, a0); | |
| 7213 }; | |
| 7214 J.noSuchMethod$1 = function(receiver, a0) { | |
| 7215 return J.getInterceptor(receiver).noSuchMethod$1(receiver, a0); | |
| 7216 }; | |
| 7217 J.removeEventListener$3$x = function(receiver, a0, a1, a2) { | |
| 7218 return J.getInterceptor$x(receiver).removeEventListener$3(receiver, a0, a1, a2
); | |
| 7219 }; | |
| 7220 J.toString$0 = function(receiver) { | |
| 7221 return J.getInterceptor(receiver).toString$0(receiver); | |
| 7222 }; | |
| 7223 Isolate.$lazy($, "globalThis", "globalThis", "get$globalThis", function() { | |
| 7224 return function() { return this; }(); | |
| 7225 }); | |
| 7226 Isolate.$lazy($, "globalWindow", "globalWindow", "get$globalWindow", function()
{ | |
| 7227 return $.get$globalThis().window; | |
| 7228 }); | |
| 7229 Isolate.$lazy($, "globalWorker", "globalWorker", "get$globalWorker", function()
{ | |
| 7230 return $.get$globalThis().Worker; | |
| 7231 }); | |
| 7232 Isolate.$lazy($, "globalPostMessageDefined", "globalPostMessageDefined", "get$gl
obalPostMessageDefined", function() { | |
| 7233 return $.get$globalThis().postMessage !== void 0; | |
| 7234 }); | |
| 7235 Isolate.$lazy($, "thisScript", "IsolateNatives_thisScript", "get$IsolateNatives_
thisScript", function() { | |
| 7236 return H.IsolateNatives_computeThisScript(); | |
| 7237 }); | |
| 7238 Isolate.$lazy($, "workerIds", "IsolateNatives_workerIds", "get$IsolateNatives_wo
rkerIds", function() { | |
| 7239 return new P.Expando(null); | |
| 7240 }); | |
| 7241 Isolate.$lazy($, "noSuchMethodPattern", "TypeErrorDecoder_noSuchMethodPattern",
"get$TypeErrorDecoder_noSuchMethodPattern", function() { | |
| 7242 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
({ toString: function() { return "$receiver$"; } })); | |
| 7243 }); | |
| 7244 Isolate.$lazy($, "notClosurePattern", "TypeErrorDecoder_notClosurePattern", "get
$TypeErrorDecoder_notClosurePattern", function() { | |
| 7245 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
({ $method$: null, toString: function() { return "$receiver$"; } })); | |
| 7246 }); | |
| 7247 Isolate.$lazy($, "nullCallPattern", "TypeErrorDecoder_nullCallPattern", "get$Typ
eErrorDecoder_nullCallPattern", function() { | |
| 7248 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
(null)); | |
| 7249 }); | |
| 7250 Isolate.$lazy($, "nullLiteralCallPattern", "TypeErrorDecoder_nullLiteralCallPatt
ern", "get$TypeErrorDecoder_nullLiteralCallPattern", function() { | |
| 7251 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
Null()); | |
| 7252 }); | |
| 7253 Isolate.$lazy($, "undefinedCallPattern", "TypeErrorDecoder_undefinedCallPattern"
, "get$TypeErrorDecoder_undefinedCallPattern", function() { | |
| 7254 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
(void 0)); | |
| 7255 }); | |
| 7256 Isolate.$lazy($, "undefinedLiteralCallPattern", "TypeErrorDecoder_undefinedLiter
alCallPattern", "get$TypeErrorDecoder_undefinedLiteralCallPattern", function() { | |
| 7257 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
Undefined()); | |
| 7258 }); | |
| 7259 Isolate.$lazy($, "nullPropertyPattern", "TypeErrorDecoder_nullPropertyPattern",
"get$TypeErrorDecoder_nullPropertyPattern", function() { | |
| 7260 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOn(null)); | |
| 7261 }); | |
| 7262 Isolate.$lazy($, "nullLiteralPropertyPattern", "TypeErrorDecoder_nullLiteralProp
ertyPattern", "get$TypeErrorDecoder_nullLiteralPropertyPattern", function() { | |
| 7263 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOnNull()); | |
| 7264 }); | |
| 7265 Isolate.$lazy($, "undefinedPropertyPattern", "TypeErrorDecoder_undefinedProperty
Pattern", "get$TypeErrorDecoder_undefinedPropertyPattern", function() { | |
| 7266 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOn(void 0)); | |
| 7267 }); | |
| 7268 Isolate.$lazy($, "undefinedLiteralPropertyPattern", "TypeErrorDecoder_undefinedL
iteralPropertyPattern", "get$TypeErrorDecoder_undefinedLiteralPropertyPattern",
function() { | |
| 7269 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOnUndefined()); | |
| 7270 }); | |
| 7271 Isolate.$lazy($, "_toStringList", "IterableMixinWorkaround__toStringList", "get$
IterableMixinWorkaround__toStringList", function() { | |
| 7272 return P.List_List(null, null); | |
| 7273 }); | |
| 7274 Isolate.$lazy($, "_asyncCallbacks", "_asyncCallbacks", "get$_asyncCallbacks", fu
nction() { | |
| 7275 return P.ListQueue$(null, {func: "void_", void: true}); | |
| 7276 }); | |
| 7277 Isolate.$lazy($, "_toStringVisiting", "_toStringVisiting", "get$_toStringVisitin
g", function() { | |
| 7278 return P.HashSet_HashSet$identity(null); | |
| 7279 }); | |
| 7280 Isolate.$lazy($, "_toStringList", "Maps__toStringList", "get$Maps__toStringList"
, function() { | |
| 7281 return P.List_List(null, null); | |
| 7282 }); | |
| 7283 Isolate.$lazy($, "context", "context", "get$context", function() { | |
| 7284 return P._wrapToDart(function() { return this; }()); | |
| 7285 }); | |
| 7286 Isolate.$lazy($, "visualization", "visualization", "get$visualization", function
() { | |
| 7287 return document.querySelector("#gauge"); | |
| 7288 }); | |
| 7289 Isolate.$lazy($, "slider", "slider", "get$slider", function() { | |
| 7290 return document.querySelector("#slider"); | |
| 7291 }); | |
| 7292 // Native classes | |
| 7293 | |
| 7294 init.functionAliases = {}; | |
| 7295 ; | |
| 7296 init.metadata = [, | |
| 7297 ]; | |
| 7298 $ = null; | |
| 7299 Isolate = Isolate.$finishIsolateConstructor(Isolate); | |
| 7300 $ = new Isolate(); | |
| 7301 function convertToFastObject(properties) { | |
| 7302 function MyClass() {}; | |
| 7303 MyClass.prototype = properties; | |
| 7304 new MyClass(); | |
| 7305 return properties; | |
| 7306 } | |
| 7307 A = convertToFastObject(A); | |
| 7308 B = convertToFastObject(B); | |
| 7309 C = convertToFastObject(C); | |
| 7310 D = convertToFastObject(D); | |
| 7311 E = convertToFastObject(E); | |
| 7312 F = convertToFastObject(F); | |
| 7313 G = convertToFastObject(G); | |
| 7314 H = convertToFastObject(H); | |
| 7315 J = convertToFastObject(J); | |
| 7316 K = convertToFastObject(K); | |
| 7317 L = convertToFastObject(L); | |
| 7318 M = convertToFastObject(M); | |
| 7319 N = convertToFastObject(N); | |
| 7320 O = convertToFastObject(O); | |
| 7321 P = convertToFastObject(P); | |
| 7322 Q = convertToFastObject(Q); | |
| 7323 R = convertToFastObject(R); | |
| 7324 S = convertToFastObject(S); | |
| 7325 T = convertToFastObject(T); | |
| 7326 U = convertToFastObject(U); | |
| 7327 V = convertToFastObject(V); | |
| 7328 W = convertToFastObject(W); | |
| 7329 X = convertToFastObject(X); | |
| 7330 Y = convertToFastObject(Y); | |
| 7331 Z = convertToFastObject(Z); | |
| 7332 !function() { | |
| 7333 var objectProto = Object.prototype; | |
| 7334 for (var i = 0;; i++) { | |
| 7335 var property = "___dart_dispatch_record_ZxYxX_0_"; | |
| 7336 if (i > 0) | |
| 7337 property = rootProperty + "_" + i; | |
| 7338 if (!(property in objectProto)) | |
| 7339 return init.dispatchPropertyName = property; | |
| 7340 } | |
| 7341 }(); | |
| 7342 // BEGIN invoke [main]. | |
| 7343 ;(function (callback) { | |
| 7344 if (typeof document === "undefined") { | |
| 7345 callback(null); | |
| 7346 return; | |
| 7347 } | |
| 7348 if (document.currentScript) { | |
| 7349 callback(document.currentScript); | |
| 7350 return; | |
| 7351 } | |
| 7352 | |
| 7353 var scripts = document.scripts; | |
| 7354 function onLoad(event) { | |
| 7355 for (var i = 0; i < scripts.length; ++i) { | |
| 7356 scripts[i].removeEventListener("load", onLoad, false); | |
| 7357 } | |
| 7358 callback(event.target); | |
| 7359 } | |
| 7360 for (var i = 0; i < scripts.length; ++i) { | |
| 7361 scripts[i].addEventListener("load", onLoad, false); | |
| 7362 } | |
| 7363 })(function(currentScript) { | |
| 7364 init.currentScript = currentScript; | |
| 7365 | |
| 7366 if (typeof dartMainRunner === "function") { | |
| 7367 dartMainRunner(function() { H.startRootIsolate(Y.main$closure); }); | |
| 7368 } else { | |
| 7369 H.startRootIsolate(Y.main$closure); | |
| 7370 } | |
| 7371 }); | |
| 7372 // END invoke [main]. | |
| 7373 function init() { | |
| 7374 Isolate.$isolateProperties = {}; | |
| 7375 function generateAccessor(field, accessors, cls) { | |
| 7376 var len = field.length; | |
| 7377 var code = field.charCodeAt(len - 1); | |
| 7378 var reflectable = false; | |
| 7379 if (code == 45) { | |
| 7380 len--; | |
| 7381 code = field.charCodeAt(len - 1); | |
| 7382 field = field.substring(0, len); | |
| 7383 reflectable = true; | |
| 7384 } | |
| 7385 code = code >= 60 && code <= 64 ? code - 59 : code >= 123 && code <= 126 ? c
ode - 117 : code >= 37 && code <= 43 ? code - 27 : 0; | |
| 7386 if (code) { | |
| 7387 var getterCode = code & 3; | |
| 7388 var setterCode = code >> 2; | |
| 7389 var accessorName = field = field.substring(0, len - 1); | |
| 7390 var divider = field.indexOf(":"); | |
| 7391 if (divider > 0) { | |
| 7392 accessorName = field.substring(0, divider); | |
| 7393 field = field.substring(divider + 1); | |
| 7394 } | |
| 7395 if (getterCode) { | |
| 7396 var args = getterCode & 2 ? "receiver" : ""; | |
| 7397 var receiver = getterCode & 1 ? "this" : "receiver"; | |
| 7398 var body = "return " + receiver + "." + field; | |
| 7399 var property = cls + ".prototype.get$" + accessorName + "="; | |
| 7400 var fn = "function(" + args + "){" + body + "}"; | |
| 7401 if (reflectable) | |
| 7402 accessors.push(property + "$reflectable(" + fn + ");\n"); | |
| 7403 else | |
| 7404 accessors.push(property + fn + ";\n"); | |
| 7405 } | |
| 7406 if (setterCode) { | |
| 7407 var args = setterCode & 2 ? "receiver, value" : "value"; | |
| 7408 var receiver = setterCode & 1 ? "this" : "receiver"; | |
| 7409 var body = receiver + "." + field + " = value"; | |
| 7410 var property = cls + ".prototype.set$" + accessorName + "="; | |
| 7411 var fn = "function(" + args + "){" + body + "}"; | |
| 7412 if (reflectable) | |
| 7413 accessors.push(property + "$reflectable(" + fn + ");\n"); | |
| 7414 else | |
| 7415 accessors.push(property + fn + ";\n"); | |
| 7416 } | |
| 7417 } | |
| 7418 return field; | |
| 7419 } | |
| 7420 Isolate.$isolateProperties.$generateAccessor = generateAccessor; | |
| 7421 function defineClass(name, cls, fields) { | |
| 7422 var accessors = []; | |
| 7423 var str = "function " + cls + "("; | |
| 7424 var body = ""; | |
| 7425 for (var i = 0; i < fields.length; i++) { | |
| 7426 if (i != 0) | |
| 7427 str += ", "; | |
| 7428 var field = generateAccessor(fields[i], accessors, cls); | |
| 7429 var parameter = "parameter_" + field; | |
| 7430 str += parameter; | |
| 7431 body += "this." + field + " = " + parameter + ";\n"; | |
| 7432 } | |
| 7433 str += ") {\n" + body + "}\n"; | |
| 7434 str += cls + ".builtin$cls=\"" + name + "\";\n"; | |
| 7435 str += "$desc=$collectedClasses." + cls + ";\n"; | |
| 7436 str += "if($desc instanceof Array) $desc = $desc[1];\n"; | |
| 7437 str += cls + ".prototype = $desc;\n"; | |
| 7438 if (typeof defineClass.name != "string") { | |
| 7439 str += cls + ".name=\"" + cls + "\";\n"; | |
| 7440 } | |
| 7441 str += accessors.join(""); | |
| 7442 return str; | |
| 7443 } | |
| 7444 var inheritFrom = function() { | |
| 7445 function tmp() { | |
| 7446 } | |
| 7447 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| 7448 return function(constructor, superConstructor) { | |
| 7449 tmp.prototype = superConstructor.prototype; | |
| 7450 var object = new tmp(); | |
| 7451 var properties = constructor.prototype; | |
| 7452 for (var member in properties) | |
| 7453 if (hasOwnProperty.call(properties, member)) | |
| 7454 object[member] = properties[member]; | |
| 7455 object.constructor = constructor; | |
| 7456 constructor.prototype = object; | |
| 7457 return object; | |
| 7458 }; | |
| 7459 }(); | |
| 7460 Isolate.$finishClasses = function(collectedClasses, isolateProperties, existin
gIsolateProperties) { | |
| 7461 var pendingClasses = {}; | |
| 7462 if (!init.allClasses) | |
| 7463 init.allClasses = {}; | |
| 7464 var allClasses = init.allClasses; | |
| 7465 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| 7466 if (typeof dart_precompiled == "function") { | |
| 7467 var constructors = dart_precompiled(collectedClasses); | |
| 7468 } else { | |
| 7469 var combinedConstructorFunction = "function $reflectable(fn){fn.$reflectab
le=1;return fn};\n" + "var $desc;\n"; | |
| 7470 var constructorsList = []; | |
| 7471 } | |
| 7472 for (var cls in collectedClasses) { | |
| 7473 if (hasOwnProperty.call(collectedClasses, cls)) { | |
| 7474 var desc = collectedClasses[cls]; | |
| 7475 if (desc instanceof Array) | |
| 7476 desc = desc[1]; | |
| 7477 var classData = desc[""], supr, name = cls, fields = classData; | |
| 7478 if (typeof classData == "string") { | |
| 7479 var split = classData.split("/"); | |
| 7480 if (split.length == 2) { | |
| 7481 name = split[0]; | |
| 7482 fields = split[1]; | |
| 7483 } | |
| 7484 } | |
| 7485 var s = fields.split(";"); | |
| 7486 fields = s[1] == "" ? [] : s[1].split(","); | |
| 7487 supr = s[0]; | |
| 7488 if (supr && supr.indexOf("+") > 0) { | |
| 7489 s = supr.split("+"); | |
| 7490 supr = s[0]; | |
| 7491 var mixin = collectedClasses[s[1]]; | |
| 7492 if (mixin instanceof Array) | |
| 7493 mixin = mixin[1]; | |
| 7494 for (var d in mixin) { | |
| 7495 if (hasOwnProperty.call(mixin, d) && !hasOwnProperty.call(desc, d)) | |
| 7496 desc[d] = mixin[d]; | |
| 7497 } | |
| 7498 } | |
| 7499 if (typeof dart_precompiled != "function") { | |
| 7500 combinedConstructorFunction += defineClass(name, cls, fields); | |
| 7501 constructorsList.push(cls); | |
| 7502 } | |
| 7503 if (supr) | |
| 7504 pendingClasses[cls] = supr; | |
| 7505 } | |
| 7506 } | |
| 7507 if (typeof dart_precompiled != "function") { | |
| 7508 combinedConstructorFunction += "return [\n " + constructorsList.join(",\n
") + "\n]"; | |
| 7509 var constructors = new Function("$collectedClasses", combinedConstructorFu
nction)(collectedClasses); | |
| 7510 combinedConstructorFunction = null; | |
| 7511 } | |
| 7512 for (var i = 0; i < constructors.length; i++) { | |
| 7513 var constructor = constructors[i]; | |
| 7514 var cls = constructor.name; | |
| 7515 var desc = collectedClasses[cls]; | |
| 7516 var globalObject = isolateProperties; | |
| 7517 if (desc instanceof Array) { | |
| 7518 globalObject = desc[0] || isolateProperties; | |
| 7519 desc = desc[1]; | |
| 7520 } | |
| 7521 allClasses[cls] = constructor; | |
| 7522 globalObject[cls] = constructor; | |
| 7523 } | |
| 7524 constructors = null; | |
| 7525 var finishedClasses = {}; | |
| 7526 init.interceptorsByTag = Object.create(null); | |
| 7527 init.leafTags = {}; | |
| 7528 function finishClass(cls) { | |
| 7529 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| 7530 if (hasOwnProperty.call(finishedClasses, cls)) | |
| 7531 return; | |
| 7532 finishedClasses[cls] = true; | |
| 7533 var superclass = pendingClasses[cls]; | |
| 7534 if (!superclass || typeof superclass != "string") | |
| 7535 return; | |
| 7536 finishClass(superclass); | |
| 7537 var constructor = allClasses[cls]; | |
| 7538 var superConstructor = allClasses[superclass]; | |
| 7539 if (!superConstructor) | |
| 7540 superConstructor = existingIsolateProperties[superclass]; | |
| 7541 var prototype = inheritFrom(constructor, superConstructor); | |
| 7542 if (hasOwnProperty.call(prototype, "%")) { | |
| 7543 var nativeSpec = prototype["%"].split(";"); | |
| 7544 if (nativeSpec[0]) { | |
| 7545 var tags = nativeSpec[0].split("|"); | |
| 7546 for (var i = 0; i < tags.length; i++) { | |
| 7547 init.interceptorsByTag[tags[i]] = constructor; | |
| 7548 init.leafTags[tags[i]] = true; | |
| 7549 } | |
| 7550 } | |
| 7551 if (nativeSpec[1]) { | |
| 7552 tags = nativeSpec[1].split("|"); | |
| 7553 if (nativeSpec[2]) { | |
| 7554 var subclasses = nativeSpec[2].split("|"); | |
| 7555 for (var i = 0; i < subclasses.length; i++) { | |
| 7556 var subclass = allClasses[subclasses[i]]; | |
| 7557 subclass.$nativeSuperclassTag = tags[0]; | |
| 7558 } | |
| 7559 } | |
| 7560 for (i = 0; i < tags.length; i++) { | |
| 7561 init.interceptorsByTag[tags[i]] = constructor; | |
| 7562 init.leafTags[tags[i]] = false; | |
| 7563 } | |
| 7564 } | |
| 7565 } | |
| 7566 } | |
| 7567 for (var cls in pendingClasses) | |
| 7568 finishClass(cls); | |
| 7569 }; | |
| 7570 Isolate.$lazy = function(prototype, staticName, fieldName, getterName, lazyVal
ue) { | |
| 7571 var sentinelUndefined = {}; | |
| 7572 var sentinelInProgress = {}; | |
| 7573 prototype[fieldName] = sentinelUndefined; | |
| 7574 prototype[getterName] = function() { | |
| 7575 var result = $[fieldName]; | |
| 7576 try { | |
| 7577 if (result === sentinelUndefined) { | |
| 7578 $[fieldName] = sentinelInProgress; | |
| 7579 try { | |
| 7580 result = $[fieldName] = lazyValue(); | |
| 7581 } finally { | |
| 7582 if (result === sentinelUndefined) { | |
| 7583 if ($[fieldName] === sentinelInProgress) { | |
| 7584 $[fieldName] = null; | |
| 7585 } | |
| 7586 } | |
| 7587 } | |
| 7588 } else { | |
| 7589 if (result === sentinelInProgress) | |
| 7590 H.throwCyclicInit(staticName); | |
| 7591 } | |
| 7592 return result; | |
| 7593 } finally { | |
| 7594 $[getterName] = function() { | |
| 7595 return this[fieldName]; | |
| 7596 }; | |
| 7597 } | |
| 7598 }; | |
| 7599 }; | |
| 7600 Isolate.$finishIsolateConstructor = function(oldIsolate) { | |
| 7601 var isolateProperties = oldIsolate.$isolateProperties; | |
| 7602 function Isolate() { | |
| 7603 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| 7604 for (var staticName in isolateProperties) | |
| 7605 if (hasOwnProperty.call(isolateProperties, staticName)) | |
| 7606 this[staticName] = isolateProperties[staticName]; | |
| 7607 function ForceEfficientMap() { | |
| 7608 } | |
| 7609 ForceEfficientMap.prototype = this; | |
| 7610 new ForceEfficientMap(); | |
| 7611 } | |
| 7612 Isolate.prototype = oldIsolate.prototype; | |
| 7613 Isolate.prototype.constructor = Isolate; | |
| 7614 Isolate.$isolateProperties = isolateProperties; | |
| 7615 Isolate.$finishClasses = oldIsolate.$finishClasses; | |
| 7616 Isolate.makeConstantList = oldIsolate.makeConstantList; | |
| 7617 return Isolate; | |
| 7618 }; | |
| 7619 } | |
| 7620 })() | |
| 7621 | |
| 7622 //# sourceMappingURL=gauge.dart.js.map | |
| 7623 //@ sourceMappingURL=gauge.dart.js.map | |
| OLD | NEW |