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 $$.Closure$0 = [H, {"": "Closure;call$0,$name"}]; | |
69 | |
70 $$.Closure$7 = [H, {"": "Closure;call$7,$name"}]; | |
71 | |
72 $$.Closure$2 = [P, {"": "Closure;call$2,$name"}]; | |
73 | |
74 $$.Closure$1 = [P, {"": "Closure;call$1,$name"}]; | |
75 | |
76 $$.Closure$4 = [P, {"": "Closure;call$4,$name"}]; | |
77 | |
78 (function (reflectionData) { | |
79 function map(x){x={x:x};delete x.x;return x} | |
80 if (!init.libraries) init.libraries = []; | |
81 if (!init.mangledNames) init.mangledNames = map(); | |
82 if (!init.mangledGlobalNames) init.mangledGlobalNames = map(); | |
83 if (!init.statics) init.statics = map(); | |
84 if (!init.typeInformation) init.typeInformation = map(); | |
85 if (!init.globalFunctions) init.globalFunctions = map(); | |
86 var libraries = init.libraries; | |
87 var mangledNames = init.mangledNames; | |
88 var mangledGlobalNames = init.mangledGlobalNames; | |
89 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
90 var length = reflectionData.length; | |
91 for (var i = 0; i < length; i++) { | |
92 var data = reflectionData[i]; | |
93 var name = data[0]; | |
94 var uri = data[1]; | |
95 var metadata = data[2]; | |
96 var globalObject = data[3]; | |
97 var descriptor = data[4]; | |
98 var isRoot = !!data[5]; | |
99 var fields = descriptor && descriptor[""]; | |
100 var classes = []; | |
101 var functions = []; | |
102 function processStatics(descriptor) { | |
103 for (var property in descriptor) { | |
104 if (!hasOwnProperty.call(descriptor, property)) continue; | |
105 if (property === "") continue; | |
106 var element = descriptor[property]; | |
107 var firstChar = property.substring(0, 1); | |
108 var previousProperty; | |
109 if (firstChar === "+") { | |
110 mangledGlobalNames[previousProperty] = property.substring(1); | |
111 if (descriptor[property] == 1) descriptor[previousProperty].$reflectab
le = 1; | |
112 if (element && element.length) init.typeInformation[previousProperty]
= element; | |
113 } else if (firstChar === "@") { | |
114 property = property.substring(1); | |
115 $[property]["@"] = element; | |
116 } else if (firstChar === "*") { | |
117 globalObject[previousProperty].$defaultValues = element; | |
118 var optionalMethods = descriptor.$methodsWithOptionalArguments; | |
119 if (!optionalMethods) { | |
120 descriptor.$methodsWithOptionalArguments = optionalMethods = {} | |
121 } | |
122 optionalMethods[property] = previousProperty; | |
123 } else if (typeof element === "function") { | |
124 globalObject[previousProperty = property] = element; | |
125 functions.push(property); | |
126 init.globalFunctions[property] = element; | |
127 } else { | |
128 previousProperty = property; | |
129 var newDesc = {}; | |
130 var previousProp; | |
131 for (var prop in element) { | |
132 if (!hasOwnProperty.call(element, prop)) continue; | |
133 firstChar = prop.substring(0, 1); | |
134 if (prop === "static") { | |
135 processStatics(init.statics[property] = element[prop]); | |
136 } else if (firstChar === "+") { | |
137 mangledNames[previousProp] = prop.substring(1); | |
138 if (element[prop] == 1) element[previousProp].$reflectable = 1; | |
139 } else if (firstChar === "@" && prop !== "@") { | |
140 newDesc[prop.substring(1)]["@"] = element[prop]; | |
141 } else if (firstChar === "*") { | |
142 newDesc[previousProp].$defaultValues = element[prop]; | |
143 var optionalMethods = newDesc.$methodsWithOptionalArguments; | |
144 if (!optionalMethods) { | |
145 newDesc.$methodsWithOptionalArguments = optionalMethods={} | |
146 } | |
147 optionalMethods[prop] = previousProp; | |
148 } else { | |
149 newDesc[previousProp = prop] = element[prop]; | |
150 } | |
151 } | |
152 $$[property] = [globalObject, newDesc]; | |
153 classes.push(property); | |
154 } | |
155 } | |
156 } | |
157 processStatics(descriptor); | |
158 libraries.push([name, uri, classes, functions, metadata, fields, isRoot, | |
159 globalObject]); | |
160 } | |
161 })([ | |
162 ["_foreign_helper", "dart:_foreign_helper", , H, { | |
163 JS_CONST: {"": "Object;code"}}], | |
164 ["_interceptors", "dart:_interceptors", , J, { | |
165 getInterceptor: function(object) { | |
166 return void 0; | |
167 }, | |
168 | |
169 makeDispatchRecord: function(interceptor, proto, extension, indexability) { | |
170 return {i: interceptor, p: proto, e: extension, x: indexability}; | |
171 }, | |
172 | |
173 getNativeInterceptor: function(object) { | |
174 var record, proto, objectProto, interceptor; | |
175 record = object[init.dispatchPropertyName]; | |
176 if (record == null) | |
177 if ($.initNativeDispatchFlag == null) { | |
178 H.initNativeDispatch(); | |
179 record = object[init.dispatchPropertyName]; | |
180 } | |
181 if (record != null) { | |
182 proto = record.p; | |
183 if (false === proto) | |
184 return record.i; | |
185 if (true === proto) | |
186 return object; | |
187 objectProto = Object.getPrototypeOf(object); | |
188 if (proto === objectProto) | |
189 return record.i; | |
190 if (record.e === objectProto) | |
191 throw H.wrapException(P.UnimplementedError$("Return interceptor for " + H.
S(proto(object, record)))); | |
192 } | |
193 interceptor = H.lookupAndCacheInterceptor(object); | |
194 if (interceptor == null) | |
195 return C.UnknownJavaScriptObject_methods; | |
196 return interceptor; | |
197 }, | |
198 | |
199 Interceptor: {"": "Object;", | |
200 $eq: function(receiver, other) { | |
201 return receiver === other; | |
202 }, | |
203 get$hashCode: function(receiver) { | |
204 return H.Primitives_objectHashCode(receiver); | |
205 }, | |
206 toString$0: function(receiver) { | |
207 return H.Primitives_objectToString(receiver); | |
208 }, | |
209 noSuchMethod$1: function(receiver, invocation) { | |
210 throw H.wrapException(P.NoSuchMethodError$(receiver, invocation.get$memberNa
me(), invocation.get$positionalArguments(), invocation.get$namedArguments(), nul
l)); | |
211 }, | |
212 "%": "DOMError|FileError|MediaError|MediaKeyError|NavigatorUserMediaError|Posi
tionError|SQLError" | |
213 }, | |
214 | |
215 JSBool: {"": "bool/Interceptor;", | |
216 toString$0: function(receiver) { | |
217 return String(receiver); | |
218 }, | |
219 get$hashCode: function(receiver) { | |
220 return receiver ? 519018 : 218159; | |
221 }, | |
222 $isbool: true | |
223 }, | |
224 | |
225 JSNull: {"": "Interceptor;", | |
226 $eq: function(receiver, other) { | |
227 return null == other; | |
228 }, | |
229 toString$0: function(receiver) { | |
230 return "null"; | |
231 }, | |
232 get$hashCode: function(receiver) { | |
233 return 0; | |
234 } | |
235 }, | |
236 | |
237 JavaScriptObject: {"": "Interceptor;", | |
238 get$hashCode: function(_) { | |
239 return 0; | |
240 } | |
241 }, | |
242 | |
243 PlainJavaScriptObject: {"": "JavaScriptObject;"}, | |
244 | |
245 UnknownJavaScriptObject: {"": "JavaScriptObject;"}, | |
246 | |
247 JSArray: {"": "List/Interceptor;", | |
248 add$1: function(receiver, value) { | |
249 if (!!receiver.fixed$length) | |
250 H.throwExpression(P.UnsupportedError$("add")); | |
251 receiver.push(value); | |
252 }, | |
253 addAll$1: function(receiver, collection) { | |
254 var t1; | |
255 for (t1 = J.get$iterator$ax(collection); t1.moveNext$0();) | |
256 this.add$1(receiver, t1.get$current()); | |
257 }, | |
258 forEach$1: function(receiver, f) { | |
259 return H.IterableMixinWorkaround_forEach(receiver, f); | |
260 }, | |
261 map$1: function(receiver, f) { | |
262 var t1 = new H.MappedListIterable(receiver, f); | |
263 H.setRuntimeTypeInfo(t1, [null, null]); | |
264 return t1; | |
265 }, | |
266 elementAt$1: function(receiver, index) { | |
267 if (index >>> 0 !== index || index >= receiver.length) | |
268 throw H.ioore(receiver, index); | |
269 return receiver[index]; | |
270 }, | |
271 toString$0: function(receiver) { | |
272 return H.IterableMixinWorkaround_toStringIterable(receiver, "[", "]"); | |
273 }, | |
274 get$iterator: function(receiver) { | |
275 return new H.ListIterator(receiver, receiver.length, 0, null); | |
276 }, | |
277 get$hashCode: function(receiver) { | |
278 return H.Primitives_objectHashCode(receiver); | |
279 }, | |
280 get$length: function(receiver) { | |
281 return receiver.length; | |
282 }, | |
283 set$length: function(receiver, newLength) { | |
284 if (typeof newLength !== "number" || Math.floor(newLength) !== newLength) | |
285 throw H.wrapException(P.ArgumentError$(newLength)); | |
286 if (newLength < 0) | |
287 throw H.wrapException(P.RangeError$value(newLength)); | |
288 if (!!receiver.fixed$length) | |
289 H.throwExpression(P.UnsupportedError$("set length")); | |
290 receiver.length = newLength; | |
291 }, | |
292 $index: function(receiver, index) { | |
293 if (typeof index !== "number" || Math.floor(index) !== index) | |
294 throw H.wrapException(P.ArgumentError$(index)); | |
295 if (index >= receiver.length || index < 0) | |
296 throw H.wrapException(P.RangeError$value(index)); | |
297 return receiver[index]; | |
298 }, | |
299 $indexSet: function(receiver, index, value) { | |
300 if (!!receiver.immutable$list) | |
301 H.throwExpression(P.UnsupportedError$("indexed set")); | |
302 if (typeof index !== "number" || Math.floor(index) !== index) | |
303 throw H.wrapException(P.ArgumentError$(index)); | |
304 if (index >= receiver.length || index < 0) | |
305 throw H.wrapException(P.RangeError$value(index)); | |
306 receiver[index] = value; | |
307 }, | |
308 $isList: true, | |
309 $isEfficientLength: true | |
310 }, | |
311 | |
312 JSMutableArray: {"": "JSArray;", $isJSMutableArray: true, | |
313 $asJSArray: function() { | |
314 return [null]; | |
315 } | |
316 }, | |
317 | |
318 JSFixedArray: {"": "JSMutableArray;"}, | |
319 | |
320 JSExtendableArray: {"": "JSMutableArray;", $isJSExtendableArray: true}, | |
321 | |
322 JSNumber: {"": "num/Interceptor;", | |
323 abs$0: function(receiver) { | |
324 return Math.abs(receiver); | |
325 }, | |
326 toInt$0: function(receiver) { | |
327 var t1; | |
328 if (receiver >= -2147483648 && receiver <= 2147483647) | |
329 return receiver | 0; | |
330 if (isFinite(receiver)) { | |
331 t1 = receiver < 0 ? Math.ceil(receiver) : Math.floor(receiver); | |
332 return t1 + 0; | |
333 } | |
334 throw H.wrapException(P.UnsupportedError$('' + receiver)); | |
335 }, | |
336 toString$0: function(receiver) { | |
337 if (receiver === 0 && 1 / receiver < 0) | |
338 return "-0.0"; | |
339 else | |
340 return "" + receiver; | |
341 }, | |
342 get$hashCode: function(receiver) { | |
343 return receiver & 0x1FFFFFFF; | |
344 }, | |
345 $sub: function(receiver, other) { | |
346 return receiver - other; | |
347 }, | |
348 $shr: function(receiver, other) { | |
349 if (other < 0) | |
350 throw H.wrapException(P.ArgumentError$(other)); | |
351 if (receiver > 0) { | |
352 if (other > 31) | |
353 return 0; | |
354 return receiver >>> other; | |
355 } | |
356 if (other > 31) | |
357 other = 31; | |
358 return receiver >> other >>> 0; | |
359 }, | |
360 $lt: function(receiver, other) { | |
361 if (typeof other !== "number") | |
362 throw H.wrapException(P.ArgumentError$(other)); | |
363 return receiver < other; | |
364 }, | |
365 $gt: function(receiver, other) { | |
366 if (typeof other !== "number") | |
367 throw H.wrapException(P.ArgumentError$(other)); | |
368 return receiver > other; | |
369 }, | |
370 $ge: function(receiver, other) { | |
371 if (typeof other !== "number") | |
372 throw H.wrapException(P.ArgumentError$(other)); | |
373 return receiver >= other; | |
374 }, | |
375 $isnum: true, | |
376 static: { | |
377 "": "JSNumber__MIN_INT32,JSNumber__MAX_INT32", | |
378 } | |
379 | |
380 }, | |
381 | |
382 JSInt: {"": "int/JSNumber;", $isnum: true, $isint: true}, | |
383 | |
384 JSDouble: {"": "double/JSNumber;", $isnum: true}, | |
385 | |
386 JSString: {"": "String/Interceptor;", | |
387 codeUnitAt$1: function(receiver, index) { | |
388 if (index < 0) | |
389 throw H.wrapException(P.RangeError$value(index)); | |
390 if (index >= receiver.length) | |
391 throw H.wrapException(P.RangeError$value(index)); | |
392 return receiver.charCodeAt(index); | |
393 }, | |
394 substring$2: function(receiver, startIndex, endIndex) { | |
395 var t1; | |
396 if (typeof startIndex !== "number" || Math.floor(startIndex) !== startIndex) | |
397 H.throwExpression(P.ArgumentError$(startIndex)); | |
398 if (endIndex == null) | |
399 endIndex = receiver.length; | |
400 if (typeof endIndex !== "number" || Math.floor(endIndex) !== endIndex) | |
401 H.throwExpression(P.ArgumentError$(endIndex)); | |
402 t1 = J.getInterceptor$n(startIndex); | |
403 if (t1.$lt(startIndex, 0)) | |
404 throw H.wrapException(P.RangeError$value(startIndex)); | |
405 if (t1.$gt(startIndex, endIndex)) | |
406 throw H.wrapException(P.RangeError$value(startIndex)); | |
407 if (J.$gt$n(endIndex, receiver.length)) | |
408 throw H.wrapException(P.RangeError$value(endIndex)); | |
409 return receiver.substring(startIndex, endIndex); | |
410 }, | |
411 substring$1: function($receiver, startIndex) { | |
412 return this.substring$2($receiver, startIndex, null); | |
413 }, | |
414 get$isEmpty: function(receiver) { | |
415 return receiver.length === 0; | |
416 }, | |
417 toString$0: function(receiver) { | |
418 return receiver; | |
419 }, | |
420 get$hashCode: function(receiver) { | |
421 var t1, hash, i; | |
422 for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) { | |
423 hash = 536870911 & hash + receiver.charCodeAt(i); | |
424 hash = 536870911 & hash + ((524287 & hash) << 10 >>> 0); | |
425 hash ^= hash >> 6; | |
426 } | |
427 hash = 536870911 & hash + ((67108863 & hash) << 3 >>> 0); | |
428 hash ^= hash >> 11; | |
429 return 536870911 & hash + ((16383 & hash) << 15 >>> 0); | |
430 }, | |
431 get$length: function(receiver) { | |
432 return receiver.length; | |
433 }, | |
434 $index: function(receiver, index) { | |
435 if (typeof index !== "number" || Math.floor(index) !== index) | |
436 throw H.wrapException(P.ArgumentError$(index)); | |
437 if (index >= receiver.length || index < 0) | |
438 throw H.wrapException(P.RangeError$value(index)); | |
439 return receiver[index]; | |
440 }, | |
441 $isString: true | |
442 }}], | |
443 ["_js_helper", "dart:_js_helper", , H, { | |
444 isJsIndexable: function(object, record) { | |
445 var result, t1; | |
446 if (record != null) { | |
447 result = record.x; | |
448 if (result != null) | |
449 return result; | |
450 } | |
451 t1 = J.getInterceptor(object); | |
452 return typeof object === "object" && object !== null && !!t1.$isJavaScriptInde
xingBehavior; | |
453 }, | |
454 | |
455 S: function(value) { | |
456 var res; | |
457 if (typeof value === "string") | |
458 return value; | |
459 if (typeof value === "number") { | |
460 if (value !== 0) | |
461 return "" + value; | |
462 } else if (true === value) | |
463 return "true"; | |
464 else if (false === value) | |
465 return "false"; | |
466 else if (value == null) | |
467 return "null"; | |
468 res = J.toString$0(value); | |
469 if (typeof res !== "string") | |
470 throw H.wrapException(P.ArgumentError$(value)); | |
471 return res; | |
472 }, | |
473 | |
474 Primitives_objectHashCode: function(object) { | |
475 var hash = object.$identityHash; | |
476 if (hash == null) { | |
477 hash = Math.random() * 0x3fffffff | 0; | |
478 object.$identityHash = hash; | |
479 } | |
480 return hash; | |
481 }, | |
482 | |
483 Primitives_objectTypeName: function(object) { | |
484 var $name, decompiled, t1; | |
485 $name = C.JS_CONST_86y(J.getInterceptor(object)); | |
486 if ($name === "Object") { | |
487 decompiled = String(object.constructor).match(/^\s*function\s*(\S*)\s*\(/)[1
]; | |
488 if (typeof decompiled === "string") | |
489 $name = decompiled; | |
490 } | |
491 t1 = J.getInterceptor$s($name); | |
492 if (t1.codeUnitAt$1($name, 0) === 36) | |
493 $name = t1.substring$1($name, 1); | |
494 t1 = H.getRuntimeTypeInfo(object); | |
495 return H.S($name) + H.joinArguments(t1, 0, null); | |
496 }, | |
497 | |
498 Primitives_objectToString: function(object) { | |
499 return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
500 }, | |
501 | |
502 Primitives_newFixedList: function($length) { | |
503 var result = new Array($length); | |
504 result.fixed$length = true; | |
505 return result; | |
506 }, | |
507 | |
508 Primitives__fromCharCodeApply: function(array) { | |
509 var end, t1, result, i, subarray, t2; | |
510 end = array.length; | |
511 for (t1 = end <= 500, result = "", i = 0; i < end; i += 500) { | |
512 if (t1) | |
513 subarray = array; | |
514 else { | |
515 t2 = i + 500; | |
516 t2 = t2 < end ? t2 : end; | |
517 subarray = array.slice(i, t2); | |
518 } | |
519 result += String.fromCharCode.apply(null, subarray); | |
520 } | |
521 return result; | |
522 }, | |
523 | |
524 Primitives_stringFromCodePoints: function(codePoints) { | |
525 var a, t1, i; | |
526 a = []; | |
527 a.$builtinTypeInfo = [J.JSInt]; | |
528 for (t1 = new H.ListIterator(codePoints, codePoints.length, 0, null); t1.moveN
ext$0();) { | |
529 i = t1._current; | |
530 if (typeof i !== "number" || Math.floor(i) !== i) | |
531 throw H.wrapException(P.ArgumentError$(i)); | |
532 if (i <= 65535) | |
533 a.push(i); | |
534 else if (i <= 1114111) { | |
535 a.push(55296 + (C.JSInt_methods.$shr(i - 65536, 10) & 1023)); | |
536 a.push(56320 + (i & 1023)); | |
537 } else | |
538 throw H.wrapException(P.ArgumentError$(i)); | |
539 } | |
540 return H.Primitives__fromCharCodeApply(a); | |
541 }, | |
542 | |
543 Primitives_stringFromCharCodes: function(charCodes) { | |
544 var t1, i; | |
545 for (t1 = new H.ListIterator(charCodes, charCodes.length, 0, null); t1.moveNex
t$0();) { | |
546 i = t1._current; | |
547 if (typeof i !== "number" || Math.floor(i) !== i) | |
548 throw H.wrapException(P.ArgumentError$(i)); | |
549 if (i < 0) | |
550 throw H.wrapException(P.ArgumentError$(i)); | |
551 if (i > 65535) | |
552 return H.Primitives_stringFromCodePoints(charCodes); | |
553 } | |
554 return H.Primitives__fromCharCodeApply(charCodes); | |
555 }, | |
556 | |
557 Primitives_lazyAsJsDate: function(receiver) { | |
558 if (receiver.date === void 0) | |
559 receiver.date = new Date(receiver.millisecondsSinceEpoch); | |
560 return receiver.date; | |
561 }, | |
562 | |
563 Primitives_getYear: function(receiver) { | |
564 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCFullYear() +
0 : H.Primitives_lazyAsJsDate(receiver).getFullYear() + 0; | |
565 }, | |
566 | |
567 Primitives_getMonth: function(receiver) { | |
568 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMonth() + 1
: H.Primitives_lazyAsJsDate(receiver).getMonth() + 1; | |
569 }, | |
570 | |
571 Primitives_getDay: function(receiver) { | |
572 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCDate() + 0 :
H.Primitives_lazyAsJsDate(receiver).getDate() + 0; | |
573 }, | |
574 | |
575 Primitives_getHours: function(receiver) { | |
576 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCHours() + 0
: H.Primitives_lazyAsJsDate(receiver).getHours() + 0; | |
577 }, | |
578 | |
579 Primitives_getMinutes: function(receiver) { | |
580 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMinutes() +
0 : H.Primitives_lazyAsJsDate(receiver).getMinutes() + 0; | |
581 }, | |
582 | |
583 Primitives_getSeconds: function(receiver) { | |
584 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCSeconds() +
0 : H.Primitives_lazyAsJsDate(receiver).getSeconds() + 0; | |
585 }, | |
586 | |
587 Primitives_getMilliseconds: function(receiver) { | |
588 return receiver.isUtc ? H.Primitives_lazyAsJsDate(receiver).getUTCMilliseconds
() + 0 : H.Primitives_lazyAsJsDate(receiver).getMilliseconds() + 0; | |
589 }, | |
590 | |
591 Primitives_applyFunction: function($function, positionalArguments, namedArgument
s) { | |
592 var t1, buffer, $arguments, allNamedArguments, listOfNamedArguments, t2, t3, t
4, selectorName, jsFunction; | |
593 t1 = {}; | |
594 t1.argumentCount_0 = 0; | |
595 buffer = P.StringBuffer$(""); | |
596 $arguments = []; | |
597 t1.argumentCount_0 = t1.argumentCount_0 + positionalArguments.length; | |
598 C.JSArray_methods.addAll$1($arguments, positionalArguments); | |
599 if ("call$catchAll" in $function) { | |
600 allNamedArguments = $function.call$catchAll(); | |
601 if (namedArguments != null && !namedArguments.get$isEmpty(namedArguments)) | |
602 namedArguments.forEach$1(namedArguments, new H.Primitives_applyFunction_cl
osure(allNamedArguments)); | |
603 listOfNamedArguments = Object.getOwnPropertyNames(allNamedArguments); | |
604 t2 = t1.argumentCount_0; | |
605 t3 = J.getInterceptor$asx(listOfNamedArguments); | |
606 t4 = t3.get$length(listOfNamedArguments); | |
607 if (typeof t4 !== "number") | |
608 throw H.iae(t4); | |
609 t1.argumentCount_0 = t2 + t4; | |
610 t3.forEach$1(listOfNamedArguments, new H.Primitives_applyFunction_closure0(b
uffer, $arguments, allNamedArguments)); | |
611 } else if (namedArguments != null && !namedArguments.get$isEmpty(namedArgument
s)) | |
612 namedArguments.forEach$1(namedArguments, new H.Primitives_applyFunction_clos
ure1(t1, buffer, $arguments)); | |
613 selectorName = "call$" + H.S(t1.argumentCount_0) + H.S(buffer); | |
614 jsFunction = $function[selectorName]; | |
615 if (jsFunction == null) { | |
616 if (namedArguments == null) | |
617 t1 = []; | |
618 else { | |
619 t1 = namedArguments.get$keys(); | |
620 t1 = P.List_List$from(t1, true, H.getRuntimeTypeArgument(t1, "IterableBase
", 0)); | |
621 } | |
622 return J.noSuchMethod$1($function, new H.JSInvocationMirror(C.Symbol_call, s
electorName, 0, $arguments, t1, null)); | |
623 } | |
624 return jsFunction.apply($function, $arguments); | |
625 }, | |
626 | |
627 iae: function(argument) { | |
628 throw H.wrapException(P.ArgumentError$(argument)); | |
629 }, | |
630 | |
631 ioore: function(receiver, index) { | |
632 if (receiver == null) | |
633 J.get$length$asx(receiver); | |
634 if (typeof index !== "number" || Math.floor(index) !== index) | |
635 H.iae(index); | |
636 throw H.wrapException(P.RangeError$value(index)); | |
637 }, | |
638 | |
639 wrapException: function(ex) { | |
640 var wrapper; | |
641 if (ex == null) | |
642 ex = new P.NullThrownError(); | |
643 wrapper = new Error(); | |
644 wrapper.dartException = ex; | |
645 if ("defineProperty" in Object) { | |
646 Object.defineProperty(wrapper, "message", { get: H.toStringWrapper$closure.c
all$0 }); | |
647 wrapper.name = ""; | |
648 } else | |
649 wrapper.toString = H.toStringWrapper$closure.call$0; | |
650 return wrapper; | |
651 }, | |
652 | |
653 toStringWrapper: function() { | |
654 return J.toString$0(this.dartException); | |
655 }, | |
656 | |
657 throwExpression: function(ex) { | |
658 throw H.wrapException(ex); | |
659 }, | |
660 | |
661 makeLiteralListConst: function(list) { | |
662 list.immutable$list = true; | |
663 list.fixed$length = true; | |
664 return list; | |
665 }, | |
666 | |
667 unwrapException: function(ex) { | |
668 var t1, message, number, ieErrorCode, t2, t3, t4, nullLiteralCall, t5, t6, t7,
t8, t9, match; | |
669 t1 = new H.unwrapException_saveStackTrace(ex); | |
670 if (ex == null) | |
671 return; | |
672 if (typeof ex !== "object") | |
673 return ex; | |
674 if ("dartException" in ex) | |
675 return t1.call$1(ex.dartException); | |
676 else if (!("message" in ex)) | |
677 return ex; | |
678 message = ex.message; | |
679 if ("number" in ex && typeof ex.number == "number") { | |
680 number = ex.number; | |
681 ieErrorCode = number & 65535; | |
682 if ((C.JSInt_methods.$shr(number, 16) & 8191) === 10) | |
683 switch (ieErrorCode) { | |
684 case 438: | |
685 return t1.call$1(H.JsNoSuchMethodError$(H.S(message) + " (Error " + ie
ErrorCode + ")", null)); | |
686 case 445: | |
687 case 5007: | |
688 t2 = H.S(message) + " (Error " + ieErrorCode + ")"; | |
689 return t1.call$1(new H.NullError(t2, null)); | |
690 default: | |
691 } | |
692 } | |
693 if (ex instanceof TypeError) { | |
694 t2 = $.get$TypeErrorDecoder_noSuchMethodPattern(); | |
695 t3 = $.get$TypeErrorDecoder_notClosurePattern(); | |
696 t4 = $.get$TypeErrorDecoder_nullCallPattern(); | |
697 nullLiteralCall = $.get$TypeErrorDecoder_nullLiteralCallPattern(); | |
698 t5 = $.get$TypeErrorDecoder_undefinedCallPattern(); | |
699 t6 = $.get$TypeErrorDecoder_undefinedLiteralCallPattern(); | |
700 t7 = $.get$TypeErrorDecoder_nullPropertyPattern(); | |
701 $.get$TypeErrorDecoder_nullLiteralPropertyPattern(); | |
702 t8 = $.get$TypeErrorDecoder_undefinedPropertyPattern(); | |
703 t9 = $.get$TypeErrorDecoder_undefinedLiteralPropertyPattern(); | |
704 match = t2.matchTypeError$1(message); | |
705 if (match != null) | |
706 return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
707 else { | |
708 match = t3.matchTypeError$1(message); | |
709 if (match != null) { | |
710 match.method = "call"; | |
711 return t1.call$1(H.JsNoSuchMethodError$(message, match)); | |
712 } else { | |
713 match = t4.matchTypeError$1(message); | |
714 if (match == null) { | |
715 match = nullLiteralCall.matchTypeError$1(message); | |
716 if (match == null) { | |
717 match = t5.matchTypeError$1(message); | |
718 if (match == null) { | |
719 match = t6.matchTypeError$1(message); | |
720 if (match == null) { | |
721 match = t7.matchTypeError$1(message); | |
722 if (match == null) { | |
723 match = nullLiteralCall.matchTypeError$1(message); | |
724 if (match == null) { | |
725 match = t8.matchTypeError$1(message); | |
726 if (match == null) { | |
727 match = t9.matchTypeError$1(message); | |
728 t2 = match != null; | |
729 } else | |
730 t2 = true; | |
731 } else | |
732 t2 = true; | |
733 } else | |
734 t2 = true; | |
735 } else | |
736 t2 = true; | |
737 } else | |
738 t2 = true; | |
739 } else | |
740 t2 = true; | |
741 } else | |
742 t2 = true; | |
743 if (t2) { | |
744 t2 = match == null ? null : match.method; | |
745 return t1.call$1(new H.NullError(message, t2)); | |
746 } | |
747 } | |
748 } | |
749 t2 = typeof message === "string" ? message : ""; | |
750 return t1.call$1(new H.UnknownJsTypeError(t2)); | |
751 } | |
752 if (ex instanceof RangeError) { | |
753 if (typeof message === "string" && message.indexOf("call stack") !== -1) | |
754 return new P.StackOverflowError(); | |
755 return t1.call$1(new P.ArgumentError(null)); | |
756 } | |
757 if (typeof InternalError == "function" && ex instanceof InternalError) | |
758 if (typeof message === "string" && message === "too much recursion") | |
759 return new P.StackOverflowError(); | |
760 return ex; | |
761 }, | |
762 | |
763 objectHashCode: function(object) { | |
764 if (object == null || typeof object != 'object') | |
765 return J.get$hashCode$(object); | |
766 else | |
767 return H.Primitives_objectHashCode(object); | |
768 }, | |
769 | |
770 fillLiteralMap: function(keyValuePairs, result) { | |
771 var $length, index, index0, index1; | |
772 $length = keyValuePairs.length; | |
773 for (index = 0; index < $length; index = index1) { | |
774 index0 = index + 1; | |
775 index1 = index0 + 1; | |
776 result.$indexSet(result, keyValuePairs[index], keyValuePairs[index0]); | |
777 } | |
778 return result; | |
779 }, | |
780 | |
781 invokeClosure: function(closure, isolate, numberOfArguments, arg1, arg2, arg3, a
rg4) { | |
782 var t1 = J.getInterceptor(numberOfArguments); | |
783 if (t1.$eq(numberOfArguments, 0)) | |
784 return new H.invokeClosure_closure(closure).call$0(); | |
785 else if (t1.$eq(numberOfArguments, 1)) | |
786 return new H.invokeClosure_closure0(closure, arg1).call$0(); | |
787 else if (t1.$eq(numberOfArguments, 2)) | |
788 return new H.invokeClosure_closure1(closure, arg1, arg2).call$0(); | |
789 else if (t1.$eq(numberOfArguments, 3)) | |
790 return new H.invokeClosure_closure2(closure, arg1, arg2, arg3).call$0(); | |
791 else if (t1.$eq(numberOfArguments, 4)) | |
792 return new H.invokeClosure_closure3(closure, arg1, arg2, arg3, arg4).call$0(
); | |
793 else | |
794 throw H.wrapException(P.Exception_Exception("Unsupported number of arguments
for wrapped closure")); | |
795 }, | |
796 | |
797 convertDartClosureToJS: function(closure, arity) { | |
798 var $function; | |
799 if (closure == null) | |
800 return; | |
801 $function = closure.$identity; | |
802 if (!!$function) | |
803 return $function; | |
804 $function = (function(closure, arity, context, invoke) { return function(a1,
a2, a3, a4) { return invoke(closure, context, arity, a1, a2, a3, a4); };})(
closure,arity,$,H.invokeClosure$closure.call$7); | |
805 closure.$identity = $function; | |
806 return $function; | |
807 }, | |
808 | |
809 throwCyclicInit: function(staticName) { | |
810 throw H.wrapException(P.CyclicInitializationError$("Cyclic initialization for
static " + H.S(staticName))); | |
811 }, | |
812 | |
813 setRuntimeTypeInfo: function(target, typeInfo) { | |
814 if (target != null) | |
815 target.$builtinTypeInfo = typeInfo; | |
816 return target; | |
817 }, | |
818 | |
819 getRuntimeTypeInfo: function(target) { | |
820 if (target == null) | |
821 return; | |
822 return target.$builtinTypeInfo; | |
823 }, | |
824 | |
825 getRuntimeTypeArguments: function(target, substitutionName) { | |
826 return H.substitute(target["$as" + H.S(substitutionName)], H.getRuntimeTypeInf
o(target)); | |
827 }, | |
828 | |
829 getRuntimeTypeArgument: function(target, substitutionName, index) { | |
830 var $arguments = H.getRuntimeTypeArguments(target, substitutionName); | |
831 return $arguments == null ? null : $arguments[index]; | |
832 }, | |
833 | |
834 getRuntimeTypeAsString: function(runtimeType, onTypeVariable) { | |
835 return runtimeType[0].builtin$cls + H.joinArguments(runtimeType, 1, onTypeVari
able); | |
836 }, | |
837 | |
838 runtimeTypeToString: function(type, onTypeVariable) { | |
839 if (type == null) | |
840 return "dynamic"; | |
841 else if (typeof type === "object" && type !== null && type.constructor === Arr
ay) | |
842 return H.getRuntimeTypeAsString(type, onTypeVariable); | |
843 else if (typeof type == "function") | |
844 return type.builtin$cls; | |
845 else if (typeof type === "number" && Math.floor(type) === type) | |
846 return C.JSInt_methods.toString$0(type); | |
847 else | |
848 return; | |
849 }, | |
850 | |
851 joinArguments: function(types, startIndex, onTypeVariable) { | |
852 var buffer, index, firstArgument, allDynamic, argument, str; | |
853 if (types == null) | |
854 return ""; | |
855 buffer = P.StringBuffer$(""); | |
856 for (index = startIndex, firstArgument = true, allDynamic = true; index < type
s.length; ++index) { | |
857 if (firstArgument) | |
858 firstArgument = false; | |
859 else | |
860 buffer._contents = buffer._contents + ", "; | |
861 argument = types[index]; | |
862 if (argument != null) | |
863 allDynamic = false; | |
864 str = H.runtimeTypeToString(argument, onTypeVariable); | |
865 str = typeof str === "string" ? str : H.S(str); | |
866 buffer._contents = buffer._contents + str; | |
867 } | |
868 return allDynamic ? "" : "<" + H.S(buffer) + ">"; | |
869 }, | |
870 | |
871 substitute: function(substitution, $arguments) { | |
872 if (typeof substitution === "object" && substitution !== null && substitution.
constructor === Array) | |
873 $arguments = substitution; | |
874 else if (typeof substitution == "function") { | |
875 substitution = H.invokeOn(substitution, null, $arguments); | |
876 if (typeof substitution === "object" && substitution !== null && substitutio
n.constructor === Array) | |
877 $arguments = substitution; | |
878 else if (typeof substitution == "function") | |
879 $arguments = H.invokeOn(substitution, null, $arguments); | |
880 } | |
881 return $arguments; | |
882 }, | |
883 | |
884 invokeOn: function($function, receiver, $arguments) { | |
885 return $function.apply(receiver, $arguments); | |
886 }, | |
887 | |
888 toStringForNativeObject: function(obj) { | |
889 var t1 = $.getTagFunction; | |
890 return "Instance of " + (t1 == null ? "<Unknown>" : t1.call$1(obj)); | |
891 }, | |
892 | |
893 hashCodeForNativeObject: function(object) { | |
894 return H.Primitives_objectHashCode(object); | |
895 }, | |
896 | |
897 defineProperty: function(obj, property, value) { | |
898 Object.defineProperty(obj, property, {value: value, enumerable: false, writabl
e: true, configurable: true}); | |
899 }, | |
900 | |
901 lookupAndCacheInterceptor: function(obj) { | |
902 var tag, record, interceptor, interceptorClass, mark, t1; | |
903 tag = $.getTagFunction.call$1(obj); | |
904 record = $.dispatchRecordsForInstanceTags[tag]; | |
905 if (record != null) { | |
906 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
907 return record.i; | |
908 } | |
909 interceptor = $.interceptorsForUncacheableTags[tag]; | |
910 if (interceptor != null) | |
911 return interceptor; | |
912 interceptorClass = init.interceptorsByTag[tag]; | |
913 if (interceptorClass == null) { | |
914 tag = $.alternateTagFunction.call$2(obj, tag); | |
915 if (tag != null) { | |
916 record = $.dispatchRecordsForInstanceTags[tag]; | |
917 if (record != null) { | |
918 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, en
umerable: false, writable: true, configurable: true}); | |
919 return record.i; | |
920 } | |
921 interceptor = $.interceptorsForUncacheableTags[tag]; | |
922 if (interceptor != null) | |
923 return interceptor; | |
924 interceptorClass = init.interceptorsByTag[tag]; | |
925 } | |
926 } | |
927 if (interceptorClass == null) | |
928 return; | |
929 interceptor = interceptorClass.prototype; | |
930 mark = tag[0]; | |
931 if (mark === "!") { | |
932 record = H.makeLeafDispatchRecord(interceptor); | |
933 $.dispatchRecordsForInstanceTags[tag] = record; | |
934 Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
935 return record.i; | |
936 } | |
937 if (mark === "~") { | |
938 $.interceptorsForUncacheableTags[tag] = interceptor; | |
939 return interceptor; | |
940 } | |
941 if (mark === "-") { | |
942 t1 = H.makeLeafDispatchRecord(interceptor); | |
943 Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName,
{value: t1, enumerable: false, writable: true, configurable: true}); | |
944 return t1.i; | |
945 } | |
946 if (mark === "+") | |
947 return H.patchInteriorProto(obj, interceptor); | |
948 if (mark === "*") | |
949 throw H.wrapException(P.UnimplementedError$(tag)); | |
950 if (init.leafTags[tag] === true) { | |
951 t1 = H.makeLeafDispatchRecord(interceptor); | |
952 Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName,
{value: t1, enumerable: false, writable: true, configurable: true}); | |
953 return t1.i; | |
954 } else | |
955 return H.patchInteriorProto(obj, interceptor); | |
956 }, | |
957 | |
958 patchInteriorProto: function(obj, interceptor) { | |
959 var proto, record; | |
960 proto = Object.getPrototypeOf(obj); | |
961 record = J.makeDispatchRecord(interceptor, proto, null, null); | |
962 Object.defineProperty(proto, init.dispatchPropertyName, {value: record, enumer
able: false, writable: true, configurable: true}); | |
963 return interceptor; | |
964 }, | |
965 | |
966 makeLeafDispatchRecord: function(interceptor) { | |
967 return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScr
iptIndexingBehavior); | |
968 }, | |
969 | |
970 makeDefaultDispatchRecord: function(tag, interceptorClass, proto) { | |
971 var interceptor = interceptorClass.prototype; | |
972 if (init.leafTags[tag] === true) | |
973 return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaS
criptIndexingBehavior); | |
974 else | |
975 return J.makeDispatchRecord(interceptor, proto, null, null); | |
976 }, | |
977 | |
978 initNativeDispatch: function() { | |
979 if (true === $.initNativeDispatchFlag) | |
980 return; | |
981 $.initNativeDispatchFlag = true; | |
982 H.initNativeDispatchContinue(); | |
983 }, | |
984 | |
985 initNativeDispatchContinue: function() { | |
986 var map, tags, i, tag, proto, record, interceptorClass; | |
987 $.dispatchRecordsForInstanceTags = Object.create(null); | |
988 $.interceptorsForUncacheableTags = Object.create(null); | |
989 H.initHooks(); | |
990 map = init.interceptorsByTag; | |
991 tags = Object.getOwnPropertyNames(map); | |
992 if (typeof window != "undefined") { | |
993 window; | |
994 for (i = 0; i < tags.length; ++i) { | |
995 tag = tags[i]; | |
996 proto = $.prototypeForTagFunction.call$1(tag); | |
997 if (proto != null) { | |
998 record = H.makeDefaultDispatchRecord(tag, map[tag], proto); | |
999 if (record != null) | |
1000 Object.defineProperty(proto, init.dispatchPropertyName, {value: record
, enumerable: false, writable: true, configurable: true}); | |
1001 } | |
1002 } | |
1003 } | |
1004 for (i = 0; i < tags.length; ++i) { | |
1005 tag = tags[i]; | |
1006 if (/^[A-Za-z_]/.test(tag)) { | |
1007 interceptorClass = map[tag]; | |
1008 map["!" + tag] = interceptorClass; | |
1009 map["~" + tag] = interceptorClass; | |
1010 map["-" + tag] = interceptorClass; | |
1011 map["+" + tag] = interceptorClass; | |
1012 map["*" + tag] = interceptorClass; | |
1013 } | |
1014 } | |
1015 }, | |
1016 | |
1017 initHooks: function() { | |
1018 var hooks, transformers, i, transformer, getTag, getUnknownTag, prototypeForTa
g; | |
1019 hooks = C.JS_CONST_TtD(); | |
1020 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)))))); | |
1021 if (typeof dartNativeDispatchHooksTransformer != "undefined") { | |
1022 transformers = dartNativeDispatchHooksTransformer; | |
1023 if (typeof transformers == "function") | |
1024 transformers = [transformers]; | |
1025 if (transformers.constructor == Array) | |
1026 for (i = 0; i < transformers.length; ++i) { | |
1027 transformer = transformers[i]; | |
1028 if (typeof transformer == "function") | |
1029 hooks = transformer(hooks) || hooks; | |
1030 } | |
1031 } | |
1032 getTag = hooks.getTag; | |
1033 getUnknownTag = hooks.getUnknownTag; | |
1034 prototypeForTag = hooks.prototypeForTag; | |
1035 $.getTagFunction = new H.initHooks_closure(getTag); | |
1036 $.alternateTagFunction = new H.initHooks_closure0(getUnknownTag); | |
1037 $.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag); | |
1038 }, | |
1039 | |
1040 applyHooksTransformer: function(transformer, hooks) { | |
1041 return transformer(hooks) || hooks; | |
1042 }, | |
1043 | |
1044 JSInvocationMirror: {"": "Object;__js_helper$_memberName,_internalName,_kind,_ar
guments,_namedArgumentNames,_namedIndices", | |
1045 get$memberName: function() { | |
1046 return this.__js_helper$_memberName; | |
1047 }, | |
1048 get$positionalArguments: function() { | |
1049 var t1, argumentCount, list, index; | |
1050 if (this._kind === 1) | |
1051 return C.List_empty; | |
1052 t1 = this._arguments; | |
1053 argumentCount = t1.length - this._namedArgumentNames.length; | |
1054 if (argumentCount === 0) | |
1055 return C.List_empty; | |
1056 list = []; | |
1057 for (index = 0; index < argumentCount; ++index) { | |
1058 if (index >= t1.length) | |
1059 throw H.ioore(t1, index); | |
1060 list.push(t1[index]); | |
1061 } | |
1062 return H.makeLiteralListConst(list); | |
1063 }, | |
1064 get$namedArguments: function() { | |
1065 var t1, namedArgumentCount, t2, namedArgumentsStartIndex, map, i, t3, t4; | |
1066 if (this._kind !== 0) { | |
1067 t1 = H.fillLiteralMap([], P.LinkedHashMap_LinkedHashMap(null, null, null,
null, null)); | |
1068 H.setRuntimeTypeInfo(t1, [P.Symbol, null]); | |
1069 return t1; | |
1070 } | |
1071 t1 = this._namedArgumentNames; | |
1072 namedArgumentCount = t1.length; | |
1073 t2 = this._arguments; | |
1074 namedArgumentsStartIndex = t2.length - namedArgumentCount; | |
1075 if (namedArgumentCount === 0) { | |
1076 t1 = H.fillLiteralMap([], P.LinkedHashMap_LinkedHashMap(null, null, null,
null, null)); | |
1077 H.setRuntimeTypeInfo(t1, [P.Symbol, null]); | |
1078 return t1; | |
1079 } | |
1080 map = P.LinkedHashMap_LinkedHashMap(null, null, null, P.Symbol, null); | |
1081 for (i = 0; i < namedArgumentCount; ++i) { | |
1082 if (i >= t1.length) | |
1083 throw H.ioore(t1, i); | |
1084 t3 = t1[i]; | |
1085 t4 = namedArgumentsStartIndex + i; | |
1086 if (t4 < 0 || t4 >= t2.length) | |
1087 throw H.ioore(t2, t4); | |
1088 map.$indexSet(map, new H.Symbol0(t3), t2[t4]); | |
1089 } | |
1090 return map; | |
1091 }, | |
1092 static: { | |
1093 "": "JSInvocationMirror_METHOD,JSInvocationMirror_GETTER,JSInvocationMirror_SETT
ER", | |
1094 } | |
1095 | |
1096 }, | |
1097 | |
1098 Primitives_applyFunction_closure: {"": "Closure;allNamedArguments_1", | |
1099 call$2: function(key, argument) { | |
1100 this.allNamedArguments_1[key] = argument; | |
1101 }, | |
1102 "+call:2:0": 0, | |
1103 $isFunction: true | |
1104 }, | |
1105 | |
1106 Primitives_applyFunction_closure0: {"": "Closure;buffer_2,arguments_3,allNamedAr
guments_4", | |
1107 call$1: function($name) { | |
1108 this.buffer_2.write$1("$" + H.S($name)); | |
1109 this.arguments_3.push(this.allNamedArguments_4[$name]); | |
1110 }, | |
1111 "+call:1:0": 0, | |
1112 $isFunction: true | |
1113 }, | |
1114 | |
1115 Primitives_applyFunction_closure1: {"": "Closure;box_0,buffer_5,arguments_6", | |
1116 call$2: function($name, argument) { | |
1117 var t1; | |
1118 this.buffer_5.write$1("$" + H.S($name)); | |
1119 this.arguments_6.push(argument); | |
1120 t1 = this.box_0; | |
1121 t1.argumentCount_0 = t1.argumentCount_0 + 1; | |
1122 }, | |
1123 "+call:2:0": 0, | |
1124 $isFunction: true | |
1125 }, | |
1126 | |
1127 TypeErrorDecoder: {"": "Object;_pattern,_arguments,_argumentsExpr,_expr,_method,
_receiver", | |
1128 matchTypeError$1: function(message) { | |
1129 var match, result, t1; | |
1130 match = new RegExp(this._pattern).exec(message); | |
1131 if (match == null) | |
1132 return; | |
1133 result = {}; | |
1134 t1 = this._arguments; | |
1135 if (t1 !== -1) | |
1136 result.arguments = match[t1 + 1]; | |
1137 t1 = this._argumentsExpr; | |
1138 if (t1 !== -1) | |
1139 result.argumentsExpr = match[t1 + 1]; | |
1140 t1 = this._expr; | |
1141 if (t1 !== -1) | |
1142 result.expr = match[t1 + 1]; | |
1143 t1 = this._method; | |
1144 if (t1 !== -1) | |
1145 result.method = match[t1 + 1]; | |
1146 t1 = this._receiver; | |
1147 if (t1 !== -1) | |
1148 result.receiver = match[t1 + 1]; | |
1149 return result; | |
1150 }, | |
1151 static: { | |
1152 "": "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", | |
1153 TypeErrorDecoder_extractPattern: function(message) { | |
1154 var match, $arguments, argumentsExpr, expr, method, receiver; | |
1155 message = message.replace(String({}), '$receiver$').replace(new RegExp("[[\\]{
}()*+?.\\\\^$|]", 'g'), '\\$&'); | |
1156 match = message.match(/\\\$[a-zA-Z]+\\\$/g); | |
1157 if (match == null) | |
1158 match = []; | |
1159 $arguments = match.indexOf("\\$arguments\\$"); | |
1160 argumentsExpr = match.indexOf("\\$argumentsExpr\\$"); | |
1161 expr = match.indexOf("\\$expr\\$"); | |
1162 method = match.indexOf("\\$method\\$"); | |
1163 receiver = match.indexOf("\\$receiver\\$"); | |
1164 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); | |
1165 }, | |
1166 | |
1167 TypeErrorDecoder_provokeCallErrorOn: function(expression) { | |
1168 return function($expr$) { | |
1169 var $argumentsExpr$ = '$arguments$' | |
1170 try { | |
1171 $expr$.$method$($argumentsExpr$); | |
1172 } catch (e) { | |
1173 return e.message; | |
1174 } | |
1175 }(expression); | |
1176 }, | |
1177 | |
1178 TypeErrorDecoder_provokeCallErrorOnNull: function() { | |
1179 return function() { | |
1180 var $argumentsExpr$ = '$arguments$' | |
1181 try { | |
1182 null.$method$($argumentsExpr$); | |
1183 } catch (e) { | |
1184 return e.message; | |
1185 } | |
1186 }(); | |
1187 }, | |
1188 | |
1189 TypeErrorDecoder_provokeCallErrorOnUndefined: function() { | |
1190 return function() { | |
1191 var $argumentsExpr$ = '$arguments$' | |
1192 try { | |
1193 (void 0).$method$($argumentsExpr$); | |
1194 } catch (e) { | |
1195 return e.message; | |
1196 } | |
1197 }(); | |
1198 }, | |
1199 | |
1200 TypeErrorDecoder_provokePropertyErrorOn: function(expression) { | |
1201 return function($expr$) { | |
1202 try { | |
1203 $expr$.$method$; | |
1204 } catch (e) { | |
1205 return e.message; | |
1206 } | |
1207 }(expression); | |
1208 }, | |
1209 | |
1210 TypeErrorDecoder_provokePropertyErrorOnNull: function() { | |
1211 return function() { | |
1212 try { | |
1213 null.$method$; | |
1214 } catch (e) { | |
1215 return e.message; | |
1216 } | |
1217 }(); | |
1218 }, | |
1219 | |
1220 TypeErrorDecoder_provokePropertyErrorOnUndefined: function() { | |
1221 return function() { | |
1222 try { | |
1223 (void 0).$method$; | |
1224 } catch (e) { | |
1225 return e.message; | |
1226 } | |
1227 }(); | |
1228 }} | |
1229 | |
1230 }, | |
1231 | |
1232 NullError: {"": "Error;_message,_method", | |
1233 toString$0: function(_) { | |
1234 var t1 = this._method; | |
1235 if (t1 == null) | |
1236 return "NullError: " + H.S(this._message); | |
1237 return "NullError: Cannot call \"" + H.S(t1) + "\" on null"; | |
1238 }, | |
1239 $isError: true | |
1240 }, | |
1241 | |
1242 JsNoSuchMethodError: {"": "Error;_message,_method,_receiver", | |
1243 toString$0: function(_) { | |
1244 var t1, t2; | |
1245 t1 = this._method; | |
1246 if (t1 == null) | |
1247 return "NoSuchMethodError: " + H.S(this._message); | |
1248 t2 = this._receiver; | |
1249 if (t2 == null) | |
1250 return "NoSuchMethodError: Cannot call \"" + t1 + "\" (" + H.S(this._messa
ge) + ")"; | |
1251 return "NoSuchMethodError: Cannot call \"" + t1 + "\" on \"" + t2 + "\" (" +
H.S(this._message) + ")"; | |
1252 }, | |
1253 $isError: true, | |
1254 static: { | |
1255 JsNoSuchMethodError$: function(_message, match) { | |
1256 var t1, t2; | |
1257 t1 = match == null; | |
1258 t2 = t1 ? null : match.method; | |
1259 t1 = t1 ? null : match.receiver; | |
1260 return new H.JsNoSuchMethodError(_message, t2, t1); | |
1261 }} | |
1262 | |
1263 }, | |
1264 | |
1265 UnknownJsTypeError: {"": "Error;_message", | |
1266 toString$0: function(_) { | |
1267 var t1 = this._message; | |
1268 return C.JSString_methods.get$isEmpty(t1) ? "Error" : "Error: " + t1; | |
1269 } | |
1270 }, | |
1271 | |
1272 unwrapException_saveStackTrace: {"": "Closure;ex_0", | |
1273 call$1: function(error) { | |
1274 var t1 = J.getInterceptor(error); | |
1275 if (typeof error === "object" && error !== null && !!t1.$isError) | |
1276 if (error.$thrownJsError == null) | |
1277 error.$thrownJsError = this.ex_0; | |
1278 return error; | |
1279 }, | |
1280 "+call:1:0": 0, | |
1281 $isFunction: true | |
1282 }, | |
1283 | |
1284 invokeClosure_closure: {"": "Closure;closure_0", | |
1285 call$0: function() { | |
1286 return this.closure_0.call$0(); | |
1287 }, | |
1288 "+call:0:0": 0, | |
1289 $isFunction: true | |
1290 }, | |
1291 | |
1292 invokeClosure_closure0: {"": "Closure;closure_1,arg1_2", | |
1293 call$0: function() { | |
1294 return this.closure_1.call$1(this.arg1_2); | |
1295 }, | |
1296 "+call:0:0": 0, | |
1297 $isFunction: true | |
1298 }, | |
1299 | |
1300 invokeClosure_closure1: {"": "Closure;closure_3,arg1_4,arg2_5", | |
1301 call$0: function() { | |
1302 return this.closure_3.call$2(this.arg1_4, this.arg2_5); | |
1303 }, | |
1304 "+call:0:0": 0, | |
1305 $isFunction: true | |
1306 }, | |
1307 | |
1308 invokeClosure_closure2: {"": "Closure;closure_6,arg1_7,arg2_8,arg3_9", | |
1309 call$0: function() { | |
1310 return this.closure_6.call$3(this.arg1_7, this.arg2_8, this.arg3_9); | |
1311 }, | |
1312 "+call:0:0": 0, | |
1313 $isFunction: true | |
1314 }, | |
1315 | |
1316 invokeClosure_closure3: {"": "Closure;closure_10,arg1_11,arg2_12,arg3_13,arg4_14
", | |
1317 call$0: function() { | |
1318 return this.closure_10.call$4(this.arg1_11, this.arg2_12, this.arg3_13, this
.arg4_14); | |
1319 }, | |
1320 "+call:0:0": 0, | |
1321 $isFunction: true | |
1322 }, | |
1323 | |
1324 Closure: {"": "Object;", | |
1325 toString$0: function(_) { | |
1326 return "Closure"; | |
1327 }, | |
1328 $isFunction: true | |
1329 }, | |
1330 | |
1331 initHooks_closure: {"": "Closure;getTag_0", | |
1332 call$1: function(o) { | |
1333 return this.getTag_0(o); | |
1334 }, | |
1335 "+call:1:0": 0, | |
1336 $isFunction: true | |
1337 }, | |
1338 | |
1339 initHooks_closure0: {"": "Closure;getUnknownTag_1", | |
1340 call$2: function(o, tag) { | |
1341 return this.getUnknownTag_1(o, tag); | |
1342 }, | |
1343 "+call:2:0": 0, | |
1344 $isFunction: true | |
1345 }, | |
1346 | |
1347 initHooks_closure1: {"": "Closure;prototypeForTag_2", | |
1348 call$1: function(tag) { | |
1349 return this.prototypeForTag_2(tag); | |
1350 }, | |
1351 "+call:1:0": 0, | |
1352 $isFunction: true | |
1353 }}], | |
1354 ["dart._collection.dev", "dart:_collection-dev", , H, { | |
1355 IterableMixinWorkaround_forEach: function(iterable, f) { | |
1356 var t1; | |
1357 for (t1 = new H.ListIterator(iterable, iterable.length, 0, null); t1.moveNext$
0();) | |
1358 f.call$1(t1._current); | |
1359 }, | |
1360 | |
1361 IterableMixinWorkaround_toStringIterable: function(iterable, leftDelimiter, righ
tDelimiter) { | |
1362 var result, i, t1; | |
1363 for (i = 0; i < $.get$IterableMixinWorkaround__toStringList().length; ++i) { | |
1364 t1 = $.get$IterableMixinWorkaround__toStringList(); | |
1365 if (i >= t1.length) | |
1366 throw H.ioore(t1, i); | |
1367 if (t1[i] === iterable) | |
1368 return H.S(leftDelimiter) + "..." + H.S(rightDelimiter); | |
1369 } | |
1370 result = P.StringBuffer$(""); | |
1371 try { | |
1372 $.get$IterableMixinWorkaround__toStringList().push(iterable); | |
1373 result.write$1(leftDelimiter); | |
1374 result.writeAll$2(iterable, ", "); | |
1375 result.write$1(rightDelimiter); | |
1376 } finally { | |
1377 t1 = $.get$IterableMixinWorkaround__toStringList(); | |
1378 if (0 >= t1.length) | |
1379 throw H.ioore(t1, 0); | |
1380 t1.pop(); | |
1381 } | |
1382 return result.get$_contents(); | |
1383 }, | |
1384 | |
1385 ListIterable: {"": "IterableBase;", | |
1386 get$iterator: function(_) { | |
1387 return new H.ListIterator(this, this.get$length(this), 0, null); | |
1388 }, | |
1389 forEach$1: function(_, action) { | |
1390 var $length, i; | |
1391 $length = this.get$length(this); | |
1392 if (typeof $length !== "number") | |
1393 throw H.iae($length); | |
1394 i = 0; | |
1395 for (; i < $length; ++i) { | |
1396 action.call$1(this.elementAt$1(this, i)); | |
1397 if ($length !== this.get$length(this)) | |
1398 throw H.wrapException(P.ConcurrentModificationError$(this)); | |
1399 } | |
1400 }, | |
1401 map$1: function(_, f) { | |
1402 var t1 = new H.MappedListIterable(this, f); | |
1403 H.setRuntimeTypeInfo(t1, [null, null]); | |
1404 return t1; | |
1405 }, | |
1406 $asIterableBase: null, | |
1407 $isEfficientLength: true | |
1408 }, | |
1409 | |
1410 ListIterator: {"": "Object;_iterable,_length,_index,_current", | |
1411 get$current: function() { | |
1412 return this._current; | |
1413 }, | |
1414 moveNext$0: function() { | |
1415 var t1, t2, $length, t3; | |
1416 t1 = this._iterable; | |
1417 t2 = J.getInterceptor$asx(t1); | |
1418 $length = t2.get$length(t1); | |
1419 if (!J.$eq(this._length, $length)) | |
1420 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
1421 t3 = this._index; | |
1422 if (typeof $length !== "number") | |
1423 throw H.iae($length); | |
1424 if (t3 >= $length) { | |
1425 this._current = null; | |
1426 return false; | |
1427 } | |
1428 this._current = t2.elementAt$1(t1, t3); | |
1429 this._index = this._index + 1; | |
1430 return true; | |
1431 } | |
1432 }, | |
1433 | |
1434 MappedIterable: {"": "IterableBase;_iterable,_f", | |
1435 get$iterator: function(_) { | |
1436 var t1 = this._iterable; | |
1437 t1 = t1.get$iterator(t1); | |
1438 t1 = new H.MappedIterator(null, t1, this._f); | |
1439 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "MappedIterable", 0
), H.getRuntimeTypeArgument(this, "MappedIterable", 1)]); | |
1440 return t1; | |
1441 }, | |
1442 get$length: function(_) { | |
1443 var t1 = this._iterable; | |
1444 return t1.get$length(t1); | |
1445 }, | |
1446 $asIterableBase: function($S, $T) { | |
1447 return [$T]; | |
1448 }, | |
1449 static: { | |
1450 MappedIterable_MappedIterable: function(iterable, $function, $S, $T) { | |
1451 var t1; | |
1452 if (!!iterable.$isEfficientLength) { | |
1453 t1 = new H.EfficientLengthMappedIterable(iterable, $function); | |
1454 H.setRuntimeTypeInfo(t1, [$S, $T]); | |
1455 return t1; | |
1456 } | |
1457 t1 = new H.MappedIterable(iterable, $function); | |
1458 H.setRuntimeTypeInfo(t1, [$S, $T]); | |
1459 return t1; | |
1460 }} | |
1461 | |
1462 }, | |
1463 | |
1464 EfficientLengthMappedIterable: {"": "MappedIterable;_iterable,_f", $asMappedIter
able: null, $isEfficientLength: true}, | |
1465 | |
1466 MappedIterator: {"": "Iterator;_current,_iterator,_f", | |
1467 _f$1: function(arg0) { | |
1468 return this._f.call$1(arg0); | |
1469 }, | |
1470 moveNext$0: function() { | |
1471 var t1 = this._iterator; | |
1472 if (t1.moveNext$0()) { | |
1473 this._current = this._f$1(t1.get$current()); | |
1474 return true; | |
1475 } | |
1476 this._current = null; | |
1477 return false; | |
1478 }, | |
1479 get$current: function() { | |
1480 return this._current; | |
1481 }, | |
1482 $asIterator: function($S, $T) { | |
1483 return [$T]; | |
1484 } | |
1485 }, | |
1486 | |
1487 MappedListIterable: {"": "ListIterable;_source,_f", | |
1488 _f$1: function(arg0) { | |
1489 return this._f.call$1(arg0); | |
1490 }, | |
1491 get$length: function(_) { | |
1492 return J.get$length$asx(this._source); | |
1493 }, | |
1494 elementAt$1: function(_, index) { | |
1495 return this._f$1(J.elementAt$1$ax(this._source, index)); | |
1496 }, | |
1497 $asListIterable: function($S, $T) { | |
1498 return [$T]; | |
1499 }, | |
1500 $isEfficientLength: true | |
1501 }, | |
1502 | |
1503 FixedLengthListMixin: {"": "Object;"}, | |
1504 | |
1505 Symbol0: {"": "Object;_name<", | |
1506 $eq: function(_, other) { | |
1507 var t1; | |
1508 if (other == null) | |
1509 return false; | |
1510 t1 = J.getInterceptor(other); | |
1511 return typeof other === "object" && other !== null && !!t1.$isSymbol0 && J.$
eq(this._name, other._name); | |
1512 }, | |
1513 get$hashCode: function(_) { | |
1514 return 536870911 & 664597 * J.get$hashCode$(this._name); | |
1515 }, | |
1516 toString$0: function(_) { | |
1517 return "Symbol(\"" + H.S(this._name) + "\")"; | |
1518 }, | |
1519 $isSymbol0: true, | |
1520 static: { | |
1521 "": "Symbol_validationPattern", | |
1522 } | |
1523 | |
1524 }}], | |
1525 ["dart.collection", "dart:collection", , P, { | |
1526 _defaultEquals: function(a, b) { | |
1527 return J.$eq(a, b); | |
1528 }, | |
1529 | |
1530 _defaultHashCode: function(a) { | |
1531 return J.get$hashCode$(a); | |
1532 }, | |
1533 | |
1534 HashSet_HashSet$identity: function($E) { | |
1535 var t1 = new P._IdentityHashSet(0, null, null, null, null); | |
1536 H.setRuntimeTypeInfo(t1, [$E]); | |
1537 return t1; | |
1538 }, | |
1539 | |
1540 _iterableToString: function(iterable) { | |
1541 var parts, t1; | |
1542 t1 = $.get$_toStringVisiting(); | |
1543 if (t1.contains$1(t1, iterable)) | |
1544 return "(...)"; | |
1545 t1 = $.get$_toStringVisiting(); | |
1546 t1.add$1(t1, iterable); | |
1547 parts = []; | |
1548 try { | |
1549 P._iterablePartsToStrings(iterable, parts); | |
1550 } finally { | |
1551 t1 = $.get$_toStringVisiting(); | |
1552 t1.remove$1(t1, iterable); | |
1553 } | |
1554 t1 = P.StringBuffer$("("); | |
1555 t1.writeAll$2(parts, ", "); | |
1556 t1.write$1(")"); | |
1557 return t1._contents; | |
1558 }, | |
1559 | |
1560 _iterablePartsToStrings: function(iterable, parts) { | |
1561 var it, $length, count, next, ultimateString, penultimateString, penultimate,
ultimate, ultimate0, elision; | |
1562 it = iterable.get$iterator(iterable); | |
1563 $length = 0; | |
1564 count = 0; | |
1565 while (true) { | |
1566 if (!($length < 80 || count < 3)) | |
1567 break; | |
1568 if (!it.moveNext$0()) | |
1569 return; | |
1570 next = H.S(it.get$current()); | |
1571 parts.push(next); | |
1572 $length += next.length + 2; | |
1573 ++count; | |
1574 } | |
1575 if (!it.moveNext$0()) { | |
1576 if (count <= 5) | |
1577 return; | |
1578 if (0 >= parts.length) | |
1579 throw H.ioore(parts, 0); | |
1580 ultimateString = parts.pop(); | |
1581 if (0 >= parts.length) | |
1582 throw H.ioore(parts, 0); | |
1583 penultimateString = parts.pop(); | |
1584 } else { | |
1585 penultimate = it.get$current(); | |
1586 ++count; | |
1587 if (!it.moveNext$0()) { | |
1588 if (count <= 4) { | |
1589 parts.push(H.S(penultimate)); | |
1590 return; | |
1591 } | |
1592 ultimateString = H.S(penultimate); | |
1593 if (0 >= parts.length) | |
1594 throw H.ioore(parts, 0); | |
1595 penultimateString = parts.pop(); | |
1596 $length += ultimateString.length + 2; | |
1597 } else { | |
1598 ultimate = it.get$current(); | |
1599 ++count; | |
1600 for (; it.moveNext$0(); penultimate = ultimate, ultimate = ultimate0) { | |
1601 ultimate0 = it.get$current(); | |
1602 ++count; | |
1603 if (count > 100) { | |
1604 while (true) { | |
1605 if (!($length > 75 && count > 3)) | |
1606 break; | |
1607 if (0 >= parts.length) | |
1608 throw H.ioore(parts, 0); | |
1609 $length -= parts.pop().length + 2; | |
1610 --count; | |
1611 } | |
1612 parts.push("..."); | |
1613 return; | |
1614 } | |
1615 } | |
1616 penultimateString = H.S(penultimate); | |
1617 ultimateString = H.S(ultimate); | |
1618 $length += ultimateString.length + penultimateString.length + 4; | |
1619 } | |
1620 } | |
1621 if (count > parts.length + 2) { | |
1622 $length += 5; | |
1623 elision = "..."; | |
1624 } else | |
1625 elision = null; | |
1626 while (true) { | |
1627 if (!($length > 80 && parts.length > 3)) | |
1628 break; | |
1629 if (0 >= parts.length) | |
1630 throw H.ioore(parts, 0); | |
1631 $length -= parts.pop().length + 2; | |
1632 if (elision == null) { | |
1633 $length += 5; | |
1634 elision = "..."; | |
1635 } | |
1636 } | |
1637 if (elision != null) | |
1638 parts.push(elision); | |
1639 parts.push(penultimateString); | |
1640 parts.push(ultimateString); | |
1641 }, | |
1642 | |
1643 LinkedHashMap_LinkedHashMap: function(equals, hashCode, isValidKey, $K, $V) { | |
1644 var t1 = new P._LinkedHashMap(0, null, null, null, null, null, 0); | |
1645 H.setRuntimeTypeInfo(t1, [$K, $V]); | |
1646 return t1; | |
1647 }, | |
1648 | |
1649 Maps_mapToString: function(m) { | |
1650 var t1, result, i, t2; | |
1651 t1 = {}; | |
1652 for (i = 0; i < $.get$Maps__toStringList().length; ++i) { | |
1653 t2 = $.get$Maps__toStringList(); | |
1654 if (i >= t2.length) | |
1655 throw H.ioore(t2, i); | |
1656 if (t2[i] === m) | |
1657 return "{...}"; | |
1658 } | |
1659 result = P.StringBuffer$(""); | |
1660 try { | |
1661 $.get$Maps__toStringList().push(m); | |
1662 result.write$1("{"); | |
1663 t1.first_0 = true; | |
1664 J.forEach$1$ax(m, new P.Maps_mapToString_closure(t1, result)); | |
1665 result.write$1("}"); | |
1666 } finally { | |
1667 t1 = $.get$Maps__toStringList(); | |
1668 if (0 >= t1.length) | |
1669 throw H.ioore(t1, 0); | |
1670 t1.pop(); | |
1671 } | |
1672 return result.get$_contents(); | |
1673 }, | |
1674 | |
1675 _LinkedHashMap: {"": "Object;_collection$_length,_strings,_nums,_rest,_first,_la
st,_modifications", | |
1676 get$length: function(_) { | |
1677 return this._collection$_length; | |
1678 }, | |
1679 get$isEmpty: function(_) { | |
1680 return this._collection$_length === 0; | |
1681 }, | |
1682 get$keys: function() { | |
1683 var t1 = new P.LinkedHashMapKeyIterable(this); | |
1684 H.setRuntimeTypeInfo(t1, [H.getRuntimeTypeArgument(this, "_LinkedHashMap", 0
)]); | |
1685 return t1; | |
1686 }, | |
1687 $index: function(_, key) { | |
1688 var strings, cell, nums, rest, bucket, index; | |
1689 if (typeof key === "string" && key !== "__proto__") { | |
1690 strings = this._strings; | |
1691 if (strings == null) | |
1692 return; | |
1693 cell = strings[key]; | |
1694 return cell == null ? null : cell.get$_value(); | |
1695 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
1696 nums = this._nums; | |
1697 if (nums == null) | |
1698 return; | |
1699 cell = nums[key]; | |
1700 return cell == null ? null : cell.get$_value(); | |
1701 } else { | |
1702 rest = this._rest; | |
1703 if (rest == null) | |
1704 return; | |
1705 bucket = rest[this._computeHashCode$1(key)]; | |
1706 index = this._findBucketIndex$2(bucket, key); | |
1707 if (index < 0) | |
1708 return; | |
1709 return bucket[index].get$_value(); | |
1710 } | |
1711 }, | |
1712 $indexSet: function(_, key, value) { | |
1713 var strings, nums, rest, hash, bucket, index; | |
1714 if (typeof key === "string" && key !== "__proto__") { | |
1715 strings = this._strings; | |
1716 if (strings == null) { | |
1717 strings = P._LinkedHashMap__newHashTable(); | |
1718 this._strings = strings; | |
1719 } | |
1720 this._addHashTableEntry$3(strings, key, value); | |
1721 } else if (typeof key === "number" && (key & 0x3ffffff) === key) { | |
1722 nums = this._nums; | |
1723 if (nums == null) { | |
1724 nums = P._LinkedHashMap__newHashTable(); | |
1725 this._nums = nums; | |
1726 } | |
1727 this._addHashTableEntry$3(nums, key, value); | |
1728 } else { | |
1729 rest = this._rest; | |
1730 if (rest == null) { | |
1731 rest = P._LinkedHashMap__newHashTable(); | |
1732 this._rest = rest; | |
1733 } | |
1734 hash = this._computeHashCode$1(key); | |
1735 bucket = rest[hash]; | |
1736 if (bucket == null) | |
1737 rest[hash] = [this._newLinkedCell$2(key, value)]; | |
1738 else { | |
1739 index = this._findBucketIndex$2(bucket, key); | |
1740 if (index >= 0) | |
1741 bucket[index].set$_value(value); | |
1742 else | |
1743 bucket.push(this._newLinkedCell$2(key, value)); | |
1744 } | |
1745 } | |
1746 }, | |
1747 forEach$1: function(_, action) { | |
1748 var cell, modifications; | |
1749 cell = this._first; | |
1750 modifications = this._modifications; | |
1751 for (; cell != null;) { | |
1752 action.call$2(cell._key, cell._value); | |
1753 if (modifications !== this._modifications) | |
1754 throw H.wrapException(P.ConcurrentModificationError$(this)); | |
1755 cell = cell._next; | |
1756 } | |
1757 }, | |
1758 _addHashTableEntry$3: function(table, key, value) { | |
1759 var cell = table[key]; | |
1760 if (cell == null) | |
1761 table[key] = this._newLinkedCell$2(key, value); | |
1762 else | |
1763 cell.set$_value(value); | |
1764 }, | |
1765 _newLinkedCell$2: function(key, value) { | |
1766 var cell, last; | |
1767 cell = new P.LinkedHashMapCell(key, value, null, null); | |
1768 if (this._first == null) { | |
1769 this._last = cell; | |
1770 this._first = cell; | |
1771 } else { | |
1772 last = this._last; | |
1773 cell._previous = last; | |
1774 last._next = cell; | |
1775 this._last = cell; | |
1776 } | |
1777 this._collection$_length = this._collection$_length + 1; | |
1778 this._modifications = this._modifications + 1 & 67108863; | |
1779 return cell; | |
1780 }, | |
1781 _computeHashCode$1: function(key) { | |
1782 return J.get$hashCode$(key) & 0x3ffffff; | |
1783 }, | |
1784 _findBucketIndex$2: function(bucket, key) { | |
1785 var $length, i; | |
1786 if (bucket == null) | |
1787 return -1; | |
1788 $length = bucket.length; | |
1789 for (i = 0; i < $length; ++i) | |
1790 if (J.$eq(bucket[i].get$_key(), key)) | |
1791 return i; | |
1792 return -1; | |
1793 }, | |
1794 toString$0: function(_) { | |
1795 return P.Maps_mapToString(this); | |
1796 }, | |
1797 static: { | |
1798 _LinkedHashMap__newHashTable: function() { | |
1799 var table = Object.create(null); | |
1800 table["<non-identifier-key>"] = table; | |
1801 delete table["<non-identifier-key>"]; | |
1802 return table; | |
1803 }} | |
1804 | |
1805 }, | |
1806 | |
1807 LinkedHashMapCell: {"": "Object;_key<,_value@,_next,_previous"}, | |
1808 | |
1809 LinkedHashMapKeyIterable: {"": "IterableBase;_map", | |
1810 get$length: function(_) { | |
1811 return this._map._collection$_length; | |
1812 }, | |
1813 get$iterator: function(_) { | |
1814 var t1 = this._map; | |
1815 t1 = new P.LinkedHashMapKeyIterator(t1, t1._modifications, null, null); | |
1816 t1._cell = t1._map._first; | |
1817 return t1; | |
1818 }, | |
1819 forEach$1: function(_, f) { | |
1820 var t1, cell, modifications; | |
1821 t1 = this._map; | |
1822 cell = t1._first; | |
1823 modifications = t1._modifications; | |
1824 for (; cell != null;) { | |
1825 f.call$1(cell._key); | |
1826 if (modifications !== t1._modifications) | |
1827 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
1828 cell = cell._next; | |
1829 } | |
1830 }, | |
1831 $asIterableBase: null, | |
1832 $isEfficientLength: true | |
1833 }, | |
1834 | |
1835 LinkedHashMapKeyIterator: {"": "Object;_map,_modifications,_cell,_collection$_cu
rrent", | |
1836 get$current: function() { | |
1837 return this._collection$_current; | |
1838 }, | |
1839 moveNext$0: function() { | |
1840 var t1 = this._map; | |
1841 if (this._modifications !== t1._modifications) | |
1842 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
1843 else { | |
1844 t1 = this._cell; | |
1845 if (t1 == null) { | |
1846 this._collection$_current = null; | |
1847 return false; | |
1848 } else { | |
1849 this._collection$_current = t1._key; | |
1850 this._cell = this._cell._next; | |
1851 return true; | |
1852 } | |
1853 } | |
1854 } | |
1855 }, | |
1856 | |
1857 _HashSet: {"": "_HashSetBase;", | |
1858 get$iterator: function(_) { | |
1859 return new P.HashSetIterator(this, this._computeElements$0(), 0, null); | |
1860 }, | |
1861 get$length: function(_) { | |
1862 return this._collection$_length; | |
1863 }, | |
1864 contains$1: function(_, object) { | |
1865 var rest = this._rest; | |
1866 if (rest == null) | |
1867 return false; | |
1868 return this._findBucketIndex$2(rest[this._computeHashCode$1(object)], object
) >= 0; | |
1869 }, | |
1870 add$1: function(_, element) { | |
1871 var rest, table, hash, bucket; | |
1872 rest = this._rest; | |
1873 if (rest == null) { | |
1874 table = Object.create(null); | |
1875 table["<non-identifier-key>"] = table; | |
1876 delete table["<non-identifier-key>"]; | |
1877 this._rest = table; | |
1878 rest = table; | |
1879 } | |
1880 hash = this._computeHashCode$1(element); | |
1881 bucket = rest[hash]; | |
1882 if (bucket == null) | |
1883 rest[hash] = [element]; | |
1884 else { | |
1885 if (this._findBucketIndex$2(bucket, element) >= 0) | |
1886 return false; | |
1887 bucket.push(element); | |
1888 } | |
1889 this._collection$_length = this._collection$_length + 1; | |
1890 this._elements = null; | |
1891 return true; | |
1892 }, | |
1893 remove$1: function(_, object) { | |
1894 var rest, bucket, index; | |
1895 rest = this._rest; | |
1896 if (rest == null) | |
1897 return false; | |
1898 bucket = rest[this._computeHashCode$1(object)]; | |
1899 index = this._findBucketIndex$2(bucket, object); | |
1900 if (index < 0) | |
1901 return false; | |
1902 this._collection$_length = this._collection$_length - 1; | |
1903 this._elements = null; | |
1904 bucket.splice(index, 1); | |
1905 return true; | |
1906 }, | |
1907 _computeElements$0: function() { | |
1908 var t1, result, strings, names, entries, index, i, nums, rest, bucket, $leng
th, i0; | |
1909 t1 = this._elements; | |
1910 if (t1 != null) | |
1911 return t1; | |
1912 result = P.List_List(this._collection$_length, null); | |
1913 strings = this._strings; | |
1914 if (strings != null) { | |
1915 names = Object.getOwnPropertyNames(strings); | |
1916 entries = names.length; | |
1917 for (index = 0, i = 0; i < entries; ++i) { | |
1918 result[index] = names[i]; | |
1919 ++index; | |
1920 } | |
1921 } else | |
1922 index = 0; | |
1923 nums = this._nums; | |
1924 if (nums != null) { | |
1925 names = Object.getOwnPropertyNames(nums); | |
1926 entries = names.length; | |
1927 for (i = 0; i < entries; ++i) { | |
1928 result[index] = +names[i]; | |
1929 ++index; | |
1930 } | |
1931 } | |
1932 rest = this._rest; | |
1933 if (rest != null) { | |
1934 names = Object.getOwnPropertyNames(rest); | |
1935 entries = names.length; | |
1936 for (i = 0; i < entries; ++i) { | |
1937 bucket = rest[names[i]]; | |
1938 $length = bucket.length; | |
1939 for (i0 = 0; i0 < $length; ++i0) { | |
1940 result[index] = bucket[i0]; | |
1941 ++index; | |
1942 } | |
1943 } | |
1944 } | |
1945 this._elements = result; | |
1946 return result; | |
1947 }, | |
1948 _computeHashCode$1: function(element) { | |
1949 return J.get$hashCode$(element) & 0x3ffffff; | |
1950 }, | |
1951 _findBucketIndex$2: function(bucket, element) { | |
1952 var $length, i; | |
1953 if (bucket == null) | |
1954 return -1; | |
1955 $length = bucket.length; | |
1956 for (i = 0; i < $length; ++i) | |
1957 if (J.$eq(bucket[i], element)) | |
1958 return i; | |
1959 return -1; | |
1960 }, | |
1961 $as_HashSetBase: null, | |
1962 $isEfficientLength: true | |
1963 }, | |
1964 | |
1965 _IdentityHashSet: {"": "_HashSet;_collection$_length,_strings,_nums,_rest,_eleme
nts", | |
1966 _computeHashCode$1: function(key) { | |
1967 return H.objectHashCode(key) & 0x3ffffff; | |
1968 }, | |
1969 _findBucketIndex$2: function(bucket, element) { | |
1970 var $length, i; | |
1971 if (bucket == null) | |
1972 return -1; | |
1973 $length = bucket.length; | |
1974 for (i = 0; i < $length; ++i) | |
1975 if (bucket[i] === element) | |
1976 return i; | |
1977 return -1; | |
1978 }, | |
1979 $as_HashSet: null | |
1980 }, | |
1981 | |
1982 HashSetIterator: {"": "Object;_set,_elements,_offset,_collection$_current", | |
1983 get$current: function() { | |
1984 return this._collection$_current; | |
1985 }, | |
1986 moveNext$0: function() { | |
1987 var elements, offset, t1; | |
1988 elements = this._elements; | |
1989 offset = this._offset; | |
1990 t1 = this._set; | |
1991 if (elements !== t1._elements) | |
1992 throw H.wrapException(P.ConcurrentModificationError$(t1)); | |
1993 else if (offset >= elements.length) { | |
1994 this._collection$_current = null; | |
1995 return false; | |
1996 } else { | |
1997 this._collection$_current = elements[offset]; | |
1998 this._offset = offset + 1; | |
1999 return true; | |
2000 } | |
2001 } | |
2002 }, | |
2003 | |
2004 _HashSetBase: {"": "IterableBase;", | |
2005 toString$0: function(_) { | |
2006 return H.IterableMixinWorkaround_toStringIterable(this, "{", "}"); | |
2007 }, | |
2008 $asIterableBase: null, | |
2009 $isEfficientLength: true | |
2010 }, | |
2011 | |
2012 IterableBase: {"": "Object;", | |
2013 map$1: function(_, f) { | |
2014 return H.MappedIterable_MappedIterable(this, f, H.getRuntimeTypeArgument(thi
s, "IterableBase", 0), null); | |
2015 }, | |
2016 forEach$1: function(_, f) { | |
2017 var t1; | |
2018 for (t1 = this.get$iterator(this); t1.moveNext$0();) | |
2019 f.call$1(t1.get$current()); | |
2020 }, | |
2021 get$length: function(_) { | |
2022 var it, count; | |
2023 it = this.get$iterator(this); | |
2024 for (count = 0; it.moveNext$0();) | |
2025 ++count; | |
2026 return count; | |
2027 }, | |
2028 elementAt$1: function(_, index) { | |
2029 var t1, remaining, element; | |
2030 if (typeof index !== "number" || Math.floor(index) !== index || index < 0) | |
2031 throw H.wrapException(P.RangeError$value(index)); | |
2032 for (t1 = this.get$iterator(this), remaining = index; t1.moveNext$0();) { | |
2033 element = t1.get$current(); | |
2034 if (remaining === 0) | |
2035 return element; | |
2036 remaining = J.$sub$n(remaining, 1); | |
2037 } | |
2038 throw H.wrapException(P.RangeError$value(index)); | |
2039 }, | |
2040 toString$0: function(_) { | |
2041 return P._iterableToString(this); | |
2042 } | |
2043 }, | |
2044 | |
2045 ListBase: {"": "Object+ListMixin;", $isEfficientLength: true}, | |
2046 | |
2047 ListMixin: {"": "Object;", | |
2048 get$iterator: function(receiver) { | |
2049 return new H.ListIterator(receiver, this.get$length(receiver), 0, null); | |
2050 }, | |
2051 elementAt$1: function(receiver, index) { | |
2052 return this.$index(receiver, index); | |
2053 }, | |
2054 forEach$1: function(receiver, action) { | |
2055 var $length, i; | |
2056 $length = this.get$length(receiver); | |
2057 if (typeof $length !== "number") | |
2058 throw H.iae($length); | |
2059 i = 0; | |
2060 for (; i < $length; ++i) { | |
2061 action.call$1(this.$index(receiver, i)); | |
2062 if ($length !== this.get$length(receiver)) | |
2063 throw H.wrapException(P.ConcurrentModificationError$(receiver)); | |
2064 } | |
2065 }, | |
2066 map$1: function(receiver, f) { | |
2067 var t1 = new H.MappedListIterable(receiver, f); | |
2068 H.setRuntimeTypeInfo(t1, [null, null]); | |
2069 return t1; | |
2070 }, | |
2071 toList$1$growable: function(receiver, growable) { | |
2072 var result, i, t1; | |
2073 if (growable) { | |
2074 result = P.List_List(null, H.getRuntimeTypeArgument(receiver, "ListMixin",
0)); | |
2075 H.setRuntimeTypeInfo(result, [H.getRuntimeTypeArgument(receiver, "ListMixi
n", 0)]); | |
2076 C.JSArray_methods.set$length(result, this.get$length(receiver)); | |
2077 } else { | |
2078 result = P.List_List(this.get$length(receiver), H.getRuntimeTypeArgument(r
eceiver, "ListMixin", 0)); | |
2079 H.setRuntimeTypeInfo(result, [H.getRuntimeTypeArgument(receiver, "ListMixi
n", 0)]); | |
2080 } | |
2081 i = 0; | |
2082 while (true) { | |
2083 t1 = this.get$length(receiver); | |
2084 if (typeof t1 !== "number") | |
2085 throw H.iae(t1); | |
2086 if (!(i < t1)) | |
2087 break; | |
2088 t1 = this.$index(receiver, i); | |
2089 if (i >= result.length) | |
2090 throw H.ioore(result, i); | |
2091 result[i] = t1; | |
2092 ++i; | |
2093 } | |
2094 return result; | |
2095 }, | |
2096 toList$0: function($receiver) { | |
2097 return this.toList$1$growable($receiver, true); | |
2098 }, | |
2099 toString$0: function(receiver) { | |
2100 var result, t1; | |
2101 t1 = $.get$_toStringVisiting(); | |
2102 if (t1.contains$1(t1, receiver)) | |
2103 return "[...]"; | |
2104 result = P.StringBuffer$(""); | |
2105 try { | |
2106 t1 = $.get$_toStringVisiting(); | |
2107 t1.add$1(t1, receiver); | |
2108 result.write$1("["); | |
2109 result.writeAll$2(receiver, ", "); | |
2110 result.write$1("]"); | |
2111 } finally { | |
2112 t1 = $.get$_toStringVisiting(); | |
2113 t1.remove$1(t1, receiver); | |
2114 } | |
2115 return result.get$_contents(); | |
2116 }, | |
2117 $isEfficientLength: true | |
2118 }, | |
2119 | |
2120 Maps_mapToString_closure: {"": "Closure;box_0,result_1", | |
2121 call$2: function(k, v) { | |
2122 var t1 = this.box_0; | |
2123 if (!t1.first_0) | |
2124 this.result_1.write$1(", "); | |
2125 t1.first_0 = false; | |
2126 t1 = this.result_1; | |
2127 t1.write$1(k); | |
2128 t1.write$1(": "); | |
2129 t1.write$1(v); | |
2130 }, | |
2131 "+call:2:0": 0, | |
2132 $isFunction: true | |
2133 }}], | |
2134 ["dart.core", "dart:core", , P, { | |
2135 Function__toMangledNames: function(namedArguments) { | |
2136 return; | |
2137 }, | |
2138 | |
2139 Error_safeToString: function(object) { | |
2140 var buffer, t1, i, codeUnit, t2, charCodes; | |
2141 if (typeof object === "number" || typeof object === "boolean" || null == objec
t) | |
2142 return J.toString$0(object); | |
2143 if (typeof object === "string") { | |
2144 buffer = new P.StringBuffer(""); | |
2145 buffer._contents = "\""; | |
2146 for (t1 = object.length, i = 0; i < t1; ++i) { | |
2147 codeUnit = C.JSString_methods.codeUnitAt$1(object, i); | |
2148 if (codeUnit <= 31) | |
2149 if (codeUnit === 10) | |
2150 buffer._contents = buffer._contents + "\\n"; | |
2151 else if (codeUnit === 13) | |
2152 buffer._contents = buffer._contents + "\\r"; | |
2153 else if (codeUnit === 9) | |
2154 buffer._contents = buffer._contents + "\\t"; | |
2155 else { | |
2156 buffer._contents = buffer._contents + "\\x"; | |
2157 if (codeUnit < 16) | |
2158 buffer._contents = buffer._contents + "0"; | |
2159 else { | |
2160 buffer._contents = buffer._contents + "1"; | |
2161 codeUnit -= 16; | |
2162 } | |
2163 t2 = codeUnit < 10 ? 48 + codeUnit : 87 + codeUnit; | |
2164 charCodes = P.List_List$filled(1, t2, J.JSInt); | |
2165 charCodes.$builtinTypeInfo = [J.JSInt]; | |
2166 t2 = H.Primitives_stringFromCharCodes(charCodes); | |
2167 buffer._contents = buffer._contents + t2; | |
2168 } | |
2169 else if (codeUnit === 92) | |
2170 buffer._contents = buffer._contents + "\\\\"; | |
2171 else if (codeUnit === 34) | |
2172 buffer._contents = buffer._contents + "\\\""; | |
2173 else { | |
2174 charCodes = P.List_List$filled(1, codeUnit, J.JSInt); | |
2175 charCodes.$builtinTypeInfo = [J.JSInt]; | |
2176 t2 = H.Primitives_stringFromCharCodes(charCodes); | |
2177 buffer._contents = buffer._contents + t2; | |
2178 } | |
2179 } | |
2180 buffer._contents = buffer._contents + "\""; | |
2181 return buffer._contents; | |
2182 } | |
2183 return "Instance of '" + H.Primitives_objectTypeName(object) + "'"; | |
2184 }, | |
2185 | |
2186 Exception_Exception: function(message) { | |
2187 return new P._ExceptionImplementation(message); | |
2188 }, | |
2189 | |
2190 identical: function(a, b) { | |
2191 return a == null ? b == null : a === b; | |
2192 }, | |
2193 | |
2194 identityHashCode: function(object) { | |
2195 return H.objectHashCode(object); | |
2196 }, | |
2197 | |
2198 List_List: function($length, $E) { | |
2199 if ($length == null) | |
2200 return new Array(0); | |
2201 if (typeof $length !== "number" || Math.floor($length) !== $length || $length
< 0) | |
2202 throw H.wrapException(P.ArgumentError$("Length must be a positive integer: "
+ H.S($length) + ".")); | |
2203 return H.Primitives_newFixedList($length); | |
2204 }, | |
2205 | |
2206 List_List$filled: function($length, fill, $E) { | |
2207 var result, t1, i; | |
2208 if ($length < 0) | |
2209 throw H.wrapException(P.ArgumentError$("Length must be a positive integer: "
+ $length + ".")); | |
2210 result = H.Primitives_newFixedList($length); | |
2211 if ($length !== 0 && true) | |
2212 for (t1 = result.length, i = 0; i < t1; ++i) | |
2213 result[i] = fill; | |
2214 return result; | |
2215 }, | |
2216 | |
2217 List_List$from: function(other, growable, $E) { | |
2218 var list, t1, $length, fixedList, i; | |
2219 list = P.List_List(null, $E); | |
2220 H.setRuntimeTypeInfo(list, [$E]); | |
2221 for (t1 = J.get$iterator$ax(other); t1.moveNext$0();) | |
2222 list.push(t1.get$current()); | |
2223 if (growable) | |
2224 return list; | |
2225 $length = list.length; | |
2226 fixedList = P.List_List($length, $E); | |
2227 H.setRuntimeTypeInfo(fixedList, [$E]); | |
2228 for (t1 = list.length, i = 0; i < $length; ++i) { | |
2229 if (i >= t1) | |
2230 throw H.ioore(list, i); | |
2231 fixedList[i] = list[i]; | |
2232 } | |
2233 return fixedList; | |
2234 }, | |
2235 | |
2236 Function__toMangledNames_closure: {"": "Closure;result_0", | |
2237 call$2: function(symbol, value) { | |
2238 var t1 = this.result_0; | |
2239 t1.$indexSet(t1, symbol.get$_name(), value); | |
2240 }, | |
2241 "+call:2:0": 0, | |
2242 $isFunction: true | |
2243 }, | |
2244 | |
2245 NoSuchMethodError_toString_closure: {"": "Closure;box_0", | |
2246 call$2: function(key, value) { | |
2247 var t1 = this.box_0; | |
2248 if (t1.i_1 > 0) | |
2249 t1.sb_0.write$1(", "); | |
2250 t1.sb_0.write$1(key.get$_name()); | |
2251 t1.sb_0.write$1(": "); | |
2252 t1.sb_0.write$1(P.Error_safeToString(value)); | |
2253 t1.i_1 = t1.i_1 + 1; | |
2254 }, | |
2255 "+call:2:0": 0, | |
2256 $isFunction: true | |
2257 }, | |
2258 | |
2259 DateTime: {"": "Object;millisecondsSinceEpoch,isUtc", | |
2260 $eq: function(_, other) { | |
2261 var t1; | |
2262 if (other == null) | |
2263 return false; | |
2264 t1 = J.getInterceptor(other); | |
2265 if (typeof other !== "object" || other === null || !t1.$isDateTime) | |
2266 return false; | |
2267 return this.millisecondsSinceEpoch === other.millisecondsSinceEpoch && this.
isUtc === other.isUtc; | |
2268 }, | |
2269 get$hashCode: function(_) { | |
2270 return this.millisecondsSinceEpoch; | |
2271 }, | |
2272 toString$0: function(_) { | |
2273 var t1, y, m, d, h, min, sec, ms; | |
2274 t1 = new P.DateTime_toString_twoDigits(); | |
2275 y = new P.DateTime_toString_fourDigits().call$1(H.Primitives_getYear(this)); | |
2276 m = t1.call$1(H.Primitives_getMonth(this)); | |
2277 d = t1.call$1(H.Primitives_getDay(this)); | |
2278 h = t1.call$1(H.Primitives_getHours(this)); | |
2279 min = t1.call$1(H.Primitives_getMinutes(this)); | |
2280 sec = t1.call$1(H.Primitives_getSeconds(this)); | |
2281 ms = new P.DateTime_toString_threeDigits().call$1(H.Primitives_getMillisecon
ds(this)); | |
2282 if (this.isUtc) | |
2283 return H.S(y) + "-" + H.S(m) + "-" + H.S(d) + " " + H.S(h) + ":" + H.S(min
) + ":" + H.S(sec) + "." + H.S(ms) + "Z"; | |
2284 else | |
2285 return H.S(y) + "-" + H.S(m) + "-" + H.S(d) + " " + H.S(h) + ":" + H.S(min
) + ":" + H.S(sec) + "." + H.S(ms); | |
2286 }, | |
2287 DateTime$fromMillisecondsSinceEpoch$2$isUtc: function(millisecondsSinceEpoch,
isUtc) { | |
2288 if (Math.abs(millisecondsSinceEpoch) > 8640000000000000) | |
2289 throw H.wrapException(new P.ArgumentError(millisecondsSinceEpoch)); | |
2290 }, | |
2291 $isDateTime: true, | |
2292 static: { | |
2293 "": "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", | |
2294 DateTime$fromMillisecondsSinceEpoch: function(millisecondsSinceEpoch, isUtc) { | |
2295 var t1 = new P.DateTime(millisecondsSinceEpoch, isUtc); | |
2296 t1.DateTime$fromMillisecondsSinceEpoch$2$isUtc(millisecondsSinceEpoch, isUtc); | |
2297 return t1; | |
2298 }} | |
2299 | |
2300 }, | |
2301 | |
2302 DateTime_toString_fourDigits: {"": "Closure;", | |
2303 call$1: function(n) { | |
2304 var t1, absN, sign; | |
2305 t1 = J.getInterceptor$n(n); | |
2306 absN = t1.abs$0(n); | |
2307 sign = t1.$lt(n, 0) ? "-" : ""; | |
2308 if (absN >= 1000) | |
2309 return H.S(n); | |
2310 if (absN >= 100) | |
2311 return sign + "0" + H.S(absN); | |
2312 if (absN >= 10) | |
2313 return sign + "00" + H.S(absN); | |
2314 return sign + "000" + H.S(absN); | |
2315 }, | |
2316 "+call:1:0": 0, | |
2317 $isFunction: true | |
2318 }, | |
2319 | |
2320 DateTime_toString_threeDigits: {"": "Closure;", | |
2321 call$1: function(n) { | |
2322 var t1 = J.getInterceptor$n(n); | |
2323 if (t1.$ge(n, 100)) | |
2324 return H.S(n); | |
2325 if (t1.$ge(n, 10)) | |
2326 return "0" + H.S(n); | |
2327 return "00" + H.S(n); | |
2328 }, | |
2329 "+call:1:0": 0, | |
2330 $isFunction: true | |
2331 }, | |
2332 | |
2333 DateTime_toString_twoDigits: {"": "Closure;", | |
2334 call$1: function(n) { | |
2335 if (J.$ge$n(n, 10)) | |
2336 return H.S(n); | |
2337 return "0" + H.S(n); | |
2338 }, | |
2339 "+call:1:0": 0, | |
2340 $isFunction: true | |
2341 }, | |
2342 | |
2343 Error: {"": "Object;", $isError: true}, | |
2344 | |
2345 NullThrownError: {"": "Error;", | |
2346 toString$0: function(_) { | |
2347 return "Throw of null."; | |
2348 } | |
2349 }, | |
2350 | |
2351 ArgumentError: {"": "Error;message", | |
2352 toString$0: function(_) { | |
2353 var t1 = this.message; | |
2354 if (t1 != null) | |
2355 return "Illegal argument(s): " + H.S(t1); | |
2356 return "Illegal argument(s)"; | |
2357 }, | |
2358 static: { | |
2359 ArgumentError$: function(message) { | |
2360 return new P.ArgumentError(message); | |
2361 }} | |
2362 | |
2363 }, | |
2364 | |
2365 RangeError: {"": "ArgumentError;message", | |
2366 toString$0: function(_) { | |
2367 return "RangeError: " + H.S(this.message); | |
2368 }, | |
2369 static: { | |
2370 RangeError$value: function(value) { | |
2371 return new P.RangeError("value " + H.S(value)); | |
2372 }, | |
2373 | |
2374 RangeError$range: function(value, start, end) { | |
2375 return new P.RangeError("value " + H.S(value) + " not in range " + start + "..
" + H.S(end)); | |
2376 }} | |
2377 | |
2378 }, | |
2379 | |
2380 NoSuchMethodError: {"": "Error;_core$_receiver,_memberName,_core$_arguments,_nam
edArguments,_existingArgumentNames", | |
2381 toString$0: function(_) { | |
2382 var t1, t2, t3, t4, str; | |
2383 t1 = {}; | |
2384 t1.sb_0 = P.StringBuffer$(""); | |
2385 t1.i_1 = 0; | |
2386 for (t2 = this._core$_arguments; t3 = t1.i_1, t3 < t2.length; t1.i_1 = t1.i_
1 + 1) { | |
2387 if (t3 > 0) { | |
2388 t3 = t1.sb_0; | |
2389 t3._contents = t3._contents + ", "; | |
2390 } | |
2391 t3 = t1.sb_0; | |
2392 t4 = t1.i_1; | |
2393 if (t4 < 0 || t4 >= t2.length) | |
2394 throw H.ioore(t2, t4); | |
2395 str = P.Error_safeToString(t2[t4]); | |
2396 str = typeof str === "string" ? str : H.S(str); | |
2397 t3._contents = t3._contents + str; | |
2398 } | |
2399 t2 = this._namedArguments; | |
2400 t2.forEach$1(t2, new P.NoSuchMethodError_toString_closure(t1)); | |
2401 return "NoSuchMethodError : method not found: '" + H.S(this._memberName) + "
'\nReceiver: " + H.S(P.Error_safeToString(this._core$_receiver)) + "\nArguments:
[" + H.S(t1.sb_0) + "]"; | |
2402 }, | |
2403 static: { | |
2404 NoSuchMethodError$: function(receiver, memberName, positionalArguments, namedArg
uments, existingArgumentNames) { | |
2405 return new P.NoSuchMethodError(receiver, memberName, positionalArguments, name
dArguments, existingArgumentNames); | |
2406 }} | |
2407 | |
2408 }, | |
2409 | |
2410 UnsupportedError: {"": "Error;message", | |
2411 toString$0: function(_) { | |
2412 return "Unsupported operation: " + this.message; | |
2413 }, | |
2414 static: { | |
2415 UnsupportedError$: function(message) { | |
2416 return new P.UnsupportedError(message); | |
2417 }} | |
2418 | |
2419 }, | |
2420 | |
2421 UnimplementedError: {"": "Error;message", | |
2422 toString$0: function(_) { | |
2423 var t1 = this.message; | |
2424 return t1 != null ? "UnimplementedError: " + H.S(t1) : "UnimplementedError"; | |
2425 }, | |
2426 $isError: true, | |
2427 static: { | |
2428 UnimplementedError$: function(message) { | |
2429 return new P.UnimplementedError(message); | |
2430 }} | |
2431 | |
2432 }, | |
2433 | |
2434 ConcurrentModificationError: {"": "Error;modifiedObject", | |
2435 toString$0: function(_) { | |
2436 var t1 = this.modifiedObject; | |
2437 if (t1 == null) | |
2438 return "Concurrent modification during iteration."; | |
2439 return "Concurrent modification during iteration: " + H.S(P.Error_safeToStri
ng(t1)) + "."; | |
2440 }, | |
2441 static: { | |
2442 ConcurrentModificationError$: function(modifiedObject) { | |
2443 return new P.ConcurrentModificationError(modifiedObject); | |
2444 }} | |
2445 | |
2446 }, | |
2447 | |
2448 StackOverflowError: {"": "Object;", | |
2449 toString$0: function(_) { | |
2450 return "Stack Overflow"; | |
2451 }, | |
2452 $isError: true | |
2453 }, | |
2454 | |
2455 CyclicInitializationError: {"": "Error;variableName", | |
2456 toString$0: function(_) { | |
2457 return "Reading static variable '" + this.variableName + "' during its initi
alization"; | |
2458 }, | |
2459 static: { | |
2460 CyclicInitializationError$: function(variableName) { | |
2461 return new P.CyclicInitializationError(variableName); | |
2462 }} | |
2463 | |
2464 }, | |
2465 | |
2466 _ExceptionImplementation: {"": "Object;message", | |
2467 toString$0: function(_) { | |
2468 return "Exception: " + this.message; | |
2469 } | |
2470 }, | |
2471 | |
2472 Iterator: {"": "Object;"}, | |
2473 | |
2474 Null: {"": "Object;", | |
2475 toString$0: function(_) { | |
2476 return "null"; | |
2477 } | |
2478 }, | |
2479 | |
2480 Object: {"": ";", | |
2481 $eq: function(_, other) { | |
2482 return this === other; | |
2483 }, | |
2484 get$hashCode: function(_) { | |
2485 return H.Primitives_objectHashCode(this); | |
2486 }, | |
2487 toString$0: function(_) { | |
2488 return H.Primitives_objectToString(this); | |
2489 }, | |
2490 noSuchMethod$1: function(_, invocation) { | |
2491 throw H.wrapException(P.NoSuchMethodError$(this, invocation.get$memberName()
, invocation.get$positionalArguments(), invocation.get$namedArguments(), null)); | |
2492 } | |
2493 }, | |
2494 | |
2495 StringBuffer: {"": "Object;_contents<", | |
2496 get$length: function(_) { | |
2497 return this._contents.length; | |
2498 }, | |
2499 write$1: function(obj) { | |
2500 var str = typeof obj === "string" ? obj : H.S(obj); | |
2501 this._contents = this._contents + str; | |
2502 }, | |
2503 writeAll$2: function(objects, separator) { | |
2504 var iterator, str; | |
2505 iterator = J.get$iterator$ax(objects); | |
2506 if (!iterator.moveNext$0()) | |
2507 return; | |
2508 if (separator.length === 0) | |
2509 do { | |
2510 str = iterator.get$current(); | |
2511 str = typeof str === "string" ? str : H.S(str); | |
2512 this._contents = this._contents + str; | |
2513 } while (iterator.moveNext$0()); | |
2514 else { | |
2515 this.write$1(iterator.get$current()); | |
2516 for (; iterator.moveNext$0();) { | |
2517 this._contents = this._contents + separator; | |
2518 str = iterator.get$current(); | |
2519 str = typeof str === "string" ? str : H.S(str); | |
2520 this._contents = this._contents + str; | |
2521 } | |
2522 } | |
2523 }, | |
2524 toString$0: function(_) { | |
2525 return this._contents; | |
2526 }, | |
2527 StringBuffer$1: function($content) { | |
2528 this._contents = $content; | |
2529 }, | |
2530 static: { | |
2531 StringBuffer$: function($content) { | |
2532 var t1 = new P.StringBuffer(""); | |
2533 t1.StringBuffer$1($content); | |
2534 return t1; | |
2535 }} | |
2536 | |
2537 }, | |
2538 | |
2539 Symbol: {"": "Object;"}}], | |
2540 ["dart.dom.html", "dart:html", , W, { | |
2541 _ElementFactoryProvider_createElement_tag: function(tag, typeExtension) { | |
2542 return document.createElement(tag); | |
2543 }, | |
2544 | |
2545 HtmlElement: {"": "Element;", "%": "HTMLAppletElement|HTMLBRElement|HTMLBaseFont
Element|HTMLBodyElement|HTMLButtonElement|HTMLCanvasElement|HTMLContentElement|H
TMLDListElement|HTMLDataListElement|HTMLDetailsElement|HTMLDialogElement|HTMLDir
ectoryElement|HTMLDivElement|HTMLFieldSetElement|HTMLFontElement|HTMLFrameElemen
t|HTMLFrameSetElement|HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlE
lement|HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLMa
pElement|HTMLMarqueeElement|HTMLMenuElement|HTMLMetaElement|HTMLMeterElement|HTM
LModElement|HTMLOListElement|HTMLObjectElement|HTMLOptGroupElement|HTMLOptionEle
ment|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPreElement|HTML
ProgressElement|HTMLQuoteElement|HTMLShadowElement|HTMLSpanElement|HTMLStyleElem
ent|HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDa
taCellElement|HTMLTableElement|HTMLTableHeaderCellElement|HTMLTableRowElement|HT
MLTableSectionElement|HTMLTemplateElement|HTMLTextAreaElement|HTMLTitleElement|H
TMLUListElement|HTMLUnknownElement;HTMLElement"}, | |
2546 | |
2547 AnchorElement: {"": "HtmlElement;href}", | |
2548 toString$0: function(receiver) { | |
2549 return receiver.toString(); | |
2550 }, | |
2551 "%": "HTMLAnchorElement" | |
2552 }, | |
2553 | |
2554 AreaElement: {"": "HtmlElement;href}", "%": "HTMLAreaElement"}, | |
2555 | |
2556 BaseElement: {"": "HtmlElement;href}", "%": "HTMLBaseElement"}, | |
2557 | |
2558 Blob: {"": "Interceptor;", $isBlob: true, "%": "Blob|File"}, | |
2559 | |
2560 CharacterData: {"": "Node;length=", "%": "CDATASection|CharacterData|Comment|Pro
cessingInstruction|Text"}, | |
2561 | |
2562 DomException: {"": "Interceptor;", | |
2563 toString$0: function(receiver) { | |
2564 return receiver.toString(); | |
2565 }, | |
2566 "%": "DOMException" | |
2567 }, | |
2568 | |
2569 Element: {"": "Node;", | |
2570 toString$0: function(receiver) { | |
2571 return receiver.localName; | |
2572 }, | |
2573 "%": "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" | |
2574 }, | |
2575 | |
2576 EmbedElement: {"": "HtmlElement;src}", "%": "HTMLEmbedElement"}, | |
2577 | |
2578 Event: {"": "Interceptor;", $isEvent: true, "%": "AudioProcessingEvent|Autocompl
eteErrorEvent|BeforeLoadEvent|BeforeUnloadEvent|CSSFontFaceLoadEvent|CloseEvent|
CompositionEvent|CustomEvent|DeviceMotionEvent|DeviceOrientationEvent|DragEvent|
ErrorEvent|Event|FocusEvent|HashChangeEvent|IDBVersionChangeEvent|KeyboardEvent|
MIDIConnectionEvent|MIDIMessageEvent|MSPointerEvent|MediaKeyEvent|MediaKeyMessag
eEvent|MediaKeyNeededEvent|MediaStreamEvent|MediaStreamTrackEvent|MessageEvent|M
ouseEvent|MouseScrollEvent|MouseWheelEvent|MutationEvent|OfflineAudioCompletionE
vent|OverflowEvent|PageTransitionEvent|PointerEvent|PopStateEvent|ProgressEvent|
RTCDTMFToneChangeEvent|RTCDataChannelEvent|RTCIceCandidateEvent|ResourceProgress
Event|SVGZoomEvent|SecurityPolicyViolationEvent|SpeechInputEvent|SpeechRecogniti
onError|SpeechRecognitionEvent|SpeechSynthesisEvent|StorageEvent|TextEvent|Touch
Event|TrackEvent|TransitionEvent|UIEvent|WebGLContextEvent|WebKitAnimationEvent|
WebKitTransitionEvent|WheelEvent|XMLHttpRequestProgressEvent"}, | |
2579 | |
2580 EventTarget: {"": "Interceptor;", "%": ";EventTarget"}, | |
2581 | |
2582 FormElement: {"": "HtmlElement;length=", "%": "HTMLFormElement"}, | |
2583 | |
2584 HtmlCollection: {"": "Interceptor_ListMixin_ImmutableListMixin;", | |
2585 get$length: function(receiver) { | |
2586 return receiver.length; | |
2587 }, | |
2588 $index: function(receiver, index) { | |
2589 var t1 = receiver.length; | |
2590 if (index >>> 0 !== index || index >= t1) | |
2591 throw H.wrapException(P.RangeError$range(index, 0, t1)); | |
2592 return receiver[index]; | |
2593 }, | |
2594 $indexSet: function(receiver, index, value) { | |
2595 throw H.wrapException(P.UnsupportedError$("Cannot assign element of immutabl
e List.")); | |
2596 }, | |
2597 elementAt$1: function(receiver, index) { | |
2598 if (index >>> 0 !== index || index >= receiver.length) | |
2599 throw H.ioore(receiver, index); | |
2600 return receiver[index]; | |
2601 }, | |
2602 $isEfficientLength: true, | |
2603 $isJavaScriptIndexingBehavior: true, | |
2604 "%": "HTMLCollection|HTMLFormControlsCollection|HTMLOptionsCollection" | |
2605 }, | |
2606 | |
2607 IFrameElement: {"": "HtmlElement;src}", "%": "HTMLIFrameElement"}, | |
2608 | |
2609 ImageData: {"": "Interceptor;", $isImageData: true, "%": "ImageData"}, | |
2610 | |
2611 ImageElement: {"": "HtmlElement;src}", "%": "HTMLImageElement"}, | |
2612 | |
2613 InputElement: {"": "HtmlElement;src}", $isNode: true, "%": "HTMLInputElement"}, | |
2614 | |
2615 LinkElement: {"": "HtmlElement;href}", "%": "HTMLLinkElement"}, | |
2616 | |
2617 MediaElement: {"": "HtmlElement;src}", "%": "HTMLAudioElement|HTMLMediaElement|H
TMLVideoElement"}, | |
2618 | |
2619 Node: {"": "EventTarget;text:textContent}", | |
2620 toString$0: function(receiver) { | |
2621 var t1 = receiver.nodeValue; | |
2622 return t1 == null ? J.Interceptor.prototype.toString$0.call(this, receiver)
: t1; | |
2623 }, | |
2624 $isNode: true, | |
2625 "%": "Attr|Document|DocumentFragment|DocumentType|Entity|HTMLDocument|Notation
|SVGDocument|ShadowRoot;Node" | |
2626 }, | |
2627 | |
2628 NodeList: {"": "Interceptor_ListMixin_ImmutableListMixin0;", | |
2629 get$length: function(receiver) { | |
2630 return receiver.length; | |
2631 }, | |
2632 $index: function(receiver, index) { | |
2633 var t1 = receiver.length; | |
2634 if (index >>> 0 !== index || index >= t1) | |
2635 throw H.wrapException(P.RangeError$range(index, 0, t1)); | |
2636 return receiver[index]; | |
2637 }, | |
2638 $indexSet: function(receiver, index, value) { | |
2639 throw H.wrapException(P.UnsupportedError$("Cannot assign element of immutabl
e List.")); | |
2640 }, | |
2641 elementAt$1: function(receiver, index) { | |
2642 if (index >>> 0 !== index || index >= receiver.length) | |
2643 throw H.ioore(receiver, index); | |
2644 return receiver[index]; | |
2645 }, | |
2646 $isEfficientLength: true, | |
2647 $isJavaScriptIndexingBehavior: true, | |
2648 "%": "NodeList|RadioNodeList" | |
2649 }, | |
2650 | |
2651 ScriptElement: {"": "HtmlElement;src}", "%": "HTMLScriptElement"}, | |
2652 | |
2653 SelectElement: {"": "HtmlElement;length=", "%": "HTMLSelectElement"}, | |
2654 | |
2655 SourceElement: {"": "HtmlElement;src}", "%": "HTMLSourceElement"}, | |
2656 | |
2657 TrackElement: {"": "HtmlElement;src}", "%": "HTMLTrackElement"}, | |
2658 | |
2659 Window: {"": "EventTarget;", | |
2660 toString$0: function(receiver) { | |
2661 return receiver.toString(); | |
2662 }, | |
2663 $isWindow: true, | |
2664 "%": "DOMWindow|Window" | |
2665 }, | |
2666 | |
2667 _ChildrenElementList: {"": "ListBase;_element,_childElements", | |
2668 get$length: function(_) { | |
2669 return this._childElements.length; | |
2670 }, | |
2671 $index: function(_, index) { | |
2672 var t1 = this._childElements; | |
2673 if (index >>> 0 !== index || index >= t1.length) | |
2674 throw H.ioore(t1, index); | |
2675 return t1[index]; | |
2676 }, | |
2677 $indexSet: function(_, index, value) { | |
2678 var t1 = this._childElements; | |
2679 if (index >>> 0 !== index || index >= t1.length) | |
2680 throw H.ioore(t1, index); | |
2681 this._element.replaceChild(value, t1[index]); | |
2682 }, | |
2683 get$iterator: function(_) { | |
2684 var t1 = this.toList$0(this); | |
2685 return new H.ListIterator(t1, t1.length, 0, null); | |
2686 } | |
2687 }, | |
2688 | |
2689 Interceptor_ListMixin: {"": "Interceptor+ListMixin;", $isEfficientLength: true}, | |
2690 | |
2691 Interceptor_ListMixin_ImmutableListMixin: {"": "Interceptor_ListMixin+ImmutableL
istMixin;", $isEfficientLength: true}, | |
2692 | |
2693 Interceptor_ListMixin0: {"": "Interceptor+ListMixin;", $isEfficientLength: true}
, | |
2694 | |
2695 Interceptor_ListMixin_ImmutableListMixin0: {"": "Interceptor_ListMixin0+Immutabl
eListMixin;", $isEfficientLength: true}, | |
2696 | |
2697 ImmutableListMixin: {"": "Object;", | |
2698 get$iterator: function(receiver) { | |
2699 return W.FixedSizeListIterator$(receiver); | |
2700 }, | |
2701 $isEfficientLength: true | |
2702 }, | |
2703 | |
2704 FixedSizeListIterator: {"": "Object;_array,_html$_length,_position,_html$_curren
t", | |
2705 moveNext$0: function() { | |
2706 var nextPosition, t1; | |
2707 nextPosition = this._position + 1; | |
2708 t1 = this._html$_length; | |
2709 if (nextPosition < t1) { | |
2710 this._html$_current = J.$index$asx(this._array, nextPosition); | |
2711 this._position = nextPosition; | |
2712 return true; | |
2713 } | |
2714 this._html$_current = null; | |
2715 this._position = t1; | |
2716 return false; | |
2717 }, | |
2718 get$current: function() { | |
2719 return this._html$_current; | |
2720 }, | |
2721 static: { | |
2722 FixedSizeListIterator$: function(array) { | |
2723 return new W.FixedSizeListIterator(array, J.get$length$asx(array), -1, null); | |
2724 }} | |
2725 | |
2726 }}], | |
2727 ["dart.dom.indexed_db", "dart:indexed_db", , P, { | |
2728 KeyRange: {"": "Interceptor;", $isKeyRange: true, "%": "IDBKeyRange"}}], | |
2729 ["dart.js", "dart:js", , P, { | |
2730 _convertDartFunction: function(f, captureThis) { | |
2731 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); | |
2732 }, | |
2733 | |
2734 _callDartFunction: function(callback, captureThis, $self, $arguments) { | |
2735 var arguments0; | |
2736 if (captureThis === true) { | |
2737 arguments0 = [$self]; | |
2738 C.JSArray_methods.addAll$1(arguments0, $arguments); | |
2739 $arguments = arguments0; | |
2740 } | |
2741 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))); | |
2742 }, | |
2743 | |
2744 _defineProperty: function(o, $name, value) { | |
2745 var exception; | |
2746 if (Object.isExtensible(o)) | |
2747 try { | |
2748 Object.defineProperty(o, $name, { value: value}); | |
2749 return true; | |
2750 } catch (exception) { | |
2751 H.unwrapException(exception); | |
2752 } | |
2753 | |
2754 return false; | |
2755 }, | |
2756 | |
2757 _convertToJS: function(o) { | |
2758 var t1; | |
2759 if (o == null) | |
2760 return; | |
2761 else { | |
2762 if (typeof o !== "string") | |
2763 if (typeof o !== "number") | |
2764 if (typeof o !== "boolean") { | |
2765 t1 = J.getInterceptor(o); | |
2766 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; | |
2767 } else | |
2768 t1 = true; | |
2769 else | |
2770 t1 = true; | |
2771 else | |
2772 t1 = true; | |
2773 if (t1) | |
2774 return o; | |
2775 else { | |
2776 t1 = J.getInterceptor(o); | |
2777 if (typeof o === "object" && o !== null && !!t1.$isDateTime) | |
2778 return H.Primitives_lazyAsJsDate(o); | |
2779 else if (typeof o === "object" && o !== null && !!t1.$isJsObject) | |
2780 return o._jsObject; | |
2781 else if (typeof o === "object" && o !== null && !!t1.$isFunction) | |
2782 return P._getJsProxy(o, "$dart_jsFunction", new P._convertToJS_closure()
); | |
2783 else | |
2784 return P._getJsProxy(o, "_$dart_jsObject", new P._convertToJS_closure0()
); | |
2785 } | |
2786 } | |
2787 }, | |
2788 | |
2789 _getJsProxy: function(o, propertyName, createProxy) { | |
2790 var jsProxy = o[propertyName]; | |
2791 if (jsProxy == null) { | |
2792 jsProxy = createProxy.call$1(o); | |
2793 P._defineProperty(o, propertyName, jsProxy); | |
2794 } | |
2795 return jsProxy; | |
2796 }, | |
2797 | |
2798 _convertToDart: function(o) { | |
2799 var t1; | |
2800 if (o == null || typeof o == "string" || typeof o == "number" || typeof o == "
boolean") | |
2801 return o; | |
2802 else { | |
2803 if (o instanceof Object) { | |
2804 t1 = J.getInterceptor(o); | |
2805 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; | |
2806 } else | |
2807 t1 = false; | |
2808 if (t1) | |
2809 return o; | |
2810 else if (o instanceof Date) | |
2811 return P.DateTime$fromMillisecondsSinceEpoch(o.getMilliseconds(), false); | |
2812 else if (o.constructor === DartObject) | |
2813 return o.o; | |
2814 else | |
2815 return P._wrapToDart(o); | |
2816 } | |
2817 }, | |
2818 | |
2819 _wrapToDart: function(o) { | |
2820 if (typeof o == "function") | |
2821 return P._getDartProxy(o, "_$dart_dartClosure", new P._wrapToDart_closure())
; | |
2822 else if (o instanceof Array) | |
2823 return P._getDartProxy(o, "_$dart_dartObject", new P._wrapToDart_closure0())
; | |
2824 else | |
2825 return P._getDartProxy(o, "_$dart_dartObject", new P._wrapToDart_closure1())
; | |
2826 }, | |
2827 | |
2828 _getDartProxy: function(o, propertyName, createProxy) { | |
2829 var dartProxy = o[propertyName]; | |
2830 if (dartProxy == null) { | |
2831 dartProxy = createProxy.call$1(o); | |
2832 P._defineProperty(o, propertyName, dartProxy); | |
2833 } | |
2834 return dartProxy; | |
2835 }, | |
2836 | |
2837 JsObject: {"": "Object;_jsObject", | |
2838 $index: function(_, property) { | |
2839 if (typeof property !== "string" && typeof property !== "number") | |
2840 throw H.wrapException(new P.ArgumentError("property is not a String or num
")); | |
2841 return P._convertToDart(this._jsObject[property]); | |
2842 }, | |
2843 $indexSet: function(_, property, value) { | |
2844 if (typeof property !== "string" && typeof property !== "number") | |
2845 throw H.wrapException(new P.ArgumentError("property is not a String or num
")); | |
2846 this._jsObject[property] = P._convertToJS(value); | |
2847 }, | |
2848 get$hashCode: function(_) { | |
2849 return 0; | |
2850 }, | |
2851 $eq: function(_, other) { | |
2852 var t1; | |
2853 if (other == null) | |
2854 return false; | |
2855 t1 = J.getInterceptor(other); | |
2856 return typeof other === "object" && other !== null && !!t1.$isJsObject && th
is._jsObject === other._jsObject; | |
2857 }, | |
2858 toString$0: function(_) { | |
2859 var t1, exception; | |
2860 try { | |
2861 t1 = String(this._jsObject); | |
2862 return t1; | |
2863 } catch (exception) { | |
2864 H.unwrapException(exception); | |
2865 return P.Object.prototype.toString$0.call(this, this); | |
2866 } | |
2867 | |
2868 }, | |
2869 $isJsObject: true | |
2870 }, | |
2871 | |
2872 JsFunction: {"": "JsObject;_jsObject"}, | |
2873 | |
2874 JsArray: {"": "JsObject_ListMixin;_jsObject", | |
2875 $index: function(_, index) { | |
2876 var t1; | |
2877 if (typeof index === "number" && index === C.JSNumber_methods.toInt$0(index)
) { | |
2878 if (typeof index === "number" && Math.floor(index) === index) | |
2879 if (!(index < 0)) { | |
2880 t1 = P.JsObject.prototype.$index.call(this, this, "length"); | |
2881 if (typeof t1 !== "number") | |
2882 throw H.iae(t1); | |
2883 t1 = index >= t1; | |
2884 } else | |
2885 t1 = true; | |
2886 else | |
2887 t1 = false; | |
2888 if (t1) | |
2889 H.throwExpression(P.RangeError$range(index, 0, P.JsObject.prototype.$ind
ex.call(this, this, "length"))); | |
2890 } | |
2891 return P.JsObject.prototype.$index.call(this, this, index); | |
2892 }, | |
2893 $indexSet: function(_, index, value) { | |
2894 var t1; | |
2895 if (typeof index === "number" && index === C.JSNumber_methods.toInt$0(index)
) { | |
2896 if (typeof index === "number" && Math.floor(index) === index) | |
2897 if (!(index < 0)) { | |
2898 t1 = P.JsObject.prototype.$index.call(this, this, "length"); | |
2899 if (typeof t1 !== "number") | |
2900 throw H.iae(t1); | |
2901 t1 = index >= t1; | |
2902 } else | |
2903 t1 = true; | |
2904 else | |
2905 t1 = false; | |
2906 if (t1) | |
2907 H.throwExpression(P.RangeError$range(index, 0, P.JsObject.prototype.$ind
ex.call(this, this, "length"))); | |
2908 } | |
2909 P.JsObject.prototype.$indexSet.call(this, this, index, value); | |
2910 }, | |
2911 get$length: function(_) { | |
2912 return P.JsObject.prototype.$index.call(this, this, "length"); | |
2913 } | |
2914 }, | |
2915 | |
2916 JsObject_ListMixin: {"": "JsObject+ListMixin;", $isEfficientLength: true}, | |
2917 | |
2918 _convertToJS_closure: {"": "Closure;", | |
2919 call$1: function(o) { | |
2920 var jsFunction = P._convertDartFunction(o, false); | |
2921 P._defineProperty(jsFunction, "_$dart_dartClosure", o); | |
2922 return jsFunction; | |
2923 }, | |
2924 "+call:1:0": 0, | |
2925 $isFunction: true | |
2926 }, | |
2927 | |
2928 _convertToJS_closure0: {"": "Closure;", | |
2929 call$1: function(o) { | |
2930 return new DartObject(o); | |
2931 }, | |
2932 "+call:1:0": 0, | |
2933 $isFunction: true | |
2934 }, | |
2935 | |
2936 _wrapToDart_closure: {"": "Closure;", | |
2937 call$1: function(o) { | |
2938 return new P.JsFunction(o); | |
2939 }, | |
2940 "+call:1:0": 0, | |
2941 $isFunction: true | |
2942 }, | |
2943 | |
2944 _wrapToDart_closure0: {"": "Closure;", | |
2945 call$1: function(o) { | |
2946 var t1 = new P.JsArray(o); | |
2947 H.setRuntimeTypeInfo(t1, [null]); | |
2948 return t1; | |
2949 }, | |
2950 "+call:1:0": 0, | |
2951 $isFunction: true | |
2952 }, | |
2953 | |
2954 _wrapToDart_closure1: {"": "Closure;", | |
2955 call$1: function(o) { | |
2956 return new P.JsObject(o); | |
2957 }, | |
2958 "+call:1:0": 0, | |
2959 $isFunction: true | |
2960 }}], | |
2961 ["dart.typed_data", "dart:typed_data", , P, { | |
2962 TypedData: {"": "Interceptor;", | |
2963 _invalidIndex$2: function(receiver, index, $length) { | |
2964 var t1 = J.getInterceptor$n(index); | |
2965 if (t1.$lt(index, 0) || t1.$ge(index, $length)) | |
2966 throw H.wrapException(P.RangeError$range(index, 0, $length)); | |
2967 else | |
2968 throw H.wrapException(P.ArgumentError$("Invalid list index " + H.S(index))
); | |
2969 }, | |
2970 $isTypedData: true, | |
2971 "%": "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" | |
2972 }, | |
2973 | |
2974 Float32List: {"": "TypedData_ListMixin_FixedLengthListMixin;", | |
2975 get$length: function(receiver) { | |
2976 return C.JS_CONST_ZYJ(receiver); | |
2977 }, | |
2978 $index: function(receiver, index) { | |
2979 var t1 = C.JS_CONST_ZYJ(receiver); | |
2980 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
2981 this._invalidIndex$2(receiver, index, t1); | |
2982 return receiver[index]; | |
2983 }, | |
2984 $indexSet: function(receiver, index, value) { | |
2985 var t1 = C.JS_CONST_ZYJ(receiver); | |
2986 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
2987 this._invalidIndex$2(receiver, index, t1); | |
2988 receiver[index] = value; | |
2989 }, | |
2990 $isEfficientLength: true, | |
2991 $isJavaScriptIndexingBehavior: true, | |
2992 "%": "Float32Array" | |
2993 }, | |
2994 | |
2995 Float64List: {"": "TypedData_ListMixin_FixedLengthListMixin0;", | |
2996 get$length: function(receiver) { | |
2997 return C.JS_CONST_ZYJ(receiver); | |
2998 }, | |
2999 $index: function(receiver, index) { | |
3000 var t1 = C.JS_CONST_ZYJ(receiver); | |
3001 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3002 this._invalidIndex$2(receiver, index, t1); | |
3003 return receiver[index]; | |
3004 }, | |
3005 $indexSet: function(receiver, index, value) { | |
3006 var t1 = C.JS_CONST_ZYJ(receiver); | |
3007 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3008 this._invalidIndex$2(receiver, index, t1); | |
3009 receiver[index] = value; | |
3010 }, | |
3011 $isEfficientLength: true, | |
3012 $isJavaScriptIndexingBehavior: true, | |
3013 "%": "Float64Array" | |
3014 }, | |
3015 | |
3016 Int16List: {"": "TypedData_ListMixin_FixedLengthListMixin1;", | |
3017 get$length: function(receiver) { | |
3018 return C.JS_CONST_ZYJ(receiver); | |
3019 }, | |
3020 $index: function(receiver, index) { | |
3021 var t1 = C.JS_CONST_ZYJ(receiver); | |
3022 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3023 this._invalidIndex$2(receiver, index, t1); | |
3024 return receiver[index]; | |
3025 }, | |
3026 $indexSet: function(receiver, index, value) { | |
3027 var t1 = C.JS_CONST_ZYJ(receiver); | |
3028 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3029 this._invalidIndex$2(receiver, index, t1); | |
3030 receiver[index] = value; | |
3031 }, | |
3032 $isEfficientLength: true, | |
3033 $isJavaScriptIndexingBehavior: true, | |
3034 "%": "Int16Array" | |
3035 }, | |
3036 | |
3037 Int32List: {"": "TypedData_ListMixin_FixedLengthListMixin2;", | |
3038 get$length: function(receiver) { | |
3039 return C.JS_CONST_ZYJ(receiver); | |
3040 }, | |
3041 $index: function(receiver, index) { | |
3042 var t1 = C.JS_CONST_ZYJ(receiver); | |
3043 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3044 this._invalidIndex$2(receiver, index, t1); | |
3045 return receiver[index]; | |
3046 }, | |
3047 $indexSet: function(receiver, index, value) { | |
3048 var t1 = C.JS_CONST_ZYJ(receiver); | |
3049 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3050 this._invalidIndex$2(receiver, index, t1); | |
3051 receiver[index] = value; | |
3052 }, | |
3053 $isEfficientLength: true, | |
3054 $isJavaScriptIndexingBehavior: true, | |
3055 "%": "Int32Array" | |
3056 }, | |
3057 | |
3058 Int8List: {"": "TypedData_ListMixin_FixedLengthListMixin3;", | |
3059 get$length: function(receiver) { | |
3060 return C.JS_CONST_ZYJ(receiver); | |
3061 }, | |
3062 $index: function(receiver, index) { | |
3063 var t1 = C.JS_CONST_ZYJ(receiver); | |
3064 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3065 this._invalidIndex$2(receiver, index, t1); | |
3066 return receiver[index]; | |
3067 }, | |
3068 $indexSet: function(receiver, index, value) { | |
3069 var t1 = C.JS_CONST_ZYJ(receiver); | |
3070 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3071 this._invalidIndex$2(receiver, index, t1); | |
3072 receiver[index] = value; | |
3073 }, | |
3074 $isEfficientLength: true, | |
3075 $isJavaScriptIndexingBehavior: true, | |
3076 "%": "Int8Array" | |
3077 }, | |
3078 | |
3079 Uint16List: {"": "TypedData_ListMixin_FixedLengthListMixin4;", | |
3080 get$length: function(receiver) { | |
3081 return C.JS_CONST_ZYJ(receiver); | |
3082 }, | |
3083 $index: function(receiver, index) { | |
3084 var t1 = C.JS_CONST_ZYJ(receiver); | |
3085 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3086 this._invalidIndex$2(receiver, index, t1); | |
3087 return receiver[index]; | |
3088 }, | |
3089 $indexSet: function(receiver, index, value) { | |
3090 var t1 = C.JS_CONST_ZYJ(receiver); | |
3091 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3092 this._invalidIndex$2(receiver, index, t1); | |
3093 receiver[index] = value; | |
3094 }, | |
3095 $isEfficientLength: true, | |
3096 $isJavaScriptIndexingBehavior: true, | |
3097 "%": "Uint16Array" | |
3098 }, | |
3099 | |
3100 Uint32List: {"": "TypedData_ListMixin_FixedLengthListMixin5;", | |
3101 get$length: function(receiver) { | |
3102 return C.JS_CONST_ZYJ(receiver); | |
3103 }, | |
3104 $index: function(receiver, index) { | |
3105 var t1 = C.JS_CONST_ZYJ(receiver); | |
3106 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3107 this._invalidIndex$2(receiver, index, t1); | |
3108 return receiver[index]; | |
3109 }, | |
3110 $indexSet: function(receiver, index, value) { | |
3111 var t1 = C.JS_CONST_ZYJ(receiver); | |
3112 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3113 this._invalidIndex$2(receiver, index, t1); | |
3114 receiver[index] = value; | |
3115 }, | |
3116 $isEfficientLength: true, | |
3117 $isJavaScriptIndexingBehavior: true, | |
3118 "%": "Uint32Array" | |
3119 }, | |
3120 | |
3121 Uint8ClampedList: {"": "TypedData_ListMixin_FixedLengthListMixin6;", | |
3122 get$length: function(receiver) { | |
3123 return C.JS_CONST_ZYJ(receiver); | |
3124 }, | |
3125 $index: function(receiver, index) { | |
3126 var t1 = C.JS_CONST_ZYJ(receiver); | |
3127 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3128 this._invalidIndex$2(receiver, index, t1); | |
3129 return receiver[index]; | |
3130 }, | |
3131 $indexSet: function(receiver, index, value) { | |
3132 var t1 = C.JS_CONST_ZYJ(receiver); | |
3133 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3134 this._invalidIndex$2(receiver, index, t1); | |
3135 receiver[index] = value; | |
3136 }, | |
3137 $isEfficientLength: true, | |
3138 $isJavaScriptIndexingBehavior: true, | |
3139 "%": "CanvasPixelArray|Uint8ClampedArray" | |
3140 }, | |
3141 | |
3142 Uint8List: {"": "TypedData_ListMixin_FixedLengthListMixin7;", | |
3143 get$length: function(receiver) { | |
3144 return C.JS_CONST_ZYJ(receiver); | |
3145 }, | |
3146 $index: function(receiver, index) { | |
3147 var t1 = C.JS_CONST_ZYJ(receiver); | |
3148 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3149 this._invalidIndex$2(receiver, index, t1); | |
3150 return receiver[index]; | |
3151 }, | |
3152 $indexSet: function(receiver, index, value) { | |
3153 var t1 = C.JS_CONST_ZYJ(receiver); | |
3154 if (index >>> 0 != index || J.$ge$n(index, t1)) | |
3155 this._invalidIndex$2(receiver, index, t1); | |
3156 receiver[index] = value; | |
3157 }, | |
3158 $isEfficientLength: true, | |
3159 $isJavaScriptIndexingBehavior: true, | |
3160 "%": ";Uint8Array" | |
3161 }, | |
3162 | |
3163 TypedData_ListMixin: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3164 | |
3165 TypedData_ListMixin_FixedLengthListMixin: {"": "TypedData_ListMixin+FixedLengthL
istMixin;"}, | |
3166 | |
3167 TypedData_ListMixin0: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3168 | |
3169 TypedData_ListMixin_FixedLengthListMixin0: {"": "TypedData_ListMixin0+FixedLengt
hListMixin;"}, | |
3170 | |
3171 TypedData_ListMixin1: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3172 | |
3173 TypedData_ListMixin_FixedLengthListMixin1: {"": "TypedData_ListMixin1+FixedLengt
hListMixin;"}, | |
3174 | |
3175 TypedData_ListMixin2: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3176 | |
3177 TypedData_ListMixin_FixedLengthListMixin2: {"": "TypedData_ListMixin2+FixedLengt
hListMixin;"}, | |
3178 | |
3179 TypedData_ListMixin3: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3180 | |
3181 TypedData_ListMixin_FixedLengthListMixin3: {"": "TypedData_ListMixin3+FixedLengt
hListMixin;"}, | |
3182 | |
3183 TypedData_ListMixin4: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3184 | |
3185 TypedData_ListMixin_FixedLengthListMixin4: {"": "TypedData_ListMixin4+FixedLengt
hListMixin;"}, | |
3186 | |
3187 TypedData_ListMixin5: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3188 | |
3189 TypedData_ListMixin_FixedLengthListMixin5: {"": "TypedData_ListMixin5+FixedLengt
hListMixin;"}, | |
3190 | |
3191 TypedData_ListMixin6: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3192 | |
3193 TypedData_ListMixin_FixedLengthListMixin6: {"": "TypedData_ListMixin6+FixedLengt
hListMixin;"}, | |
3194 | |
3195 TypedData_ListMixin7: {"": "TypedData+ListMixin;", $isEfficientLength: true}, | |
3196 | |
3197 TypedData_ListMixin_FixedLengthListMixin7: {"": "TypedData_ListMixin7+FixedLengt
hListMixin;"}, | |
3198 | |
3199 Int64List: {"": "TypedData;", $isEfficientLength: true, $isJavaScriptIndexingBeh
avior: true, static: { | |
3200 "": "Int64List_BYTES_PER_ELEMENT", | |
3201 } | |
3202 }, | |
3203 | |
3204 Uint64List: {"": "TypedData;", $isEfficientLength: true, $isJavaScriptIndexingBe
havior: true, static: { | |
3205 "": "Uint64List_BYTES_PER_ELEMENT", | |
3206 } | |
3207 }}], | |
3208 ["jsonp_sample", "index.dart", , R, { | |
3209 addTableHeadRow: function() { | |
3210 var tr, t1, field, t2; | |
3211 tr = document.createElement("tr", null); | |
3212 for (t1 = new H.ListIterator(C.List_8nO, 5, 0, null); t1.moveNext$0();) { | |
3213 field = t1._current; | |
3214 t2 = W._ElementFactoryProvider_createElement_tag("th", null); | |
3215 J.set$text$x(t2, field); | |
3216 tr.appendChild(t2); | |
3217 } | |
3218 $.get$table().querySelector("thead").appendChild(tr); | |
3219 }, | |
3220 | |
3221 addTableBodyRow: function(repo) { | |
3222 var tr, t1, t2, field, td, e; | |
3223 tr = document.createElement("tr", null); | |
3224 for (t1 = new H.ListIterator(C.List_8nO, 5, 0, null), t2 = J.getInterceptor$as
x(repo); t1.moveNext$0();) { | |
3225 field = t1._current; | |
3226 td = document.createElement("td", null); | |
3227 if (J.$eq(field, "name")) { | |
3228 e = document.createElement("a", null); | |
3229 J.set$href$x(e, t2.$index(repo, "html_url")); | |
3230 e.textContent = t2.$index(repo, field); | |
3231 td.appendChild(e); | |
3232 } else | |
3233 td.textContent = J.toString$0(t2.$index(repo, field)); | |
3234 tr.appendChild(td); | |
3235 } | |
3236 $.get$table().querySelector("tbody").appendChild(tr); | |
3237 }, | |
3238 | |
3239 main: function() { | |
3240 var script, t1; | |
3241 J.$indexSet$ax($.get$context(), "processData", new R.main_closure()); | |
3242 script = W._ElementFactoryProvider_createElement_tag("script", null); | |
3243 J.set$src$x(script, "https://api.github.com/users/dart-lang/repos?callback=pro
cessData"); | |
3244 t1 = document.body; | |
3245 new W._ChildrenElementList(t1, t1.children)._element.appendChild(script); | |
3246 }, | |
3247 | |
3248 main_closure: {"": "Closure;", | |
3249 call$1: function(response) { | |
3250 var t1; | |
3251 R.addTableHeadRow(); | |
3252 for (t1 = J.get$iterator$ax(J.$index$asx(response, "data")); t1.moveNext$0()
;) | |
3253 R.addTableBodyRow(t1.get$current()); | |
3254 }, | |
3255 "+call:1:0": 0, | |
3256 $isFunction: true | |
3257 }}, | |
3258 1], | |
3259 ]); | |
3260 Isolate.$finishClasses($$, $, null); | |
3261 $$ = null; | |
3262 | |
3263 // Static function getters | |
3264 init.globalFunctions.toStringWrapper$closure = H.toStringWrapper$closure = new H
.Closure$0(H.toStringWrapper, "toStringWrapper$closure"); | |
3265 init.globalFunctions.invokeClosure$closure = H.invokeClosure$closure = new H.Clo
sure$7(H.invokeClosure, "invokeClosure$closure"); | |
3266 init.globalFunctions._defaultEquals$closure = P._defaultEquals$closure = new P.C
losure$2(P._defaultEquals, "_defaultEquals$closure"); | |
3267 init.globalFunctions._defaultHashCode$closure = P._defaultHashCode$closure = new
P.Closure$1(P._defaultHashCode, "_defaultHashCode$closure"); | |
3268 init.globalFunctions.identical$closure = P.identical$closure = new P.Closure$2(P
.identical, "identical$closure"); | |
3269 init.globalFunctions.identityHashCode$closure = P.identityHashCode$closure = new
P.Closure$1(P.identityHashCode, "identityHashCode$closure"); | |
3270 init.globalFunctions._callDartFunction$closure = P._callDartFunction$closure = n
ew P.Closure$4(P._callDartFunction, "_callDartFunction$closure"); | |
3271 init.globalFunctions._convertToDart$closure = P._convertToDart$closure = new P.C
losure$1(P._convertToDart, "_convertToDart$closure"); | |
3272 // Runtime type support | |
3273 // getInterceptor methods | |
3274 J.getInterceptor = function(receiver) { | |
3275 if (typeof receiver == "number") { | |
3276 if (Math.floor(receiver) == receiver) | |
3277 return J.JSInt.prototype; | |
3278 return J.JSDouble.prototype; | |
3279 } | |
3280 if (typeof receiver == "string") | |
3281 return J.JSString.prototype; | |
3282 if (receiver == null) | |
3283 return J.JSNull.prototype; | |
3284 if (typeof receiver == "boolean") | |
3285 return J.JSBool.prototype; | |
3286 if (receiver.constructor == Array) | |
3287 return J.JSArray.prototype; | |
3288 if (typeof receiver != "object") | |
3289 return receiver; | |
3290 if (receiver instanceof P.Object) | |
3291 return receiver; | |
3292 return J.getNativeInterceptor(receiver); | |
3293 }; | |
3294 J.getInterceptor$asx = function(receiver) { | |
3295 if (typeof receiver == "string") | |
3296 return J.JSString.prototype; | |
3297 if (receiver == null) | |
3298 return receiver; | |
3299 if (receiver.constructor == Array) | |
3300 return J.JSArray.prototype; | |
3301 if (typeof receiver != "object") | |
3302 return receiver; | |
3303 if (receiver instanceof P.Object) | |
3304 return receiver; | |
3305 return J.getNativeInterceptor(receiver); | |
3306 }; | |
3307 J.getInterceptor$ax = function(receiver) { | |
3308 if (receiver == null) | |
3309 return receiver; | |
3310 if (receiver.constructor == Array) | |
3311 return J.JSArray.prototype; | |
3312 if (typeof receiver != "object") | |
3313 return receiver; | |
3314 if (receiver instanceof P.Object) | |
3315 return receiver; | |
3316 return J.getNativeInterceptor(receiver); | |
3317 }; | |
3318 J.getInterceptor$n = function(receiver) { | |
3319 if (typeof receiver == "number") | |
3320 return J.JSNumber.prototype; | |
3321 if (receiver == null) | |
3322 return receiver; | |
3323 if (!(receiver instanceof P.Object)) | |
3324 return J.UnknownJavaScriptObject.prototype; | |
3325 return receiver; | |
3326 }; | |
3327 J.getInterceptor$s = function(receiver) { | |
3328 if (typeof receiver == "string") | |
3329 return J.JSString.prototype; | |
3330 if (receiver == null) | |
3331 return receiver; | |
3332 if (!(receiver instanceof P.Object)) | |
3333 return J.UnknownJavaScriptObject.prototype; | |
3334 return receiver; | |
3335 }; | |
3336 J.getInterceptor$x = function(receiver) { | |
3337 if (receiver == null) | |
3338 return receiver; | |
3339 if (typeof receiver != "object") | |
3340 return receiver; | |
3341 if (receiver instanceof P.Object) | |
3342 return receiver; | |
3343 return J.getNativeInterceptor(receiver); | |
3344 }; | |
3345 C.JSArray_methods = J.JSArray.prototype; | |
3346 C.JSInt_methods = J.JSInt.prototype; | |
3347 C.JSNumber_methods = J.JSNumber.prototype; | |
3348 C.JSString_methods = J.JSString.prototype; | |
3349 C.JS_CONST_0 = function(hooks) { | |
3350 if (typeof dartExperimentalFixupGetTag != "function") return hooks; | |
3351 hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag); | |
3352 }; | |
3353 C.JS_CONST_6qb = function(hooks) { | |
3354 var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
3355 if (userAgent.indexOf("Firefox") == -1) return hooks; | |
3356 var getTag = hooks.getTag; | |
3357 var quickMap = { | |
3358 "BeforeUnloadEvent": "Event", | |
3359 "DataTransfer": "Clipboard", | |
3360 "GeoGeolocation": "Geolocation", | |
3361 "WorkerMessageEvent": "MessageEvent", | |
3362 "XMLDocument": "Document"}; | |
3363 function getTagFirefox(o) { | |
3364 var tag = getTag(o); | |
3365 return quickMap[tag] || tag; | |
3366 } | |
3367 hooks.getTag = getTagFirefox; | |
3368 }; | |
3369 C.JS_CONST_86y = function getTagFallback(o) { | |
3370 if (o == null) return "Null"; | |
3371 var constructor = o.constructor; | |
3372 if (typeof constructor == "function") { | |
3373 var name = constructor.builtin$cls; | |
3374 if (typeof name == "string") return name; | |
3375 name = constructor.name; | |
3376 if (typeof name == "string" | |
3377 && name !== "" | |
3378 && name !== "Object" | |
3379 && name !== "Function.prototype") { | |
3380 return name; | |
3381 } | |
3382 } | |
3383 var s = Object.prototype.toString.call(o); | |
3384 return s.substring(8, s.length - 1); | |
3385 }; | |
3386 C.JS_CONST_Cbr = function(getTagFallback) { | |
3387 return function(hooks) { | |
3388 if (typeof navigator != "object") return hooks; | |
3389 var userAgent = navigator.userAgent; | |
3390 if (userAgent.indexOf("Chrome") >= 0 || | |
3391 userAgent.indexOf("DumpRenderTree") >= 0) { | |
3392 return hooks; | |
3393 } | |
3394 hooks.getTag = getTagFallback; | |
3395 }; | |
3396 }; | |
3397 C.JS_CONST_Fs4 = function(hooks) { return hooks; } | |
3398 ; | |
3399 C.JS_CONST_TtD = function() { | |
3400 function typeNameInChrome(obj) { return obj.constructor.name; } | |
3401 function getUnknownTag(object, tag) { | |
3402 if (/^HTML[A-Z].*Element$/.test(tag)) { | |
3403 var name = Object.prototype.toString.call(object); | |
3404 if (name == "[object Object]") return null; | |
3405 return "HTMLElement"; | |
3406 } | |
3407 } | |
3408 function getUnknownTagGenericBrowser(object, tag) { | |
3409 if (object instanceof HTMLElement) return "HTMLElement"; | |
3410 return getUnknownTag(object, tag); | |
3411 } | |
3412 function prototypeForTag(tag) { | |
3413 if (typeof window == "undefined") return null; | |
3414 if (typeof window[tag] == "undefined") return null; | |
3415 var constructor = window[tag]; | |
3416 if (typeof constructor != "function") return null; | |
3417 return constructor.prototype; | |
3418 } | |
3419 function discriminator(tag) { return null; } | |
3420 var isBrowser = typeof navigator == "object"; | |
3421 return { | |
3422 getTag: typeNameInChrome, | |
3423 getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag, | |
3424 prototypeForTag: prototypeForTag, | |
3425 discriminator: discriminator }; | |
3426 }; | |
3427 C.JS_CONST_ZYJ = ((typeof version == "function" && typeof os == "object" &&
"system" in os) | |
3428 || (typeof navigator == "object" | |
3429 && navigator.userAgent.indexOf('Chrome') != -1)) | |
3430 ? function(x) { return x.$dartCachedLength || x.length; } | |
3431 : function(x) { return x.length; }; | |
3432 ; | |
3433 C.JS_CONST_rD3 = function(hooks) { | |
3434 var userAgent = typeof navigator == "object" ? navigator.userAgent : ""; | |
3435 if (userAgent.indexOf("Trident/") == -1) return hooks; | |
3436 var getTag = hooks.getTag; | |
3437 var quickMap = { | |
3438 "BeforeUnloadEvent": "Event", | |
3439 "DataTransfer": "Clipboard", | |
3440 "HTMLDDElement": "HTMLElement", | |
3441 "HTMLDTElement": "HTMLElement", | |
3442 "HTMLPhraseElement": "HTMLElement", | |
3443 "Position": "Geoposition" | |
3444 }; | |
3445 function getTagIE(o) { | |
3446 var tag = getTag(o); | |
3447 var newTag = quickMap[tag]; | |
3448 if (newTag) return newTag; | |
3449 if (tag == "Document") { | |
3450 if (!!o.xmlVersion) return "!Document"; | |
3451 return "!HTMLDocument"; | |
3452 } | |
3453 if (tag == "Object") { | |
3454 if (window.DataView && (o instanceof window.DataView)) return "DataView"; | |
3455 } | |
3456 return tag; | |
3457 } | |
3458 function prototypeForTagIE(tag) { | |
3459 if (tag == "Document") return null; | |
3460 var constructor = window[tag]; | |
3461 if (constructor == null) return null; | |
3462 return constructor.prototype; | |
3463 } | |
3464 hooks.getTag = getTagIE; | |
3465 hooks.prototypeForTag = prototypeForTagIE; | |
3466 }; | |
3467 Isolate.makeConstantList = function(list) { | |
3468 list.immutable$list = true; | |
3469 list.fixed$length = true; | |
3470 return list; | |
3471 }; | |
3472 C.List_8nO = Isolate.makeConstantList(["name", "description", "size", "watchers"
, "forks"]); | |
3473 C.List_empty = Isolate.makeConstantList([]); | |
3474 C.Symbol_call = new H.Symbol0("call"); | |
3475 C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype; | |
3476 $.getTagFunction = null; | |
3477 $.alternateTagFunction = null; | |
3478 $.prototypeForTagFunction = null; | |
3479 $.dispatchRecordsForInstanceTags = null; | |
3480 $.interceptorsForUncacheableTags = null; | |
3481 $.initNativeDispatchFlag = null; | |
3482 J.$eq = function(receiver, a0) { | |
3483 if (receiver == null) | |
3484 return a0 == null; | |
3485 if (typeof receiver != "object") | |
3486 return a0 != null && receiver === a0; | |
3487 return J.getInterceptor(receiver).$eq(receiver, a0); | |
3488 }; | |
3489 J.$ge$n = function(receiver, a0) { | |
3490 if (typeof receiver == "number" && typeof a0 == "number") | |
3491 return receiver >= a0; | |
3492 return J.getInterceptor$n(receiver).$ge(receiver, a0); | |
3493 }; | |
3494 J.$gt$n = function(receiver, a0) { | |
3495 if (typeof receiver == "number" && typeof a0 == "number") | |
3496 return receiver > a0; | |
3497 return J.getInterceptor$n(receiver).$gt(receiver, a0); | |
3498 }; | |
3499 J.$index$asx = function(receiver, a0) { | |
3500 if (receiver.constructor == Array || typeof receiver == "string" || H.isJsInde
xable(receiver, receiver[init.dispatchPropertyName])) | |
3501 if (a0 >>> 0 === a0 && a0 < receiver.length) | |
3502 return receiver[a0]; | |
3503 return J.getInterceptor$asx(receiver).$index(receiver, a0); | |
3504 }; | |
3505 J.$indexSet$ax = function(receiver, a0, a1) { | |
3506 if ((receiver.constructor == Array || H.isJsIndexable(receiver, receiver[init.
dispatchPropertyName])) && !receiver.immutable$list && a0 >>> 0 === a0 && a0 < r
eceiver.length) | |
3507 return receiver[a0] = a1; | |
3508 return J.getInterceptor$ax(receiver).$indexSet(receiver, a0, a1); | |
3509 }; | |
3510 J.$sub$n = function(receiver, a0) { | |
3511 if (typeof receiver == "number" && typeof a0 == "number") | |
3512 return receiver - a0; | |
3513 return J.getInterceptor$n(receiver).$sub(receiver, a0); | |
3514 }; | |
3515 J.elementAt$1$ax = function(receiver, a0) { | |
3516 return J.getInterceptor$ax(receiver).elementAt$1(receiver, a0); | |
3517 }; | |
3518 J.forEach$1$ax = function(receiver, a0) { | |
3519 return J.getInterceptor$ax(receiver).forEach$1(receiver, a0); | |
3520 }; | |
3521 J.get$hashCode$ = function(receiver) { | |
3522 return J.getInterceptor(receiver).get$hashCode(receiver); | |
3523 }; | |
3524 J.get$iterator$ax = function(receiver) { | |
3525 return J.getInterceptor$ax(receiver).get$iterator(receiver); | |
3526 }; | |
3527 J.get$length$asx = function(receiver) { | |
3528 return J.getInterceptor$asx(receiver).get$length(receiver); | |
3529 }; | |
3530 J.map$1$ax = function(receiver, a0) { | |
3531 return J.getInterceptor$ax(receiver).map$1(receiver, a0); | |
3532 }; | |
3533 J.noSuchMethod$1 = function(receiver, a0) { | |
3534 return J.getInterceptor(receiver).noSuchMethod$1(receiver, a0); | |
3535 }; | |
3536 J.set$href$x = function(receiver, value) { | |
3537 return J.getInterceptor$x(receiver).set$href(receiver, value); | |
3538 }; | |
3539 J.set$src$x = function(receiver, value) { | |
3540 return J.getInterceptor$x(receiver).set$src(receiver, value); | |
3541 }; | |
3542 J.set$text$x = function(receiver, value) { | |
3543 return J.getInterceptor$x(receiver).set$text(receiver, value); | |
3544 }; | |
3545 J.toString$0 = function(receiver) { | |
3546 return J.getInterceptor(receiver).toString$0(receiver); | |
3547 }; | |
3548 Isolate.$lazy($, "noSuchMethodPattern", "TypeErrorDecoder_noSuchMethodPattern",
"get$TypeErrorDecoder_noSuchMethodPattern", function() { | |
3549 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
({ toString: function() { return "$receiver$"; } })); | |
3550 }); | |
3551 Isolate.$lazy($, "notClosurePattern", "TypeErrorDecoder_notClosurePattern", "get
$TypeErrorDecoder_notClosurePattern", function() { | |
3552 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
({ $method$: null, toString: function() { return "$receiver$"; } })); | |
3553 }); | |
3554 Isolate.$lazy($, "nullCallPattern", "TypeErrorDecoder_nullCallPattern", "get$Typ
eErrorDecoder_nullCallPattern", function() { | |
3555 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
(null)); | |
3556 }); | |
3557 Isolate.$lazy($, "nullLiteralCallPattern", "TypeErrorDecoder_nullLiteralCallPatt
ern", "get$TypeErrorDecoder_nullLiteralCallPattern", function() { | |
3558 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
Null()); | |
3559 }); | |
3560 Isolate.$lazy($, "undefinedCallPattern", "TypeErrorDecoder_undefinedCallPattern"
, "get$TypeErrorDecoder_undefinedCallPattern", function() { | |
3561 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
(void 0)); | |
3562 }); | |
3563 Isolate.$lazy($, "undefinedLiteralCallPattern", "TypeErrorDecoder_undefinedLiter
alCallPattern", "get$TypeErrorDecoder_undefinedLiteralCallPattern", function() { | |
3564 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn
Undefined()); | |
3565 }); | |
3566 Isolate.$lazy($, "nullPropertyPattern", "TypeErrorDecoder_nullPropertyPattern",
"get$TypeErrorDecoder_nullPropertyPattern", function() { | |
3567 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOn(null)); | |
3568 }); | |
3569 Isolate.$lazy($, "nullLiteralPropertyPattern", "TypeErrorDecoder_nullLiteralProp
ertyPattern", "get$TypeErrorDecoder_nullLiteralPropertyPattern", function() { | |
3570 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOnNull()); | |
3571 }); | |
3572 Isolate.$lazy($, "undefinedPropertyPattern", "TypeErrorDecoder_undefinedProperty
Pattern", "get$TypeErrorDecoder_undefinedPropertyPattern", function() { | |
3573 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOn(void 0)); | |
3574 }); | |
3575 Isolate.$lazy($, "undefinedLiteralPropertyPattern", "TypeErrorDecoder_undefinedL
iteralPropertyPattern", "get$TypeErrorDecoder_undefinedLiteralPropertyPattern",
function() { | |
3576 return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErr
orOnUndefined()); | |
3577 }); | |
3578 Isolate.$lazy($, "_toStringList", "IterableMixinWorkaround__toStringList", "get$
IterableMixinWorkaround__toStringList", function() { | |
3579 return P.List_List(null, null); | |
3580 }); | |
3581 Isolate.$lazy($, "_toStringVisiting", "_toStringVisiting", "get$_toStringVisitin
g", function() { | |
3582 return P.HashSet_HashSet$identity(null); | |
3583 }); | |
3584 Isolate.$lazy($, "_toStringList", "Maps__toStringList", "get$Maps__toStringList"
, function() { | |
3585 return P.List_List(null, null); | |
3586 }); | |
3587 Isolate.$lazy($, "context", "context", "get$context", function() { | |
3588 return P._wrapToDart(function() { return this; }()); | |
3589 }); | |
3590 Isolate.$lazy($, "table", "table", "get$table", function() { | |
3591 return document.querySelector("#repo-table"); | |
3592 }); | |
3593 // Native classes | |
3594 | |
3595 init.functionAliases = {}; | |
3596 ; | |
3597 init.metadata = []; | |
3598 $ = null; | |
3599 Isolate = Isolate.$finishIsolateConstructor(Isolate); | |
3600 $ = new Isolate(); | |
3601 function convertToFastObject(properties) { | |
3602 function MyClass() {}; | |
3603 MyClass.prototype = properties; | |
3604 new MyClass(); | |
3605 return properties; | |
3606 } | |
3607 A = convertToFastObject(A); | |
3608 B = convertToFastObject(B); | |
3609 C = convertToFastObject(C); | |
3610 D = convertToFastObject(D); | |
3611 E = convertToFastObject(E); | |
3612 F = convertToFastObject(F); | |
3613 G = convertToFastObject(G); | |
3614 H = convertToFastObject(H); | |
3615 J = convertToFastObject(J); | |
3616 K = convertToFastObject(K); | |
3617 L = convertToFastObject(L); | |
3618 M = convertToFastObject(M); | |
3619 N = convertToFastObject(N); | |
3620 O = convertToFastObject(O); | |
3621 P = convertToFastObject(P); | |
3622 Q = convertToFastObject(Q); | |
3623 R = convertToFastObject(R); | |
3624 S = convertToFastObject(S); | |
3625 T = convertToFastObject(T); | |
3626 U = convertToFastObject(U); | |
3627 V = convertToFastObject(V); | |
3628 W = convertToFastObject(W); | |
3629 X = convertToFastObject(X); | |
3630 Y = convertToFastObject(Y); | |
3631 Z = convertToFastObject(Z); | |
3632 !function() { | |
3633 var objectProto = Object.prototype; | |
3634 for (var i = 0;; i++) { | |
3635 var property = "___dart_dispatch_record_ZxYxX_0_"; | |
3636 if (i > 0) | |
3637 property = rootProperty + "_" + i; | |
3638 if (!(property in objectProto)) | |
3639 return init.dispatchPropertyName = property; | |
3640 } | |
3641 }(); | |
3642 // BEGIN invoke [main]. | |
3643 ;(function (callback) { | |
3644 if (typeof document === "undefined") { | |
3645 callback(null); | |
3646 return; | |
3647 } | |
3648 if (document.currentScript) { | |
3649 callback(document.currentScript); | |
3650 return; | |
3651 } | |
3652 | |
3653 var scripts = document.scripts; | |
3654 function onLoad(event) { | |
3655 for (var i = 0; i < scripts.length; ++i) { | |
3656 scripts[i].removeEventListener("load", onLoad, false); | |
3657 } | |
3658 callback(event.target); | |
3659 } | |
3660 for (var i = 0; i < scripts.length; ++i) { | |
3661 scripts[i].addEventListener("load", onLoad, false); | |
3662 } | |
3663 })(function(currentScript) { | |
3664 init.currentScript = currentScript; | |
3665 | |
3666 if (typeof dartMainRunner === "function") { | |
3667 dartMainRunner(function() { R.main(); }); | |
3668 } else { | |
3669 R.main(); | |
3670 } | |
3671 }); | |
3672 // END invoke [main]. | |
3673 function init() { | |
3674 Isolate.$isolateProperties = {}; | |
3675 function generateAccessor(field, accessors, cls) { | |
3676 var len = field.length; | |
3677 var code = field.charCodeAt(len - 1); | |
3678 var reflectable = false; | |
3679 if (code == 45) { | |
3680 len--; | |
3681 code = field.charCodeAt(len - 1); | |
3682 field = field.substring(0, len); | |
3683 reflectable = true; | |
3684 } | |
3685 code = code >= 60 && code <= 64 ? code - 59 : code >= 123 && code <= 126 ? c
ode - 117 : code >= 37 && code <= 43 ? code - 27 : 0; | |
3686 if (code) { | |
3687 var getterCode = code & 3; | |
3688 var setterCode = code >> 2; | |
3689 var accessorName = field = field.substring(0, len - 1); | |
3690 var divider = field.indexOf(":"); | |
3691 if (divider > 0) { | |
3692 accessorName = field.substring(0, divider); | |
3693 field = field.substring(divider + 1); | |
3694 } | |
3695 if (getterCode) { | |
3696 var args = getterCode & 2 ? "receiver" : ""; | |
3697 var receiver = getterCode & 1 ? "this" : "receiver"; | |
3698 var body = "return " + receiver + "." + field; | |
3699 var property = cls + ".prototype.get$" + accessorName + "="; | |
3700 var fn = "function(" + args + "){" + body + "}"; | |
3701 if (reflectable) | |
3702 accessors.push(property + "$reflectable(" + fn + ");\n"); | |
3703 else | |
3704 accessors.push(property + fn + ";\n"); | |
3705 } | |
3706 if (setterCode) { | |
3707 var args = setterCode & 2 ? "receiver, value" : "value"; | |
3708 var receiver = setterCode & 1 ? "this" : "receiver"; | |
3709 var body = receiver + "." + field + " = value"; | |
3710 var property = cls + ".prototype.set$" + accessorName + "="; | |
3711 var fn = "function(" + args + "){" + body + "}"; | |
3712 if (reflectable) | |
3713 accessors.push(property + "$reflectable(" + fn + ");\n"); | |
3714 else | |
3715 accessors.push(property + fn + ";\n"); | |
3716 } | |
3717 } | |
3718 return field; | |
3719 } | |
3720 Isolate.$isolateProperties.$generateAccessor = generateAccessor; | |
3721 function defineClass(name, cls, fields) { | |
3722 var accessors = []; | |
3723 var str = "function " + cls + "("; | |
3724 var body = ""; | |
3725 for (var i = 0; i < fields.length; i++) { | |
3726 if (i != 0) | |
3727 str += ", "; | |
3728 var field = generateAccessor(fields[i], accessors, cls); | |
3729 var parameter = "parameter_" + field; | |
3730 str += parameter; | |
3731 body += "this." + field + " = " + parameter + ";\n"; | |
3732 } | |
3733 str += ") {\n" + body + "}\n"; | |
3734 str += cls + ".builtin$cls=\"" + name + "\";\n"; | |
3735 str += "$desc=$collectedClasses." + cls + ";\n"; | |
3736 str += "if($desc instanceof Array) $desc = $desc[1];\n"; | |
3737 str += cls + ".prototype = $desc;\n"; | |
3738 if (typeof defineClass.name != "string") { | |
3739 str += cls + ".name=\"" + cls + "\";\n"; | |
3740 } | |
3741 str += accessors.join(""); | |
3742 return str; | |
3743 } | |
3744 var inheritFrom = function() { | |
3745 function tmp() { | |
3746 } | |
3747 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
3748 return function(constructor, superConstructor) { | |
3749 tmp.prototype = superConstructor.prototype; | |
3750 var object = new tmp(); | |
3751 var properties = constructor.prototype; | |
3752 for (var member in properties) | |
3753 if (hasOwnProperty.call(properties, member)) | |
3754 object[member] = properties[member]; | |
3755 object.constructor = constructor; | |
3756 constructor.prototype = object; | |
3757 return object; | |
3758 }; | |
3759 }(); | |
3760 Isolate.$finishClasses = function(collectedClasses, isolateProperties, existin
gIsolateProperties) { | |
3761 var pendingClasses = {}; | |
3762 if (!init.allClasses) | |
3763 init.allClasses = {}; | |
3764 var allClasses = init.allClasses; | |
3765 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
3766 if (typeof dart_precompiled == "function") { | |
3767 var constructors = dart_precompiled(collectedClasses); | |
3768 } else { | |
3769 var combinedConstructorFunction = "function $reflectable(fn){fn.$reflectab
le=1;return fn};\n" + "var $desc;\n"; | |
3770 var constructorsList = []; | |
3771 } | |
3772 for (var cls in collectedClasses) { | |
3773 if (hasOwnProperty.call(collectedClasses, cls)) { | |
3774 var desc = collectedClasses[cls]; | |
3775 if (desc instanceof Array) | |
3776 desc = desc[1]; | |
3777 var classData = desc[""], supr, name = cls, fields = classData; | |
3778 if (typeof classData == "string") { | |
3779 var split = classData.split("/"); | |
3780 if (split.length == 2) { | |
3781 name = split[0]; | |
3782 fields = split[1]; | |
3783 } | |
3784 } | |
3785 var s = fields.split(";"); | |
3786 fields = s[1] == "" ? [] : s[1].split(","); | |
3787 supr = s[0]; | |
3788 if (supr && supr.indexOf("+") > 0) { | |
3789 s = supr.split("+"); | |
3790 supr = s[0]; | |
3791 var mixin = collectedClasses[s[1]]; | |
3792 if (mixin instanceof Array) | |
3793 mixin = mixin[1]; | |
3794 for (var d in mixin) { | |
3795 if (hasOwnProperty.call(mixin, d) && !hasOwnProperty.call(desc, d)) | |
3796 desc[d] = mixin[d]; | |
3797 } | |
3798 } | |
3799 if (typeof dart_precompiled != "function") { | |
3800 combinedConstructorFunction += defineClass(name, cls, fields); | |
3801 constructorsList.push(cls); | |
3802 } | |
3803 if (supr) | |
3804 pendingClasses[cls] = supr; | |
3805 } | |
3806 } | |
3807 if (typeof dart_precompiled != "function") { | |
3808 combinedConstructorFunction += "return [\n " + constructorsList.join(",\n
") + "\n]"; | |
3809 var constructors = new Function("$collectedClasses", combinedConstructorFu
nction)(collectedClasses); | |
3810 combinedConstructorFunction = null; | |
3811 } | |
3812 for (var i = 0; i < constructors.length; i++) { | |
3813 var constructor = constructors[i]; | |
3814 var cls = constructor.name; | |
3815 var desc = collectedClasses[cls]; | |
3816 var globalObject = isolateProperties; | |
3817 if (desc instanceof Array) { | |
3818 globalObject = desc[0] || isolateProperties; | |
3819 desc = desc[1]; | |
3820 } | |
3821 allClasses[cls] = constructor; | |
3822 globalObject[cls] = constructor; | |
3823 } | |
3824 constructors = null; | |
3825 var finishedClasses = {}; | |
3826 init.interceptorsByTag = Object.create(null); | |
3827 init.leafTags = {}; | |
3828 function finishClass(cls) { | |
3829 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
3830 if (hasOwnProperty.call(finishedClasses, cls)) | |
3831 return; | |
3832 finishedClasses[cls] = true; | |
3833 var superclass = pendingClasses[cls]; | |
3834 if (!superclass || typeof superclass != "string") | |
3835 return; | |
3836 finishClass(superclass); | |
3837 var constructor = allClasses[cls]; | |
3838 var superConstructor = allClasses[superclass]; | |
3839 if (!superConstructor) | |
3840 superConstructor = existingIsolateProperties[superclass]; | |
3841 var prototype = inheritFrom(constructor, superConstructor); | |
3842 if (hasOwnProperty.call(prototype, "%")) { | |
3843 var nativeSpec = prototype["%"].split(";"); | |
3844 if (nativeSpec[0]) { | |
3845 var tags = nativeSpec[0].split("|"); | |
3846 for (var i = 0; i < tags.length; i++) { | |
3847 init.interceptorsByTag[tags[i]] = constructor; | |
3848 init.leafTags[tags[i]] = true; | |
3849 } | |
3850 } | |
3851 if (nativeSpec[1]) { | |
3852 tags = nativeSpec[1].split("|"); | |
3853 if (nativeSpec[2]) { | |
3854 var subclasses = nativeSpec[2].split("|"); | |
3855 for (var i = 0; i < subclasses.length; i++) { | |
3856 var subclass = allClasses[subclasses[i]]; | |
3857 subclass.$nativeSuperclassTag = tags[0]; | |
3858 } | |
3859 } | |
3860 for (i = 0; i < tags.length; i++) { | |
3861 init.interceptorsByTag[tags[i]] = constructor; | |
3862 init.leafTags[tags[i]] = false; | |
3863 } | |
3864 } | |
3865 } | |
3866 } | |
3867 for (var cls in pendingClasses) | |
3868 finishClass(cls); | |
3869 }; | |
3870 Isolate.$lazy = function(prototype, staticName, fieldName, getterName, lazyVal
ue) { | |
3871 var sentinelUndefined = {}; | |
3872 var sentinelInProgress = {}; | |
3873 prototype[fieldName] = sentinelUndefined; | |
3874 prototype[getterName] = function() { | |
3875 var result = $[fieldName]; | |
3876 try { | |
3877 if (result === sentinelUndefined) { | |
3878 $[fieldName] = sentinelInProgress; | |
3879 try { | |
3880 result = $[fieldName] = lazyValue(); | |
3881 } finally { | |
3882 if (result === sentinelUndefined) { | |
3883 if ($[fieldName] === sentinelInProgress) { | |
3884 $[fieldName] = null; | |
3885 } | |
3886 } | |
3887 } | |
3888 } else { | |
3889 if (result === sentinelInProgress) | |
3890 H.throwCyclicInit(staticName); | |
3891 } | |
3892 return result; | |
3893 } finally { | |
3894 $[getterName] = function() { | |
3895 return this[fieldName]; | |
3896 }; | |
3897 } | |
3898 }; | |
3899 }; | |
3900 Isolate.$finishIsolateConstructor = function(oldIsolate) { | |
3901 var isolateProperties = oldIsolate.$isolateProperties; | |
3902 function Isolate() { | |
3903 var hasOwnProperty = Object.prototype.hasOwnProperty; | |
3904 for (var staticName in isolateProperties) | |
3905 if (hasOwnProperty.call(isolateProperties, staticName)) | |
3906 this[staticName] = isolateProperties[staticName]; | |
3907 function ForceEfficientMap() { | |
3908 } | |
3909 ForceEfficientMap.prototype = this; | |
3910 new ForceEfficientMap(); | |
3911 } | |
3912 Isolate.prototype = oldIsolate.prototype; | |
3913 Isolate.prototype.constructor = Isolate; | |
3914 Isolate.$isolateProperties = isolateProperties; | |
3915 Isolate.$finishClasses = oldIsolate.$finishClasses; | |
3916 Isolate.makeConstantList = oldIsolate.makeConstantList; | |
3917 return Isolate; | |
3918 }; | |
3919 } | |
3920 })() | |
3921 | |
3922 //# sourceMappingURL=index.dart.js.map | |
3923 //@ sourceMappingURL=index.dart.js.map | |
OLD | NEW |