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