5408 lines
243 KiB
JavaScript
5408 lines
243 KiB
JavaScript
// Generated by dart2js (fast startup emitter, strong), the Dart to JavaScript compiler version: 2.12.3.
|
|
// The code supports the following hooks:
|
|
// dartPrint(message):
|
|
// if this function is defined it is called instead of the Dart [print]
|
|
// method.
|
|
//
|
|
// dartMainRunner(main, args):
|
|
// if this function is defined, the Dart [main] method will not be invoked
|
|
// directly. Instead, a closure that will invoke [main], and its arguments
|
|
// [args] is passed to [dartMainRunner].
|
|
//
|
|
// dartDeferredLibraryLoader(uri, successCallback, errorCallback):
|
|
// if this function is defined, it will be called when a deferred library
|
|
// is loaded. It should load and eval the javascript of `uri`, and call
|
|
// successCallback. If it fails to do so, it should call errorCallback with
|
|
// an error.
|
|
//
|
|
// dartCallInstrumentation(id, qualifiedName):
|
|
// if this function is defined, it will be called at each entry of a
|
|
// method or constructor. Used only when compiling programs with
|
|
// --experiment-call-instrumentation.
|
|
(function dartProgram() {
|
|
function copyProperties(from, to) {
|
|
var keys = Object.keys(from);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
|
|
function mixinProperties(from, to) {
|
|
var keys = Object.keys(from);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
if (!to.hasOwnProperty(key))
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
var supportsDirectProtoAccess = function () {
|
|
var cls = function () {};
|
|
cls.prototype = {
|
|
p: {}
|
|
};
|
|
var object = new cls();
|
|
if (!(object.__proto__ && object.__proto__.p === cls.prototype.p))
|
|
return false;
|
|
try {
|
|
if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0)
|
|
return true;
|
|
if (typeof version == "function" && version.length == 0) {
|
|
var v = version();
|
|
if (/^\d+\.\d+\.\d+\.\d+$/.test(v))
|
|
return true;
|
|
}
|
|
} catch (_) {}
|
|
return false;
|
|
}();
|
|
|
|
function setFunctionNamesIfNecessary(holders) {
|
|
function t() {};
|
|
if (typeof t.name == "string")
|
|
return;
|
|
for (var i = 0; i < holders.length; i++) {
|
|
var holder = holders[i];
|
|
var keys = Object.keys(holder);
|
|
for (var j = 0; j < keys.length; j++) {
|
|
var key = keys[j];
|
|
var f = holder[key];
|
|
if (typeof f == "function")
|
|
f.name = key;
|
|
}
|
|
}
|
|
}
|
|
|
|
function inherit(cls, sup) {
|
|
cls.prototype.constructor = cls;
|
|
cls.prototype["$is" + cls.name] = cls;
|
|
if (sup != null) {
|
|
if (supportsDirectProtoAccess) {
|
|
cls.prototype.__proto__ = sup.prototype;
|
|
return;
|
|
}
|
|
var clsPrototype = Object.create(sup.prototype);
|
|
copyProperties(cls.prototype, clsPrototype);
|
|
cls.prototype = clsPrototype;
|
|
}
|
|
}
|
|
|
|
function inheritMany(sup, classes) {
|
|
for (var i = 0; i < classes.length; i++)
|
|
inherit(classes[i], sup);
|
|
}
|
|
|
|
function mixin(cls, mixin) {
|
|
mixinProperties(mixin.prototype, cls.prototype);
|
|
cls.prototype.constructor = cls;
|
|
}
|
|
|
|
function lazyOld(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function () {
|
|
holder[getterName] = function () {
|
|
H.throwCyclicInit(name);
|
|
};
|
|
var result;
|
|
var sentinelInProgress = initializer;
|
|
try {
|
|
if (holder[name] === uninitializedSentinel) {
|
|
result = holder[name] = sentinelInProgress;
|
|
result = holder[name] = initializer();
|
|
} else
|
|
result = holder[name];
|
|
} finally {
|
|
if (result === sentinelInProgress)
|
|
holder[name] = null;
|
|
holder[getterName] = function () {
|
|
return this[name];
|
|
};
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
|
|
function lazy(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function () {
|
|
if (holder[name] === uninitializedSentinel)
|
|
holder[name] = initializer();
|
|
holder[getterName] = function () {
|
|
return this[name];
|
|
};
|
|
return holder[name];
|
|
};
|
|
}
|
|
|
|
function lazyFinal(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function () {
|
|
if (holder[name] === uninitializedSentinel) {
|
|
var value = initializer();
|
|
if (holder[name] !== uninitializedSentinel)
|
|
H.throwLateInitializationError(name);
|
|
holder[name] = value;
|
|
}
|
|
holder[getterName] = function () {
|
|
return this[name];
|
|
};
|
|
return holder[name];
|
|
};
|
|
}
|
|
|
|
function makeConstList(list) {
|
|
list.immutable$list = Array;
|
|
list.fixed$length = Array;
|
|
return list;
|
|
}
|
|
|
|
function convertToFastObject(properties) {
|
|
function t() {}
|
|
t.prototype = properties;
|
|
new t();
|
|
return properties;
|
|
}
|
|
|
|
function convertAllToFastObject(arrayOfObjects) {
|
|
for (var i = 0; i < arrayOfObjects.length; ++i)
|
|
convertToFastObject(arrayOfObjects[i]);
|
|
}
|
|
var functionCounter = 0;
|
|
|
|
function tearOffGetter(funcs, applyTrampolineIndex, reflectionInfo, name, isIntercepted) {
|
|
return isIntercepted ? new Function("funcs", "applyTrampolineIndex", "reflectionInfo", "name", "H", "c", "return function tearOff_" + name + functionCounter++ + "(receiver) {" + "if (c === null) c = " + "H.closureFromTearOff" + "(" + "this, funcs, applyTrampolineIndex, reflectionInfo, false, true, name);" + "return new c(this, funcs[0], receiver, name);" + "}")(funcs, applyTrampolineIndex, reflectionInfo, name, H, null) : new Function("funcs", "applyTrampolineIndex", "reflectionInfo", "name", "H", "c", "return function tearOff_" + name + functionCounter++ + "() {" + "if (c === null) c = " + "H.closureFromTearOff" + "(" + "this, funcs, applyTrampolineIndex, reflectionInfo, false, false, name);" + "return new c(this, funcs[0], null, name);" + "}")(funcs, applyTrampolineIndex, reflectionInfo, name, H, null);
|
|
}
|
|
|
|
function tearOff(funcs, applyTrampolineIndex, reflectionInfo, isStatic, name, isIntercepted) {
|
|
var cache = null;
|
|
return isStatic ? function () {
|
|
if (cache === null)
|
|
cache = H.closureFromTearOff(this, funcs, applyTrampolineIndex, reflectionInfo, true, false, name).prototype;
|
|
return cache;
|
|
} : tearOffGetter(funcs, applyTrampolineIndex, reflectionInfo, name, isIntercepted);
|
|
}
|
|
var typesOffset = 0;
|
|
|
|
function installTearOff(container, getterName, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
|
|
var funs = [];
|
|
for (var i = 0; i < funsOrNames.length; i++) {
|
|
var fun = funsOrNames[i];
|
|
if (typeof fun == "string")
|
|
fun = container[fun];
|
|
fun.$callName = callNames[i];
|
|
funs.push(fun);
|
|
}
|
|
var fun = funs[0];
|
|
fun.$requiredArgCount = requiredParameterCount;
|
|
fun.$defaultValues = optionalParameterDefaultValues;
|
|
var reflectionInfo = funType;
|
|
if (typeof reflectionInfo == "number")
|
|
reflectionInfo += typesOffset;
|
|
var name = funsOrNames[0];
|
|
fun.$stubName = name;
|
|
var getterFunction = tearOff(funs, applyIndex || 0, reflectionInfo, isStatic, name, isIntercepted);
|
|
container[getterName] = getterFunction;
|
|
if (isStatic)
|
|
fun.$tearOff = getterFunction;
|
|
}
|
|
|
|
function installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
|
|
return installTearOff(container, getterName, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex);
|
|
}
|
|
|
|
function installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
|
|
return installTearOff(container, getterName, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex);
|
|
}
|
|
|
|
function setOrUpdateInterceptorsByTag(newTags) {
|
|
var tags = init.interceptorsByTag;
|
|
if (!tags) {
|
|
init.interceptorsByTag = newTags;
|
|
return;
|
|
}
|
|
copyProperties(newTags, tags);
|
|
}
|
|
|
|
function setOrUpdateLeafTags(newTags) {
|
|
var tags = init.leafTags;
|
|
if (!tags) {
|
|
init.leafTags = newTags;
|
|
return;
|
|
}
|
|
copyProperties(newTags, tags);
|
|
}
|
|
|
|
function updateTypes(newTypes) {
|
|
var types = init.types;
|
|
var length = types.length;
|
|
types.push.apply(types, newTypes);
|
|
return length;
|
|
}
|
|
|
|
function updateHolder(holder, newHolder) {
|
|
copyProperties(newHolder, holder);
|
|
return holder;
|
|
}
|
|
var hunkHelpers = function () {
|
|
var mkInstance = function (isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
|
|
return function (container, getterName, name, funType) {
|
|
return installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex);
|
|
};
|
|
},
|
|
mkStatic = function (requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
|
|
return function (container, getterName, name, funType) {
|
|
return installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex);
|
|
};
|
|
};
|
|
return {
|
|
inherit: inherit,
|
|
inheritMany: inheritMany,
|
|
mixin: mixin,
|
|
installStaticTearOff: installStaticTearOff,
|
|
installInstanceTearOff: installInstanceTearOff,
|
|
_instance_0u: mkInstance(0, 0, null, ["call$0"], 0),
|
|
_instance_1u: mkInstance(0, 1, null, ["call$1"], 0),
|
|
_instance_2u: mkInstance(0, 2, null, ["call$2"], 0),
|
|
_instance_0i: mkInstance(1, 0, null, ["call$0"], 0),
|
|
_instance_1i: mkInstance(1, 1, null, ["call$1"], 0),
|
|
_instance_2i: mkInstance(1, 2, null, ["call$2"], 0),
|
|
_static_0: mkStatic(0, null, ["call$0"], 0),
|
|
_static_1: mkStatic(1, null, ["call$1"], 0),
|
|
_static_2: mkStatic(2, null, ["call$2"], 0),
|
|
makeConstList: makeConstList,
|
|
lazy: lazy,
|
|
lazyFinal: lazyFinal,
|
|
lazyOld: lazyOld,
|
|
updateHolder: updateHolder,
|
|
convertToFastObject: convertToFastObject,
|
|
setFunctionNamesIfNecessary: setFunctionNamesIfNecessary,
|
|
updateTypes: updateTypes,
|
|
setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag,
|
|
setOrUpdateLeafTags: setOrUpdateLeafTags
|
|
};
|
|
}();
|
|
|
|
function initializeDeferredHunk(hunk) {
|
|
typesOffset = init.types.length;
|
|
hunk(hunkHelpers, init, holders, $);
|
|
}
|
|
|
|
function getGlobalFromName(name) {
|
|
for (var i = 0; i < holders.length; i++) {
|
|
if (holders[i] == C)
|
|
continue;
|
|
if (holders[i][name])
|
|
return holders[i][name];
|
|
}
|
|
}
|
|
var C = {},
|
|
H = {
|
|
JS_CONST: function JS_CONST() {},
|
|
checkNotNullable: function (value, $name, $T) {
|
|
return value;
|
|
},
|
|
LateError: function LateError(t0) {
|
|
this._message = t0;
|
|
},
|
|
ListIterator: function ListIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_.__internal$_iterable = t0;
|
|
_.__internal$_length = t1;
|
|
_.__internal$_index = 0;
|
|
_.__internal$_current = null;
|
|
_.$ti = t2;
|
|
},
|
|
unminifyOrTag: function (rawClassName) {
|
|
var preserved = H.unmangleGlobalNameIfPreservedAnyways(rawClassName);
|
|
if (preserved != null)
|
|
return preserved;
|
|
return rawClassName;
|
|
},
|
|
isJsIndexable: function (object, record) {
|
|
var result;
|
|
if (record != null) {
|
|
result = record.x;
|
|
if (result != null)
|
|
return result;
|
|
}
|
|
return type$.JavaScriptIndexingBehavior_dynamic._is(object);
|
|
},
|
|
S: function (value) {
|
|
var res;
|
|
if (typeof value == "string")
|
|
return value;
|
|
if (typeof value == "number") {
|
|
if (value !== 0)
|
|
return "" + value;
|
|
} else if (true === value)
|
|
return "true";
|
|
else if (false === value)
|
|
return "false";
|
|
else if (value == null)
|
|
return "null";
|
|
res = J.toString$0$(value);
|
|
return res;
|
|
},
|
|
Primitives_objectHashCode: function (object) {
|
|
var hash = object.$identityHash;
|
|
if (hash == null) {
|
|
hash = Math.random() * 0x3fffffff | 0;
|
|
object.$identityHash = hash;
|
|
}
|
|
return hash;
|
|
},
|
|
Primitives_objectTypeName: function (object) {
|
|
return H.Primitives__objectTypeNameNewRti(object);
|
|
},
|
|
Primitives__objectTypeNameNewRti: function (object) {
|
|
var dispatchName, $constructor, constructorName;
|
|
if (object instanceof P.Object)
|
|
return H._rtiToString(H.instanceType(object), null);
|
|
if (J.getInterceptor$(object) === C.Interceptor_methods || type$.UnknownJavaScriptObject._is(object)) {
|
|
dispatchName = C.C_JS_CONST(object);
|
|
if (H.Primitives__saneNativeClassName(dispatchName))
|
|
return dispatchName;
|
|
$constructor = object.constructor;
|
|
if (typeof $constructor == "function") {
|
|
constructorName = $constructor.name;
|
|
if (typeof constructorName == "string" && H.Primitives__saneNativeClassName(constructorName))
|
|
return constructorName;
|
|
}
|
|
}
|
|
return H._rtiToString(H.instanceType(object), null);
|
|
},
|
|
Primitives__saneNativeClassName: function ($name) {
|
|
var t1 = $name !== "Object" && $name !== "";
|
|
return t1;
|
|
},
|
|
ioore: function (receiver, index) {
|
|
if (receiver == null)
|
|
J.get$length$asx(receiver);
|
|
throw H.wrapException(H.diagnoseIndexError(receiver, index));
|
|
},
|
|
diagnoseIndexError: function (indexable, index) {
|
|
var $length, _s5_ = "index";
|
|
if (!H._isInt(index))
|
|
return new P.ArgumentError(true, index, _s5_, null);
|
|
$length = H._asInt(J.get$length$asx(indexable));
|
|
if (index < 0 || index >= $length)
|
|
return P.IndexError$(index, indexable, _s5_, null, $length);
|
|
return P.RangeError$value(index, _s5_);
|
|
},
|
|
wrapException: function (ex) {
|
|
var wrapper, t1;
|
|
if (ex == null)
|
|
ex = new P.NullThrownError();
|
|
wrapper = new Error();
|
|
wrapper.dartException = ex;
|
|
t1 = H.toStringWrapper;
|
|
if ("defineProperty" in Object) {
|
|
Object.defineProperty(wrapper, "message", {
|
|
get: t1
|
|
});
|
|
wrapper.name = "";
|
|
} else
|
|
wrapper.toString = t1;
|
|
return wrapper;
|
|
},
|
|
toStringWrapper: function () {
|
|
return J.toString$0$(this.dartException);
|
|
},
|
|
throwExpression: function (ex) {
|
|
throw H.wrapException(ex);
|
|
},
|
|
throwConcurrentModificationError: function (collection) {
|
|
throw H.wrapException(P.ConcurrentModificationError$(collection));
|
|
},
|
|
TypeErrorDecoder_extractPattern: function (message) {
|
|
var match, $arguments, argumentsExpr, expr, method, receiver;
|
|
message = H.quoteStringForRegExp(message.replace(String({}), "$receiver$"));
|
|
match = message.match(/\\\$[a-zA-Z]+\\\$/g);
|
|
if (match == null)
|
|
match = H.setRuntimeTypeInfo([], type$.JSArray_String);
|
|
$arguments = match.indexOf("\\$arguments\\$");
|
|
argumentsExpr = match.indexOf("\\$argumentsExpr\\$");
|
|
expr = match.indexOf("\\$expr\\$");
|
|
method = match.indexOf("\\$method\\$");
|
|
receiver = match.indexOf("\\$receiver\\$");
|
|
return new H.TypeErrorDecoder(message.replace(new RegExp("\\\\\\$arguments\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$argumentsExpr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$expr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$method\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$receiver\\\\\\$", "g"), "((?:x|[^x])*)"), $arguments, argumentsExpr, expr, method, receiver);
|
|
},
|
|
TypeErrorDecoder_provokeCallErrorOn: function (expression) {
|
|
return function ($expr$) {
|
|
var $argumentsExpr$ = "$arguments$";
|
|
try {
|
|
$expr$.$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}(expression);
|
|
},
|
|
TypeErrorDecoder_provokePropertyErrorOn: function (expression) {
|
|
return function ($expr$) {
|
|
try {
|
|
$expr$.$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}(expression);
|
|
},
|
|
NullError$: function (_message, match) {
|
|
return new H.NullError(_message, match == null ? null : match.method);
|
|
},
|
|
JsNoSuchMethodError$: function (_message, match) {
|
|
var t1 = match == null,
|
|
t2 = t1 ? null : match.method;
|
|
return new H.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver);
|
|
},
|
|
unwrapException: function (ex) {
|
|
if (ex == null)
|
|
return new H.NullThrownFromJavaScriptException(ex);
|
|
if (typeof ex !== "object")
|
|
return ex;
|
|
if ("dartException" in ex)
|
|
return H.saveStackTrace(ex, ex.dartException);
|
|
return H._unwrapNonDartException(ex);
|
|
},
|
|
saveStackTrace: function (ex, error) {
|
|
if (type$.Error._is(error))
|
|
if (error.$thrownJsError == null)
|
|
error.$thrownJsError = ex;
|
|
return error;
|
|
},
|
|
_unwrapNonDartException: function (ex) {
|
|
var message, number, ieErrorCode, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, match, t1, _null = null;
|
|
if (!("message" in ex))
|
|
return ex;
|
|
message = ex.message;
|
|
if ("number" in ex && typeof ex.number == "number") {
|
|
number = ex.number;
|
|
ieErrorCode = number & 65535;
|
|
if ((C.JSInt_methods._shrOtherPositive$1(number, 16) & 8191) === 10)
|
|
switch (ieErrorCode) {
|
|
case 438:
|
|
return H.saveStackTrace(ex, H.JsNoSuchMethodError$(H.S(message) + " (Error " + ieErrorCode + ")", _null));
|
|
case 445:
|
|
case 5007:
|
|
return H.saveStackTrace(ex, H.NullError$(H.S(message) + " (Error " + ieErrorCode + ")", _null));
|
|
}
|
|
}
|
|
if (ex instanceof TypeError) {
|
|
nsme = $.$get$TypeErrorDecoder_noSuchMethodPattern();
|
|
notClosure = $.$get$TypeErrorDecoder_notClosurePattern();
|
|
nullCall = $.$get$TypeErrorDecoder_nullCallPattern();
|
|
nullLiteralCall = $.$get$TypeErrorDecoder_nullLiteralCallPattern();
|
|
undefCall = $.$get$TypeErrorDecoder_undefinedCallPattern();
|
|
undefLiteralCall = $.$get$TypeErrorDecoder_undefinedLiteralCallPattern();
|
|
nullProperty = $.$get$TypeErrorDecoder_nullPropertyPattern();
|
|
$.$get$TypeErrorDecoder_nullLiteralPropertyPattern();
|
|
undefProperty = $.$get$TypeErrorDecoder_undefinedPropertyPattern();
|
|
undefLiteralProperty = $.$get$TypeErrorDecoder_undefinedLiteralPropertyPattern();
|
|
match = nsme.matchTypeError$1(message);
|
|
if (match != null)
|
|
return H.saveStackTrace(ex, H.JsNoSuchMethodError$(H._asString(message), match));
|
|
else {
|
|
match = notClosure.matchTypeError$1(message);
|
|
if (match != null) {
|
|
match.method = "call";
|
|
return H.saveStackTrace(ex, H.JsNoSuchMethodError$(H._asString(message), match));
|
|
} else {
|
|
match = nullCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullProperty.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefProperty.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefLiteralProperty.matchTypeError$1(message);
|
|
t1 = match != null;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
if (t1)
|
|
return H.saveStackTrace(ex, H.NullError$(H._asString(message), match));
|
|
}
|
|
}
|
|
return H.saveStackTrace(ex, new H.UnknownJsTypeError(typeof message == "string" ? message : ""));
|
|
}
|
|
if (ex instanceof RangeError) {
|
|
if (typeof message == "string" && message.indexOf("call stack") !== -1)
|
|
return new P.StackOverflowError();
|
|
message = function (ex) {
|
|
try {
|
|
return String(ex);
|
|
} catch (e) {}
|
|
return null;
|
|
}(ex);
|
|
return H.saveStackTrace(ex, new P.ArgumentError(false, _null, _null, typeof message == "string" ? message.replace(/^RangeError:\s*/, "") : message));
|
|
}
|
|
if (typeof InternalError == "function" && ex instanceof InternalError)
|
|
if (typeof message == "string" && message === "too much recursion")
|
|
return new P.StackOverflowError();
|
|
return ex;
|
|
},
|
|
getTraceFromException: function (exception) {
|
|
var trace;
|
|
if (exception == null)
|
|
return new H._StackTrace(exception);
|
|
trace = exception.$cachedTrace;
|
|
if (trace != null)
|
|
return trace;
|
|
return exception.$cachedTrace = new H._StackTrace(exception);
|
|
},
|
|
fillLiteralMap: function (keyValuePairs, result) {
|
|
var t1, t2, index, index0, key, value, strings, cell, nums, rest, hash, bucket,
|
|
$length = keyValuePairs.length;
|
|
for (t1 = H._instanceType(result), t2 = t1._precomputed1, t1 = t1._rest[1], index = 0; index < $length;) {
|
|
index0 = index + 1;
|
|
key = keyValuePairs[index];
|
|
index = index0 + 1;
|
|
value = keyValuePairs[index0];
|
|
t2._as(key);
|
|
t1._as(value);
|
|
if (typeof key == "string") {
|
|
strings = result._strings;
|
|
if (strings == null)
|
|
strings = result._strings = result._newHashTable$0();
|
|
cell = result._getTableCell$2(strings, key);
|
|
if (cell == null)
|
|
result._setTableEntry$3(strings, key, result._newLinkedCell$2(key, value));
|
|
else
|
|
cell.hashMapCellValue = value;
|
|
} else if (typeof key == "number" && (key & 0x3ffffff) === key) {
|
|
nums = result._nums;
|
|
if (nums == null)
|
|
nums = result._nums = result._newHashTable$0();
|
|
cell = result._getTableCell$2(nums, key);
|
|
if (cell == null)
|
|
result._setTableEntry$3(nums, key, result._newLinkedCell$2(key, value));
|
|
else
|
|
cell.hashMapCellValue = value;
|
|
} else {
|
|
rest = result.__js_helper$_rest;
|
|
if (rest == null)
|
|
rest = result.__js_helper$_rest = result._newHashTable$0();
|
|
hash = J.get$hashCode$(key) & 0x3ffffff;
|
|
bucket = result._getTableBucket$2(rest, hash);
|
|
if (bucket == null)
|
|
result._setTableEntry$3(rest, hash, [result._newLinkedCell$2(key, value)]);
|
|
else {
|
|
index0 = result.internalFindBucketIndex$2(bucket, key);
|
|
if (index0 >= 0)
|
|
bucket[index0].hashMapCellValue = value;
|
|
else
|
|
bucket.push(result._newLinkedCell$2(key, value));
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
invokeClosure: function (closure, numberOfArguments, arg1, arg2, arg3, arg4) {
|
|
type$.Function._as(closure);
|
|
switch (H._asInt(numberOfArguments)) {
|
|
case 0:
|
|
return closure.call$0();
|
|
case 1:
|
|
return closure.call$1(arg1);
|
|
case 2:
|
|
return closure.call$2(arg1, arg2);
|
|
case 3:
|
|
return closure.call$3(arg1, arg2, arg3);
|
|
case 4:
|
|
return closure.call$4(arg1, arg2, arg3, arg4);
|
|
}
|
|
throw H.wrapException(new P._Exception("Unsupported number of arguments for wrapped closure"));
|
|
},
|
|
convertDartClosureToJS: function (closure, arity) {
|
|
var $function = closure.$identity;
|
|
if (!!$function)
|
|
return $function;
|
|
$function = function (closure, arity, invoke) {
|
|
return function (a1, a2, a3, a4) {
|
|
return invoke(closure, arity, a1, a2, a3, a4);
|
|
};
|
|
}(closure, arity, H.invokeClosure);
|
|
closure.$identity = $function;
|
|
return $function;
|
|
},
|
|
Closure_fromTearOff: function (receiver, functions, applyTrampolineIndex, reflectionInfo, isStatic, isIntercepted, propertyName) {
|
|
var $constructor, t1, trampoline, applyTrampoline, i, stub, stubCallName,
|
|
$function = functions[0],
|
|
callName = $function.$callName,
|
|
$prototype = isStatic ? Object.create(new H.StaticClosure().constructor.prototype) : Object.create(new H.BoundClosure(null, null, null, "").constructor.prototype);
|
|
$prototype.$initialize = $prototype.constructor;
|
|
if (isStatic)
|
|
$constructor = function static_tear_off() {
|
|
this.$initialize();
|
|
};
|
|
else {
|
|
t1 = $.Closure_functionCounter;
|
|
if (typeof t1 !== "number")
|
|
return t1.$add();
|
|
$.Closure_functionCounter = t1 + 1;
|
|
t1 = new Function("a,b,c,d" + t1, "this.$initialize(a,b,c,d" + t1 + ")");
|
|
$constructor = t1;
|
|
}
|
|
$prototype.constructor = $constructor;
|
|
$constructor.prototype = $prototype;
|
|
if (!isStatic) {
|
|
trampoline = H.Closure_forwardCallTo(receiver, $function, isIntercepted);
|
|
trampoline.$reflectionInfo = reflectionInfo;
|
|
} else {
|
|
$prototype.$static_name = propertyName;
|
|
trampoline = $function;
|
|
}
|
|
type$.Object._as(reflectionInfo);
|
|
$prototype.$signature = H.Closure__computeSignatureFunctionNewRti(reflectionInfo, isStatic, isIntercepted);
|
|
$prototype[callName] = trampoline;
|
|
for (applyTrampoline = trampoline, i = 1; i < functions.length; ++i) {
|
|
stub = functions[i];
|
|
stubCallName = stub.$callName;
|
|
if (stubCallName != null) {
|
|
stub = isStatic ? stub : H.Closure_forwardCallTo(receiver, stub, isIntercepted);
|
|
$prototype[stubCallName] = stub;
|
|
}
|
|
if (i === applyTrampolineIndex) {
|
|
stub.$reflectionInfo = reflectionInfo;
|
|
applyTrampoline = stub;
|
|
}
|
|
}
|
|
$prototype["call*"] = applyTrampoline;
|
|
$prototype.$requiredArgCount = $function.$requiredArgCount;
|
|
$prototype.$defaultValues = $function.$defaultValues;
|
|
return $constructor;
|
|
},
|
|
Closure__computeSignatureFunctionNewRti: function (functionType, isStatic, isIntercepted) {
|
|
var typeEvalMethod;
|
|
if (typeof functionType == "number")
|
|
return function (getType, t) {
|
|
return function () {
|
|
return getType(t);
|
|
};
|
|
}(H.getTypeFromTypesTable, functionType);
|
|
if (typeof functionType == "string") {
|
|
if (isStatic)
|
|
throw H.wrapException("Cannot compute signature for static tearoff.");
|
|
typeEvalMethod = isIntercepted ? H.BoundClosure_evalRecipeIntercepted : H.BoundClosure_evalRecipe;
|
|
return function (recipe, evalOnReceiver) {
|
|
return function () {
|
|
return evalOnReceiver(this, recipe);
|
|
};
|
|
}(functionType, typeEvalMethod);
|
|
}
|
|
throw H.wrapException("Error in functionType of tearoff");
|
|
},
|
|
Closure_cspForwardCall: function (arity, isSuperCall, stubName, $function) {
|
|
var getSelf = H.BoundClosure_selfOf;
|
|
switch (isSuperCall ? -1 : arity) {
|
|
case 0:
|
|
return function (n, S) {
|
|
return function () {
|
|
return S(this)[n]();
|
|
};
|
|
}(stubName, getSelf);
|
|
case 1:
|
|
return function (n, S) {
|
|
return function (a) {
|
|
return S(this)[n](a);
|
|
};
|
|
}(stubName, getSelf);
|
|
case 2:
|
|
return function (n, S) {
|
|
return function (a, b) {
|
|
return S(this)[n](a, b);
|
|
};
|
|
}(stubName, getSelf);
|
|
case 3:
|
|
return function (n, S) {
|
|
return function (a, b, c) {
|
|
return S(this)[n](a, b, c);
|
|
};
|
|
}(stubName, getSelf);
|
|
case 4:
|
|
return function (n, S) {
|
|
return function (a, b, c, d) {
|
|
return S(this)[n](a, b, c, d);
|
|
};
|
|
}(stubName, getSelf);
|
|
case 5:
|
|
return function (n, S) {
|
|
return function (a, b, c, d, e) {
|
|
return S(this)[n](a, b, c, d, e);
|
|
};
|
|
}(stubName, getSelf);
|
|
default:
|
|
return function (f, s) {
|
|
return function () {
|
|
return f.apply(s(this), arguments);
|
|
};
|
|
}($function, getSelf);
|
|
}
|
|
},
|
|
Closure_forwardCallTo: function (receiver, $function, isIntercepted) {
|
|
var stubName, arity, lookedUpFunction, t1, t2, selfName, $arguments;
|
|
if (isIntercepted)
|
|
return H.Closure_forwardInterceptedCallTo(receiver, $function);
|
|
stubName = $function.$stubName;
|
|
arity = $function.length;
|
|
lookedUpFunction = receiver[stubName];
|
|
t1 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction;
|
|
t2 = !t1 || arity >= 27;
|
|
if (t2)
|
|
return H.Closure_cspForwardCall(arity, !t1, stubName, $function);
|
|
if (arity === 0) {
|
|
t1 = $.Closure_functionCounter;
|
|
if (typeof t1 !== "number")
|
|
return t1.$add();
|
|
$.Closure_functionCounter = t1 + 1;
|
|
selfName = "self" + t1;
|
|
return new Function("return function(){var " + selfName + " = this." + H.BoundClosure_selfFieldName() + ";return " + selfName + "." + H.S(stubName) + "();}")();
|
|
}
|
|
$arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(",");
|
|
t1 = $.Closure_functionCounter;
|
|
if (typeof t1 !== "number")
|
|
return t1.$add();
|
|
$.Closure_functionCounter = t1 + 1;
|
|
$arguments += t1;
|
|
return new Function("return function(" + $arguments + "){return this." + H.BoundClosure_selfFieldName() + "." + H.S(stubName) + "(" + $arguments + ");}")();
|
|
},
|
|
Closure_cspForwardInterceptedCall: function (arity, isSuperCall, $name, $function) {
|
|
var getSelf = H.BoundClosure_selfOf,
|
|
getReceiver = H.BoundClosure_receiverOf;
|
|
switch (isSuperCall ? -1 : arity) {
|
|
case 0:
|
|
throw H.wrapException(new H.RuntimeError("Intercepted function with no arguments."));
|
|
case 1:
|
|
return function (n, s, r) {
|
|
return function () {
|
|
return s(this)[n](r(this));
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
case 2:
|
|
return function (n, s, r) {
|
|
return function (a) {
|
|
return s(this)[n](r(this), a);
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
case 3:
|
|
return function (n, s, r) {
|
|
return function (a, b) {
|
|
return s(this)[n](r(this), a, b);
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
case 4:
|
|
return function (n, s, r) {
|
|
return function (a, b, c) {
|
|
return s(this)[n](r(this), a, b, c);
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
case 5:
|
|
return function (n, s, r) {
|
|
return function (a, b, c, d) {
|
|
return s(this)[n](r(this), a, b, c, d);
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
case 6:
|
|
return function (n, s, r) {
|
|
return function (a, b, c, d, e) {
|
|
return s(this)[n](r(this), a, b, c, d, e);
|
|
};
|
|
}($name, getSelf, getReceiver);
|
|
default:
|
|
return function (f, s, r, a) {
|
|
return function () {
|
|
a = [r(this)];
|
|
Array.prototype.push.apply(a, arguments);
|
|
return f.apply(s(this), a);
|
|
};
|
|
}($function, getSelf, getReceiver);
|
|
}
|
|
},
|
|
Closure_forwardInterceptedCallTo: function (receiver, $function) {
|
|
var stubName, arity, lookedUpFunction, t1, t2, $arguments,
|
|
selfField = H.BoundClosure_selfFieldName(),
|
|
receiverField = $.BoundClosure_receiverFieldNameCache;
|
|
if (receiverField == null)
|
|
receiverField = $.BoundClosure_receiverFieldNameCache = H.BoundClosure_computeFieldNamed("receiver");
|
|
stubName = $function.$stubName;
|
|
arity = $function.length;
|
|
lookedUpFunction = receiver[stubName];
|
|
t1 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction;
|
|
t2 = !t1 || arity >= 28;
|
|
if (t2)
|
|
return H.Closure_cspForwardInterceptedCall(arity, !t1, stubName, $function);
|
|
if (arity === 1) {
|
|
t1 = "return function(){return this." + selfField + "." + H.S(stubName) + "(this." + receiverField + ");";
|
|
t2 = $.Closure_functionCounter;
|
|
if (typeof t2 !== "number")
|
|
return t2.$add();
|
|
$.Closure_functionCounter = t2 + 1;
|
|
return new Function(t1 + t2 + "}")();
|
|
}
|
|
$arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity - 1).join(",");
|
|
t1 = "return function(" + $arguments + "){return this." + selfField + "." + H.S(stubName) + "(this." + receiverField + ", " + $arguments + ");";
|
|
t2 = $.Closure_functionCounter;
|
|
if (typeof t2 !== "number")
|
|
return t2.$add();
|
|
$.Closure_functionCounter = t2 + 1;
|
|
return new Function(t1 + t2 + "}")();
|
|
},
|
|
closureFromTearOff: function (receiver, functions, applyTrampolineIndex, reflectionInfo, isStatic, isIntercepted, $name) {
|
|
return H.Closure_fromTearOff(receiver, functions, applyTrampolineIndex, reflectionInfo, !!isStatic, !!isIntercepted, $name);
|
|
},
|
|
BoundClosure_evalRecipe: function (closure, recipe) {
|
|
return H._Universe_evalInEnvironment(init.typeUniverse, H.instanceType(closure._self), recipe);
|
|
},
|
|
BoundClosure_evalRecipeIntercepted: function (closure, recipe) {
|
|
return H._Universe_evalInEnvironment(init.typeUniverse, H.instanceType(closure._receiver), recipe);
|
|
},
|
|
BoundClosure_selfOf: function (closure) {
|
|
return closure._self;
|
|
},
|
|
BoundClosure_receiverOf: function (closure) {
|
|
return closure._receiver;
|
|
},
|
|
BoundClosure_selfFieldName: function () {
|
|
var t1 = $.BoundClosure_selfFieldNameCache;
|
|
return t1 == null ? $.BoundClosure_selfFieldNameCache = H.BoundClosure_computeFieldNamed("self") : t1;
|
|
},
|
|
BoundClosure_computeFieldNamed: function (fieldName) {
|
|
var t1, i, $name,
|
|
template = new H.BoundClosure("self", "target", "receiver", "name"),
|
|
names = J.JSArray_markFixedList(Object.getOwnPropertyNames(template), type$.nullable_Object);
|
|
for (t1 = names.length, i = 0; i < t1; ++i) {
|
|
$name = names[i];
|
|
if (template[$name] === fieldName)
|
|
return $name;
|
|
}
|
|
throw H.wrapException(P.ArgumentError$("Field name " + fieldName + " not found."));
|
|
},
|
|
throwCyclicInit: function (staticName) {
|
|
throw H.wrapException(new P.CyclicInitializationError(staticName));
|
|
},
|
|
getIsolateAffinityTag: function ($name) {
|
|
return init.getIsolateTag($name);
|
|
},
|
|
throwLateInitializationError: function ($name) {
|
|
return H.throwExpression(new H.LateError($name));
|
|
},
|
|
defineProperty: function (obj, property, value) {
|
|
Object.defineProperty(obj, property, {
|
|
value: value,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
},
|
|
lookupAndCacheInterceptor: function (obj) {
|
|
var interceptor, interceptorClass, altTag, mark, t1,
|
|
tag = H._asString($.getTagFunction.call$1(obj)),
|
|
record = $.dispatchRecordsForInstanceTags[tag];
|
|
if (record != null) {
|
|
Object.defineProperty(obj, init.dispatchPropertyName, {
|
|
value: record,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return record.i;
|
|
}
|
|
interceptor = $.interceptorsForUncacheableTags[tag];
|
|
if (interceptor != null)
|
|
return interceptor;
|
|
interceptorClass = init.interceptorsByTag[tag];
|
|
if (interceptorClass == null) {
|
|
altTag = H._asStringQ($.alternateTagFunction.call$2(obj, tag));
|
|
if (altTag != null) {
|
|
record = $.dispatchRecordsForInstanceTags[altTag];
|
|
if (record != null) {
|
|
Object.defineProperty(obj, init.dispatchPropertyName, {
|
|
value: record,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return record.i;
|
|
}
|
|
interceptor = $.interceptorsForUncacheableTags[altTag];
|
|
if (interceptor != null)
|
|
return interceptor;
|
|
interceptorClass = init.interceptorsByTag[altTag];
|
|
tag = altTag;
|
|
}
|
|
}
|
|
if (interceptorClass == null)
|
|
return null;
|
|
interceptor = interceptorClass.prototype;
|
|
mark = tag[0];
|
|
if (mark === "!") {
|
|
record = H.makeLeafDispatchRecord(interceptor);
|
|
$.dispatchRecordsForInstanceTags[tag] = record;
|
|
Object.defineProperty(obj, init.dispatchPropertyName, {
|
|
value: record,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return record.i;
|
|
}
|
|
if (mark === "~") {
|
|
$.interceptorsForUncacheableTags[tag] = interceptor;
|
|
return interceptor;
|
|
}
|
|
if (mark === "-") {
|
|
t1 = H.makeLeafDispatchRecord(interceptor);
|
|
Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {
|
|
value: t1,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return t1.i;
|
|
}
|
|
if (mark === "+")
|
|
return H.patchInteriorProto(obj, interceptor);
|
|
if (mark === "*")
|
|
throw H.wrapException(P.UnimplementedError$(tag));
|
|
if (init.leafTags[tag] === true) {
|
|
t1 = H.makeLeafDispatchRecord(interceptor);
|
|
Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {
|
|
value: t1,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return t1.i;
|
|
} else
|
|
return H.patchInteriorProto(obj, interceptor);
|
|
},
|
|
patchInteriorProto: function (obj, interceptor) {
|
|
var proto = Object.getPrototypeOf(obj);
|
|
Object.defineProperty(proto, init.dispatchPropertyName, {
|
|
value: J.makeDispatchRecord(interceptor, proto, null, null),
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return interceptor;
|
|
},
|
|
makeLeafDispatchRecord: function (interceptor) {
|
|
return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior);
|
|
},
|
|
makeDefaultDispatchRecord: function (tag, interceptorClass, proto) {
|
|
var interceptor = interceptorClass.prototype;
|
|
if (init.leafTags[tag] === true)
|
|
return H.makeLeafDispatchRecord(interceptor);
|
|
else
|
|
return J.makeDispatchRecord(interceptor, proto, null, null);
|
|
},
|
|
initNativeDispatch: function () {
|
|
if (true === $.initNativeDispatchFlag)
|
|
return;
|
|
$.initNativeDispatchFlag = true;
|
|
H.initNativeDispatchContinue();
|
|
},
|
|
initNativeDispatchContinue: function () {
|
|
var map, tags, fun, i, tag, proto, record, interceptorClass;
|
|
$.dispatchRecordsForInstanceTags = Object.create(null);
|
|
$.interceptorsForUncacheableTags = Object.create(null);
|
|
H.initHooks();
|
|
map = init.interceptorsByTag;
|
|
tags = Object.getOwnPropertyNames(map);
|
|
if (typeof window != "undefined") {
|
|
window;
|
|
fun = function () {};
|
|
for (i = 0; i < tags.length; ++i) {
|
|
tag = tags[i];
|
|
proto = $.prototypeForTagFunction.call$1(tag);
|
|
if (proto != null) {
|
|
record = H.makeDefaultDispatchRecord(tag, map[tag], proto);
|
|
if (record != null) {
|
|
Object.defineProperty(proto, init.dispatchPropertyName, {
|
|
value: record,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
fun.prototype = proto;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < tags.length; ++i) {
|
|
tag = tags[i];
|
|
if (/^[A-Za-z_]/.test(tag)) {
|
|
interceptorClass = map[tag];
|
|
map["!" + tag] = interceptorClass;
|
|
map["~" + tag] = interceptorClass;
|
|
map["-" + tag] = interceptorClass;
|
|
map["+" + tag] = interceptorClass;
|
|
map["*" + tag] = interceptorClass;
|
|
}
|
|
}
|
|
},
|
|
initHooks: function () {
|
|
var transformers, i, transformer, getTag, getUnknownTag, prototypeForTag,
|
|
hooks = C.C_JS_CONST0();
|
|
hooks = H.applyHooksTransformer(C.C_JS_CONST1, H.applyHooksTransformer(C.C_JS_CONST2, H.applyHooksTransformer(C.C_JS_CONST3, H.applyHooksTransformer(C.C_JS_CONST3, H.applyHooksTransformer(C.C_JS_CONST4, H.applyHooksTransformer(C.C_JS_CONST5, H.applyHooksTransformer(C.C_JS_CONST6(C.C_JS_CONST), hooks)))))));
|
|
if (typeof dartNativeDispatchHooksTransformer != "undefined") {
|
|
transformers = dartNativeDispatchHooksTransformer;
|
|
if (typeof transformers == "function")
|
|
transformers = [transformers];
|
|
if (transformers.constructor == Array)
|
|
for (i = 0; i < transformers.length; ++i) {
|
|
transformer = transformers[i];
|
|
if (typeof transformer == "function")
|
|
hooks = transformer(hooks) || hooks;
|
|
}
|
|
}
|
|
getTag = hooks.getTag;
|
|
getUnknownTag = hooks.getUnknownTag;
|
|
prototypeForTag = hooks.prototypeForTag;
|
|
$.getTagFunction = new H.initHooks_closure(getTag);
|
|
$.alternateTagFunction = new H.initHooks_closure0(getUnknownTag);
|
|
$.prototypeForTagFunction = new H.initHooks_closure1(prototypeForTag);
|
|
},
|
|
applyHooksTransformer: function (transformer, hooks) {
|
|
return transformer(hooks) || hooks;
|
|
},
|
|
quoteStringForRegExp: function (string) {
|
|
if (/[[\]{}()*+?.\\^$|]/.test(string))
|
|
return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
|
|
return string;
|
|
},
|
|
TypeErrorDecoder: function TypeErrorDecoder(t0, t1, t2, t3, t4, t5) {
|
|
var _ = this;
|
|
_._pattern = t0;
|
|
_._arguments = t1;
|
|
_._argumentsExpr = t2;
|
|
_._expr = t3;
|
|
_._method = t4;
|
|
_._receiver = t5;
|
|
},
|
|
NullError: function NullError(t0, t1) {
|
|
this.__js_helper$_message = t0;
|
|
this._method = t1;
|
|
},
|
|
JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) {
|
|
this.__js_helper$_message = t0;
|
|
this._method = t1;
|
|
this._receiver = t2;
|
|
},
|
|
UnknownJsTypeError: function UnknownJsTypeError(t0) {
|
|
this.__js_helper$_message = t0;
|
|
},
|
|
NullThrownFromJavaScriptException: function NullThrownFromJavaScriptException(t0) {
|
|
this._irritant = t0;
|
|
},
|
|
_StackTrace: function _StackTrace(t0) {
|
|
this._exception = t0;
|
|
this._trace = null;
|
|
},
|
|
Closure: function Closure() {},
|
|
TearOffClosure: function TearOffClosure() {},
|
|
StaticClosure: function StaticClosure() {},
|
|
BoundClosure: function BoundClosure(t0, t1, t2, t3) {
|
|
var _ = this;
|
|
_._self = t0;
|
|
_._target = t1;
|
|
_._receiver = t2;
|
|
_._name = t3;
|
|
},
|
|
RuntimeError: function RuntimeError(t0) {
|
|
this.message = t0;
|
|
},
|
|
JsLinkedHashMap: function JsLinkedHashMap(t0) {
|
|
var _ = this;
|
|
_.__js_helper$_length = 0;
|
|
_._last = _._first = _.__js_helper$_rest = _._nums = _._strings = null;
|
|
_._modifications = 0;
|
|
_.$ti = t0;
|
|
},
|
|
LinkedHashMapCell: function LinkedHashMapCell(t0, t1) {
|
|
this.hashMapCellKey = t0;
|
|
this.hashMapCellValue = t1;
|
|
this._next = null;
|
|
},
|
|
initHooks_closure: function initHooks_closure(t0) {
|
|
this.getTag = t0;
|
|
},
|
|
initHooks_closure0: function initHooks_closure0(t0) {
|
|
this.getUnknownTag = t0;
|
|
},
|
|
initHooks_closure1: function initHooks_closure1(t0) {
|
|
this.prototypeForTag = t0;
|
|
},
|
|
Rti__getQuestionFromStar: function (universe, rti) {
|
|
var question = rti._precomputed1;
|
|
return question == null ? rti._precomputed1 = H._Universe__lookupQuestionRti(universe, rti._primary, true) : question;
|
|
},
|
|
Rti__getFutureFromFutureOr: function (universe, rti) {
|
|
var future = rti._precomputed1;
|
|
return future == null ? rti._precomputed1 = H._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future;
|
|
},
|
|
Rti__isUnionOfFunctionType: function (rti) {
|
|
var kind = rti._kind;
|
|
if (kind === 6 || kind === 7 || kind === 8)
|
|
return H.Rti__isUnionOfFunctionType(rti._primary);
|
|
return kind === 11 || kind === 12;
|
|
},
|
|
Rti__getCanonicalRecipe: function (rti) {
|
|
return rti._canonicalRecipe;
|
|
},
|
|
findType: function (recipe) {
|
|
return H._Universe_eval(init.typeUniverse, recipe, false);
|
|
},
|
|
_substitute: function (universe, rti, typeArguments, depth) {
|
|
var baseType, substitutedBaseType, interfaceTypeArguments, substitutedInterfaceTypeArguments, base, substitutedBase, $arguments, substitutedArguments, returnType, substitutedReturnType, functionParameters, substitutedFunctionParameters, bounds, substitutedBounds, index, argument,
|
|
kind = rti._kind;
|
|
switch (kind) {
|
|
case 5:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
return rti;
|
|
case 6:
|
|
baseType = rti._primary;
|
|
substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return H._Universe__lookupStarRti(universe, substitutedBaseType, true);
|
|
case 7:
|
|
baseType = rti._primary;
|
|
substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return H._Universe__lookupQuestionRti(universe, substitutedBaseType, true);
|
|
case 8:
|
|
baseType = rti._primary;
|
|
substitutedBaseType = H._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return H._Universe__lookupFutureOrRti(universe, substitutedBaseType, true);
|
|
case 9:
|
|
interfaceTypeArguments = rti._rest;
|
|
substitutedInterfaceTypeArguments = H._substituteArray(universe, interfaceTypeArguments, typeArguments, depth);
|
|
if (substitutedInterfaceTypeArguments === interfaceTypeArguments)
|
|
return rti;
|
|
return H._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments);
|
|
case 10:
|
|
base = rti._primary;
|
|
substitutedBase = H._substitute(universe, base, typeArguments, depth);
|
|
$arguments = rti._rest;
|
|
substitutedArguments = H._substituteArray(universe, $arguments, typeArguments, depth);
|
|
if (substitutedBase === base && substitutedArguments === $arguments)
|
|
return rti;
|
|
return H._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments);
|
|
case 11:
|
|
returnType = rti._primary;
|
|
substitutedReturnType = H._substitute(universe, returnType, typeArguments, depth);
|
|
functionParameters = rti._rest;
|
|
substitutedFunctionParameters = H._substituteFunctionParameters(universe, functionParameters, typeArguments, depth);
|
|
if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters)
|
|
return rti;
|
|
return H._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters);
|
|
case 12:
|
|
bounds = rti._rest;
|
|
depth += bounds.length;
|
|
substitutedBounds = H._substituteArray(universe, bounds, typeArguments, depth);
|
|
base = rti._primary;
|
|
substitutedBase = H._substitute(universe, base, typeArguments, depth);
|
|
if (substitutedBounds === bounds && substitutedBase === base)
|
|
return rti;
|
|
return H._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true);
|
|
case 13:
|
|
index = rti._primary;
|
|
if (index < depth)
|
|
return rti;
|
|
argument = typeArguments[index - depth];
|
|
if (argument == null)
|
|
return rti;
|
|
return argument;
|
|
default:
|
|
throw H.wrapException(P.AssertionError$("Attempted to substitute unexpected RTI kind " + kind));
|
|
}
|
|
},
|
|
_substituteArray: function (universe, rtiArray, typeArguments, depth) {
|
|
var changed, i, rti, substitutedRti,
|
|
$length = rtiArray.length,
|
|
result = [];
|
|
for (changed = false, i = 0; i < $length; ++i) {
|
|
rti = rtiArray[i];
|
|
substitutedRti = H._substitute(universe, rti, typeArguments, depth);
|
|
if (substitutedRti !== rti)
|
|
changed = true;
|
|
result.push(substitutedRti);
|
|
}
|
|
return changed ? result : rtiArray;
|
|
},
|
|
_substituteNamed: function (universe, namedArray, typeArguments, depth) {
|
|
var changed, i, t1, t2, rti, substitutedRti,
|
|
$length = namedArray.length,
|
|
result = [];
|
|
for (changed = false, i = 0; i < $length; i += 3) {
|
|
t1 = namedArray[i];
|
|
t2 = namedArray[i + 1];
|
|
rti = namedArray[i + 2];
|
|
substitutedRti = H._substitute(universe, rti, typeArguments, depth);
|
|
if (substitutedRti !== rti)
|
|
changed = true;
|
|
result.push(t1);
|
|
result.push(t2);
|
|
result.push(substitutedRti);
|
|
}
|
|
return changed ? result : namedArray;
|
|
},
|
|
_substituteFunctionParameters: function (universe, functionParameters, typeArguments, depth) {
|
|
var result,
|
|
requiredPositional = functionParameters._requiredPositional,
|
|
substitutedRequiredPositional = H._substituteArray(universe, requiredPositional, typeArguments, depth),
|
|
optionalPositional = functionParameters._optionalPositional,
|
|
substitutedOptionalPositional = H._substituteArray(universe, optionalPositional, typeArguments, depth),
|
|
named = functionParameters._named,
|
|
substitutedNamed = H._substituteNamed(universe, named, typeArguments, depth);
|
|
if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named)
|
|
return functionParameters;
|
|
result = new H._FunctionParameters();
|
|
result._requiredPositional = substitutedRequiredPositional;
|
|
result._optionalPositional = substitutedOptionalPositional;
|
|
result._named = substitutedNamed;
|
|
return result;
|
|
},
|
|
setRuntimeTypeInfo: function (target, rti) {
|
|
target[init.arrayRti] = rti;
|
|
return target;
|
|
},
|
|
closureFunctionType: function (closure) {
|
|
var signature = closure.$signature;
|
|
if (signature != null) {
|
|
if (typeof signature == "number")
|
|
return H.getTypeFromTypesTable(signature);
|
|
return closure.$signature();
|
|
}
|
|
return null;
|
|
},
|
|
instanceOrFunctionType: function (object, testRti) {
|
|
var rti;
|
|
if (H.Rti__isUnionOfFunctionType(testRti))
|
|
if (object instanceof H.Closure) {
|
|
rti = H.closureFunctionType(object);
|
|
if (rti != null)
|
|
return rti;
|
|
}
|
|
return H.instanceType(object);
|
|
},
|
|
instanceType: function (object) {
|
|
var rti;
|
|
if (object instanceof P.Object) {
|
|
rti = object.$ti;
|
|
return rti != null ? rti : H._instanceTypeFromConstructor(object);
|
|
}
|
|
if (Array.isArray(object))
|
|
return H._arrayInstanceType(object);
|
|
return H._instanceTypeFromConstructor(J.getInterceptor$(object));
|
|
},
|
|
_arrayInstanceType: function (object) {
|
|
var rti = object[init.arrayRti],
|
|
defaultRti = type$.JSArray_dynamic;
|
|
if (rti == null)
|
|
return defaultRti;
|
|
if (rti.constructor !== defaultRti.constructor)
|
|
return defaultRti;
|
|
return rti;
|
|
},
|
|
_instanceType: function (object) {
|
|
var rti = object.$ti;
|
|
return rti != null ? rti : H._instanceTypeFromConstructor(object);
|
|
},
|
|
_instanceTypeFromConstructor: function (instance) {
|
|
var $constructor = instance.constructor,
|
|
probe = $constructor.$ccache;
|
|
if (probe != null)
|
|
return probe;
|
|
return H._instanceTypeFromConstructorMiss(instance, $constructor);
|
|
},
|
|
_instanceTypeFromConstructorMiss: function (instance, $constructor) {
|
|
var effectiveConstructor = instance instanceof H.Closure ? instance.__proto__.__proto__.constructor : $constructor,
|
|
rti = H._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name);
|
|
$constructor.$ccache = rti;
|
|
return rti;
|
|
},
|
|
getTypeFromTypesTable: function (index) {
|
|
var table, type, rti;
|
|
H._asInt(index);
|
|
table = init.types;
|
|
type = table[index];
|
|
if (typeof type == "string") {
|
|
rti = H._Universe_eval(init.typeUniverse, type, false);
|
|
table[index] = rti;
|
|
return rti;
|
|
}
|
|
return type;
|
|
},
|
|
_installSpecializedIsTest: function (object) {
|
|
var t1, unstarred, isFn, testRti = this;
|
|
if (testRti === type$.Object)
|
|
return H._finishIsFn(testRti, object, H._isObject);
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return H._finishIsFn(testRti, object, H._isTop);
|
|
t1 = testRti._kind;
|
|
unstarred = t1 === 6 ? testRti._primary : testRti;
|
|
if (unstarred === type$.int)
|
|
isFn = H._isInt;
|
|
else if (unstarred === type$.double || unstarred === type$.num)
|
|
isFn = H._isNum;
|
|
else if (unstarred === type$.String)
|
|
isFn = H._isString;
|
|
else
|
|
isFn = unstarred === type$.bool ? H._isBool : null;
|
|
if (isFn != null)
|
|
return H._finishIsFn(testRti, object, isFn);
|
|
if (unstarred._kind === 9) {
|
|
t1 = unstarred._primary;
|
|
if (unstarred._rest.every(H.isTopType)) {
|
|
testRti._specializedTestResource = "$is" + t1;
|
|
return H._finishIsFn(testRti, object, H._isTestViaProperty);
|
|
}
|
|
} else if (t1 === 7)
|
|
return H._finishIsFn(testRti, object, H._generalNullableIsTestImplementation);
|
|
return H._finishIsFn(testRti, object, H._generalIsTestImplementation);
|
|
},
|
|
_finishIsFn: function (testRti, object, isFn) {
|
|
testRti._is = isFn;
|
|
return testRti._is(object);
|
|
},
|
|
_installSpecializedAsCheck: function (object) {
|
|
var t1, testRti = this,
|
|
asFn = H._generalAsCheckImplementation;
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
asFn = H._asTop;
|
|
else if (testRti === type$.Object)
|
|
asFn = H._asObject;
|
|
else {
|
|
t1 = H.isNullable(testRti);
|
|
if (t1)
|
|
asFn = H._generalNullableAsCheckImplementation;
|
|
}
|
|
testRti._as = asFn;
|
|
return testRti._as(object);
|
|
},
|
|
_nullIs: function (testRti) {
|
|
var t1,
|
|
kind = testRti._kind;
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
if (!(testRti === type$.legacy_Never))
|
|
if (kind !== 7)
|
|
t1 = kind === 8 && H._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
return t1;
|
|
},
|
|
_generalIsTestImplementation: function (object) {
|
|
var testRti = this;
|
|
if (object == null)
|
|
return H._nullIs(testRti);
|
|
return H._isSubtype(init.typeUniverse, H.instanceOrFunctionType(object, testRti), null, testRti, null);
|
|
},
|
|
_generalNullableIsTestImplementation: function (object) {
|
|
if (object == null)
|
|
return true;
|
|
return this._primary._is(object);
|
|
},
|
|
_isTestViaProperty: function (object) {
|
|
var tag, testRti = this;
|
|
if (object == null)
|
|
return H._nullIs(testRti);
|
|
tag = testRti._specializedTestResource;
|
|
if (object instanceof P.Object)
|
|
return !!object[tag];
|
|
return !!J.getInterceptor$(object)[tag];
|
|
},
|
|
_generalAsCheckImplementation: function (object) {
|
|
var t1, testRti = this;
|
|
if (object == null) {
|
|
t1 = H.isNullable(testRti);
|
|
if (t1)
|
|
return object;
|
|
} else if (testRti._is(object))
|
|
return object;
|
|
H._failedAsCheck(object, testRti);
|
|
},
|
|
_generalNullableAsCheckImplementation: function (object) {
|
|
var testRti = this;
|
|
if (object == null)
|
|
return object;
|
|
else if (testRti._is(object))
|
|
return object;
|
|
H._failedAsCheck(object, testRti);
|
|
},
|
|
_failedAsCheck: function (object, testRti) {
|
|
throw H.wrapException(H._TypeError$fromMessage(H._Error_compose(object, H.instanceOrFunctionType(object, testRti), H._rtiToString(testRti, null))));
|
|
},
|
|
checkTypeBound: function (type, bound, variable, methodName) {
|
|
var _null = null;
|
|
if (H._isSubtype(init.typeUniverse, type, _null, bound, _null))
|
|
return type;
|
|
throw H.wrapException(H._TypeError$fromMessage("The type argument '" + H._rtiToString(type, _null) + "' is not a subtype of the type variable bound '" + H._rtiToString(bound, _null) + "' of type variable '" + variable + "' in '" + methodName + "'."));
|
|
},
|
|
_Error_compose: function (object, objectRti, checkedTypeDescription) {
|
|
var objectDescription = P.Error_safeToString(object),
|
|
objectTypeDescription = H._rtiToString(objectRti == null ? H.instanceType(object) : objectRti, null);
|
|
return objectDescription + ": type '" + objectTypeDescription + "' is not a subtype of type '" + checkedTypeDescription + "'";
|
|
},
|
|
_TypeError$fromMessage: function (message) {
|
|
return new H._TypeError("TypeError: " + message);
|
|
},
|
|
_TypeError__TypeError$forType: function (object, type) {
|
|
return new H._TypeError("TypeError: " + H._Error_compose(object, null, type));
|
|
},
|
|
_isObject: function (object) {
|
|
return object != null;
|
|
},
|
|
_asObject: function (object) {
|
|
if (object != null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "Object"));
|
|
},
|
|
_isTop: function (object) {
|
|
return true;
|
|
},
|
|
_asTop: function (object) {
|
|
return object;
|
|
},
|
|
_isBool: function (object) {
|
|
return true === object || false === object;
|
|
},
|
|
_asBool: function (object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "bool"));
|
|
},
|
|
_asBoolS: function (object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "bool"));
|
|
},
|
|
_asBoolQ: function (object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "bool?"));
|
|
},
|
|
_asDouble: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "double"));
|
|
},
|
|
_asDoubleS: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "double"));
|
|
},
|
|
_asDoubleQ: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "double?"));
|
|
},
|
|
_isInt: function (object) {
|
|
return typeof object == "number" && Math.floor(object) === object;
|
|
},
|
|
_asInt: function (object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "int"));
|
|
},
|
|
_asIntS: function (object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "int"));
|
|
},
|
|
_asIntQ: function (object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "int?"));
|
|
},
|
|
_isNum: function (object) {
|
|
return typeof object == "number";
|
|
},
|
|
_asNum: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "num"));
|
|
},
|
|
_asNumS: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "num"));
|
|
},
|
|
_asNumQ: function (object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "num?"));
|
|
},
|
|
_isString: function (object) {
|
|
return typeof object == "string";
|
|
},
|
|
_asString: function (object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "String"));
|
|
},
|
|
_asStringS: function (object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "String"));
|
|
},
|
|
_asStringQ: function (object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw H.wrapException(H._TypeError__TypeError$forType(object, "String?"));
|
|
},
|
|
_rtiArrayToString: function (array, genericContext) {
|
|
var s, sep, i;
|
|
for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ")
|
|
s += sep + H._rtiToString(array[i], genericContext);
|
|
return s;
|
|
},
|
|
_functionRtiToString: function (functionType, genericContext, bounds) {
|
|
var boundsLength, outerContextLength, offset, i, t1, t2, typeParametersText, typeSep, t3, t4, boundRti, kind, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ";
|
|
if (bounds != null) {
|
|
boundsLength = bounds.length;
|
|
if (genericContext == null) {
|
|
genericContext = H.setRuntimeTypeInfo([], type$.JSArray_String);
|
|
outerContextLength = null;
|
|
} else
|
|
outerContextLength = genericContext.length;
|
|
offset = genericContext.length;
|
|
for (i = boundsLength; i > 0; --i)
|
|
C.JSArray_methods.add$1(genericContext, "T" + (offset + i));
|
|
for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) {
|
|
typeParametersText += typeSep;
|
|
t3 = genericContext.length;
|
|
t4 = t3 - 1 - i;
|
|
if (t4 < 0)
|
|
return H.ioore(genericContext, t4);
|
|
typeParametersText = C.JSString_methods.$add(typeParametersText, genericContext[t4]);
|
|
boundRti = bounds[i];
|
|
kind = boundRti._kind;
|
|
if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1))
|
|
if (!(boundRti === t2))
|
|
t3 = false;
|
|
else
|
|
t3 = true;
|
|
else
|
|
t3 = true;
|
|
if (!t3)
|
|
typeParametersText += " extends " + H._rtiToString(boundRti, genericContext);
|
|
}
|
|
typeParametersText += ">";
|
|
} else {
|
|
typeParametersText = "";
|
|
outerContextLength = null;
|
|
}
|
|
t1 = functionType._primary;
|
|
parameters = functionType._rest;
|
|
requiredPositional = parameters._requiredPositional;
|
|
requiredPositionalLength = requiredPositional.length;
|
|
optionalPositional = parameters._optionalPositional;
|
|
optionalPositionalLength = optionalPositional.length;
|
|
named = parameters._named;
|
|
namedLength = named.length;
|
|
returnTypeText = H._rtiToString(t1, genericContext);
|
|
for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_)
|
|
argumentsText += sep + H._rtiToString(requiredPositional[i], genericContext);
|
|
if (optionalPositionalLength > 0) {
|
|
argumentsText += sep + "[";
|
|
for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_)
|
|
argumentsText += sep + H._rtiToString(optionalPositional[i], genericContext);
|
|
argumentsText += "]";
|
|
}
|
|
if (namedLength > 0) {
|
|
argumentsText += sep + "{";
|
|
for (sep = "", i = 0; i < namedLength; i += 3, sep = _s2_) {
|
|
argumentsText += sep;
|
|
if (named[i + 1])
|
|
argumentsText += "required ";
|
|
argumentsText += H._rtiToString(named[i + 2], genericContext) + " " + named[i];
|
|
}
|
|
argumentsText += "}";
|
|
}
|
|
if (outerContextLength != null) {
|
|
genericContext.toString;
|
|
genericContext.length = outerContextLength;
|
|
}
|
|
return typeParametersText + "(" + argumentsText + ") => " + returnTypeText;
|
|
},
|
|
_rtiToString: function (rti, genericContext) {
|
|
var s, questionArgument, argumentKind, $name, $arguments, t1, t2,
|
|
kind = rti._kind;
|
|
if (kind === 5)
|
|
return "erased";
|
|
if (kind === 2)
|
|
return "dynamic";
|
|
if (kind === 3)
|
|
return "void";
|
|
if (kind === 1)
|
|
return "Never";
|
|
if (kind === 4)
|
|
return "any";
|
|
if (kind === 6) {
|
|
s = H._rtiToString(rti._primary, genericContext);
|
|
return s;
|
|
}
|
|
if (kind === 7) {
|
|
questionArgument = rti._primary;
|
|
s = H._rtiToString(questionArgument, genericContext);
|
|
argumentKind = questionArgument._kind;
|
|
return (argumentKind === 11 || argumentKind === 12 ? "(" + s + ")" : s) + "?";
|
|
}
|
|
if (kind === 8)
|
|
return "FutureOr<" + H._rtiToString(rti._primary, genericContext) + ">";
|
|
if (kind === 9) {
|
|
$name = H._unminifyOrTag(rti._primary);
|
|
$arguments = rti._rest;
|
|
return $arguments.length !== 0 ? $name + ("<" + H._rtiArrayToString($arguments, genericContext) + ">") : $name;
|
|
}
|
|
if (kind === 11)
|
|
return H._functionRtiToString(rti, genericContext, null);
|
|
if (kind === 12)
|
|
return H._functionRtiToString(rti._primary, genericContext, rti._rest);
|
|
if (kind === 13) {
|
|
t1 = rti._primary;
|
|
t2 = genericContext.length;
|
|
t1 = t2 - 1 - t1;
|
|
if (t1 < 0 || t1 >= t2)
|
|
return H.ioore(genericContext, t1);
|
|
return genericContext[t1];
|
|
}
|
|
return "?";
|
|
},
|
|
_unminifyOrTag: function (rawClassName) {
|
|
var preserved = H.unmangleGlobalNameIfPreservedAnyways(rawClassName);
|
|
if (preserved != null)
|
|
return preserved;
|
|
return rawClassName;
|
|
},
|
|
_Universe_findRule: function (universe, targetType) {
|
|
var rule = universe.tR[targetType];
|
|
for (; typeof rule == "string";)
|
|
rule = universe.tR[rule];
|
|
return rule;
|
|
},
|
|
_Universe_findErasedType: function (universe, cls) {
|
|
var $length, erased, $arguments, i, $interface,
|
|
t1 = universe.eT,
|
|
probe = t1[cls];
|
|
if (probe == null)
|
|
return H._Universe_eval(universe, cls, false);
|
|
else if (typeof probe == "number") {
|
|
$length = probe;
|
|
erased = H._Universe__lookupTerminalRti(universe, 5, "#");
|
|
$arguments = [];
|
|
for (i = 0; i < $length; ++i)
|
|
$arguments.push(erased);
|
|
$interface = H._Universe__lookupInterfaceRti(universe, cls, $arguments);
|
|
t1[cls] = $interface;
|
|
return $interface;
|
|
} else
|
|
return probe;
|
|
},
|
|
_Universe_addRules: function (universe, rules) {
|
|
return H._Utils_objectAssign(universe.tR, rules);
|
|
},
|
|
_Universe_addErasedTypes: function (universe, types) {
|
|
return H._Utils_objectAssign(universe.eT, types);
|
|
},
|
|
_Universe_eval: function (universe, recipe, normalize) {
|
|
var rti,
|
|
t1 = universe.eC,
|
|
probe = t1.get(recipe);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = H._Parser_parse(H._Parser_create(universe, null, recipe, normalize));
|
|
t1.set(recipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe_evalInEnvironment: function (universe, environment, recipe) {
|
|
var probe, rti,
|
|
cache = environment._evalCache;
|
|
if (cache == null)
|
|
cache = environment._evalCache = new Map();
|
|
probe = cache.get(recipe);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = H._Parser_parse(H._Parser_create(universe, environment, recipe, true));
|
|
cache.set(recipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe_bind: function (universe, environment, argumentsRti) {
|
|
var argumentsRecipe, probe, rti,
|
|
cache = environment._bindCache;
|
|
if (cache == null)
|
|
cache = environment._bindCache = new Map();
|
|
argumentsRecipe = argumentsRti._canonicalRecipe;
|
|
probe = cache.get(argumentsRecipe);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = H._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]);
|
|
cache.set(argumentsRecipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe__installTypeTests: function (universe, rti) {
|
|
rti._as = H._installSpecializedAsCheck;
|
|
rti._is = H._installSpecializedIsTest;
|
|
return rti;
|
|
},
|
|
_Universe__lookupTerminalRti: function (universe, kind, key) {
|
|
var rti, t1,
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = kind;
|
|
rti._canonicalRecipe = key;
|
|
t1 = H._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupStarRti: function (universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "*",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = H._Universe__createStarRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createStarRti: function (universe, baseType, key, normalize) {
|
|
var baseKind, t1, rti;
|
|
if (normalize) {
|
|
baseKind = baseType._kind;
|
|
if (!H.isStrongTopType(baseType))
|
|
t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return baseType;
|
|
}
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 6;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return H._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupQuestionRti: function (universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "?",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = H._Universe__createQuestionRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createQuestionRti: function (universe, baseType, key, normalize) {
|
|
var baseKind, t1, starArgument, rti;
|
|
if (normalize) {
|
|
baseKind = baseType._kind;
|
|
if (!H.isStrongTopType(baseType))
|
|
if (!(baseType === type$.Null || baseType === type$.JSNull))
|
|
if (baseKind !== 7)
|
|
t1 = baseKind === 8 && H.isNullable(baseType._primary);
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return baseType;
|
|
else if (baseKind === 1 || baseType === type$.legacy_Never)
|
|
return type$.Null;
|
|
else if (baseKind === 6) {
|
|
starArgument = baseType._primary;
|
|
if (starArgument._kind === 8 && H.isNullable(starArgument._primary))
|
|
return starArgument;
|
|
else
|
|
return H.Rti__getQuestionFromStar(universe, baseType);
|
|
}
|
|
}
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 7;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return H._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupFutureOrRti: function (universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "/",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = H._Universe__createFutureOrRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createFutureOrRti: function (universe, baseType, key, normalize) {
|
|
var t1, t2, rti;
|
|
if (normalize) {
|
|
t1 = baseType._kind;
|
|
if (!H.isStrongTopType(baseType))
|
|
if (!(baseType === type$.legacy_Object))
|
|
t2 = false;
|
|
else
|
|
t2 = true;
|
|
else
|
|
t2 = true;
|
|
if (t2 || baseType === type$.Object)
|
|
return baseType;
|
|
else if (t1 === 1)
|
|
return H._Universe__lookupInterfaceRti(universe, "Future", [baseType]);
|
|
else if (baseType === type$.Null || baseType === type$.JSNull)
|
|
return type$.nullable_Future_Null;
|
|
}
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 8;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return H._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupGenericFunctionParameterRti: function (universe, index) {
|
|
var rti, t1,
|
|
key = "" + index + "^",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 13;
|
|
rti._primary = index;
|
|
rti._canonicalRecipe = key;
|
|
t1 = H._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__canonicalRecipeJoin: function ($arguments) {
|
|
var s, sep, i,
|
|
$length = $arguments.length;
|
|
for (s = "", sep = "", i = 0; i < $length; ++i, sep = ",")
|
|
s += sep + $arguments[i]._canonicalRecipe;
|
|
return s;
|
|
},
|
|
_Universe__canonicalRecipeJoinNamed: function ($arguments) {
|
|
var s, sep, i, t1, nameSep, s0,
|
|
$length = $arguments.length;
|
|
for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") {
|
|
t1 = $arguments[i];
|
|
nameSep = $arguments[i + 1] ? "!" : ":";
|
|
s0 = $arguments[i + 2]._canonicalRecipe;
|
|
s += sep + t1 + nameSep + s0;
|
|
}
|
|
return s;
|
|
},
|
|
_Universe__lookupInterfaceRti: function (universe, $name, $arguments) {
|
|
var probe, rti, t1,
|
|
s = $name;
|
|
if ($arguments.length !== 0)
|
|
s += "<" + H._Universe__canonicalRecipeJoin($arguments) + ">";
|
|
probe = universe.eC.get(s);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 9;
|
|
rti._primary = $name;
|
|
rti._rest = $arguments;
|
|
if ($arguments.length > 0)
|
|
rti._precomputed1 = $arguments[0];
|
|
rti._canonicalRecipe = s;
|
|
t1 = H._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(s, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupBindingRti: function (universe, base, $arguments) {
|
|
var newBase, newArguments, key, probe, rti, t1;
|
|
if (base._kind === 10) {
|
|
newBase = base._primary;
|
|
newArguments = base._rest.concat($arguments);
|
|
} else {
|
|
newArguments = $arguments;
|
|
newBase = base;
|
|
}
|
|
key = newBase._canonicalRecipe + (";<" + H._Universe__canonicalRecipeJoin(newArguments) + ">");
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 10;
|
|
rti._primary = newBase;
|
|
rti._rest = newArguments;
|
|
rti._canonicalRecipe = key;
|
|
t1 = H._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupFunctionRti: function (universe, returnType, parameters) {
|
|
var sep, t1, key, probe, rti,
|
|
s = returnType._canonicalRecipe,
|
|
requiredPositional = parameters._requiredPositional,
|
|
requiredPositionalLength = requiredPositional.length,
|
|
optionalPositional = parameters._optionalPositional,
|
|
optionalPositionalLength = optionalPositional.length,
|
|
named = parameters._named,
|
|
namedLength = named.length,
|
|
recipe = "(" + H._Universe__canonicalRecipeJoin(requiredPositional);
|
|
if (optionalPositionalLength > 0) {
|
|
sep = requiredPositionalLength > 0 ? "," : "";
|
|
t1 = H._Universe__canonicalRecipeJoin(optionalPositional);
|
|
recipe += sep + "[" + t1 + "]";
|
|
}
|
|
if (namedLength > 0) {
|
|
sep = requiredPositionalLength > 0 ? "," : "";
|
|
t1 = H._Universe__canonicalRecipeJoinNamed(named);
|
|
recipe += sep + "{" + t1 + "}";
|
|
}
|
|
key = s + (recipe + ")");
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 11;
|
|
rti._primary = returnType;
|
|
rti._rest = parameters;
|
|
rti._canonicalRecipe = key;
|
|
t1 = H._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupGenericFunctionRti: function (universe, baseFunctionType, bounds, normalize) {
|
|
var t1,
|
|
key = baseFunctionType._canonicalRecipe + ("<" + H._Universe__canonicalRecipeJoin(bounds) + ">"),
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = H._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createGenericFunctionRti: function (universe, baseFunctionType, bounds, key, normalize) {
|
|
var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti;
|
|
if (normalize) {
|
|
$length = bounds.length;
|
|
typeArguments = new Array($length);
|
|
for (count = 0, i = 0; i < $length; ++i) {
|
|
bound = bounds[i];
|
|
if (bound._kind === 1) {
|
|
typeArguments[i] = bound;
|
|
++count;
|
|
}
|
|
}
|
|
if (count > 0) {
|
|
substitutedBase = H._substitute(universe, baseFunctionType, typeArguments, 0);
|
|
substitutedBounds = H._substituteArray(universe, bounds, typeArguments, 0);
|
|
return H._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds);
|
|
}
|
|
}
|
|
rti = new H.Rti(null, null);
|
|
rti._kind = 12;
|
|
rti._primary = baseFunctionType;
|
|
rti._rest = bounds;
|
|
rti._canonicalRecipe = key;
|
|
return H._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Parser_create: function (universe, environment, recipe, normalize) {
|
|
return {
|
|
u: universe,
|
|
e: environment,
|
|
r: recipe,
|
|
s: [],
|
|
p: 0,
|
|
n: normalize
|
|
};
|
|
},
|
|
_Parser_parse: function (parser) {
|
|
var t2, i, ch, t3, array, head, base, parameters, optionalPositional, named, item,
|
|
source = parser.r,
|
|
t1 = parser.s;
|
|
for (t2 = source.length, i = 0; i < t2;) {
|
|
ch = source.charCodeAt(i);
|
|
if (ch >= 48 && ch <= 57)
|
|
i = H._Parser_handleDigit(i + 1, ch, source, t1);
|
|
else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36)
|
|
i = H._Parser_handleIdentifier(parser, i, source, t1, false);
|
|
else if (ch === 46)
|
|
i = H._Parser_handleIdentifier(parser, i, source, t1, true);
|
|
else {
|
|
++i;
|
|
switch (ch) {
|
|
case 44:
|
|
break;
|
|
case 58:
|
|
t1.push(false);
|
|
break;
|
|
case 33:
|
|
t1.push(true);
|
|
break;
|
|
case 59:
|
|
t1.push(H._Parser_toType(parser.u, parser.e, t1.pop()));
|
|
break;
|
|
case 94:
|
|
t1.push(H._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop()));
|
|
break;
|
|
case 35:
|
|
t1.push(H._Universe__lookupTerminalRti(parser.u, 5, "#"));
|
|
break;
|
|
case 64:
|
|
t1.push(H._Universe__lookupTerminalRti(parser.u, 2, "@"));
|
|
break;
|
|
case 126:
|
|
t1.push(H._Universe__lookupTerminalRti(parser.u, 3, "~"));
|
|
break;
|
|
case 60:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 62:
|
|
t3 = parser.u;
|
|
array = t1.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
head = t1.pop();
|
|
if (typeof head == "string")
|
|
t1.push(H._Universe__lookupInterfaceRti(t3, head, array));
|
|
else {
|
|
base = H._Parser_toType(t3, parser.e, head);
|
|
switch (base._kind) {
|
|
case 11:
|
|
t1.push(H._Universe__lookupGenericFunctionRti(t3, base, array, parser.n));
|
|
break;
|
|
default:
|
|
t1.push(H._Universe__lookupBindingRti(t3, base, array));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 38:
|
|
H._Parser_handleExtendedOperations(parser, t1);
|
|
break;
|
|
case 42:
|
|
t3 = parser.u;
|
|
t1.push(H._Universe__lookupStarRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 63:
|
|
t3 = parser.u;
|
|
t1.push(H._Universe__lookupQuestionRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 47:
|
|
t3 = parser.u;
|
|
t1.push(H._Universe__lookupFutureOrRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 40:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 41:
|
|
t3 = parser.u;
|
|
parameters = new H._FunctionParameters();
|
|
optionalPositional = t3.sEA;
|
|
named = t3.sEA;
|
|
head = t1.pop();
|
|
if (typeof head == "number")
|
|
switch (head) {
|
|
case -1:
|
|
optionalPositional = t1.pop();
|
|
break;
|
|
case -2:
|
|
named = t1.pop();
|
|
break;
|
|
default:
|
|
t1.push(head);
|
|
break;
|
|
}
|
|
else
|
|
t1.push(head);
|
|
array = t1.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
parameters._requiredPositional = array;
|
|
parameters._optionalPositional = optionalPositional;
|
|
parameters._named = named;
|
|
t1.push(H._Universe__lookupFunctionRti(t3, H._Parser_toType(t3, parser.e, t1.pop()), parameters));
|
|
break;
|
|
case 91:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 93:
|
|
array = t1.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
t1.push(array);
|
|
t1.push(-1);
|
|
break;
|
|
case 123:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 125:
|
|
array = t1.splice(parser.p);
|
|
H._Parser_toTypesNamed(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
t1.push(array);
|
|
t1.push(-2);
|
|
break;
|
|
default:
|
|
throw "Bad character " + ch;
|
|
}
|
|
}
|
|
}
|
|
item = t1.pop();
|
|
return H._Parser_toType(parser.u, parser.e, item);
|
|
},
|
|
_Parser_handleDigit: function (i, digit, source, stack) {
|
|
var t1, ch,
|
|
value = digit - 48;
|
|
for (t1 = source.length; i < t1; ++i) {
|
|
ch = source.charCodeAt(i);
|
|
if (!(ch >= 48 && ch <= 57))
|
|
break;
|
|
value = value * 10 + (ch - 48);
|
|
}
|
|
stack.push(value);
|
|
return i;
|
|
},
|
|
_Parser_handleIdentifier: function (parser, start, source, stack, hasPeriod) {
|
|
var t1, ch, t2, string, environment, recipe,
|
|
i = start + 1;
|
|
for (t1 = source.length; i < t1; ++i) {
|
|
ch = source.charCodeAt(i);
|
|
if (ch === 46) {
|
|
if (hasPeriod)
|
|
break;
|
|
hasPeriod = true;
|
|
} else {
|
|
if (!((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36))
|
|
t2 = ch >= 48 && ch <= 57;
|
|
else
|
|
t2 = true;
|
|
if (!t2)
|
|
break;
|
|
}
|
|
}
|
|
string = source.substring(start, i);
|
|
if (hasPeriod) {
|
|
t1 = parser.u;
|
|
environment = parser.e;
|
|
if (environment._kind === 10)
|
|
environment = environment._primary;
|
|
recipe = H._Universe_findRule(t1, environment._primary)[string];
|
|
if (recipe == null)
|
|
H.throwExpression('No "' + string + '" in "' + H.Rti__getCanonicalRecipe(environment) + '"');
|
|
stack.push(H._Universe_evalInEnvironment(t1, environment, recipe));
|
|
} else
|
|
stack.push(string);
|
|
return i;
|
|
},
|
|
_Parser_handleExtendedOperations: function (parser, stack) {
|
|
var $top = stack.pop();
|
|
if (0 === $top) {
|
|
stack.push(H._Universe__lookupTerminalRti(parser.u, 1, "0&"));
|
|
return;
|
|
}
|
|
if (1 === $top) {
|
|
stack.push(H._Universe__lookupTerminalRti(parser.u, 4, "1&"));
|
|
return;
|
|
}
|
|
throw H.wrapException(P.AssertionError$("Unexpected extended operation " + H.S($top)));
|
|
},
|
|
_Parser_toType: function (universe, environment, item) {
|
|
if (typeof item == "string")
|
|
return H._Universe__lookupInterfaceRti(universe, item, universe.sEA);
|
|
else if (typeof item == "number")
|
|
return H._Parser_indexToType(universe, environment, item);
|
|
else
|
|
return item;
|
|
},
|
|
_Parser_toTypes: function (universe, environment, items) {
|
|
var i,
|
|
$length = items.length;
|
|
for (i = 0; i < $length; ++i)
|
|
items[i] = H._Parser_toType(universe, environment, items[i]);
|
|
},
|
|
_Parser_toTypesNamed: function (universe, environment, items) {
|
|
var i,
|
|
$length = items.length;
|
|
for (i = 2; i < $length; i += 3)
|
|
items[i] = H._Parser_toType(universe, environment, items[i]);
|
|
},
|
|
_Parser_indexToType: function (universe, environment, index) {
|
|
var typeArguments, len,
|
|
kind = environment._kind;
|
|
if (kind === 10) {
|
|
if (index === 0)
|
|
return environment._primary;
|
|
typeArguments = environment._rest;
|
|
len = typeArguments.length;
|
|
if (index <= len)
|
|
return typeArguments[index - 1];
|
|
index -= len;
|
|
environment = environment._primary;
|
|
kind = environment._kind;
|
|
} else if (index === 0)
|
|
return environment;
|
|
if (kind !== 9)
|
|
throw H.wrapException(P.AssertionError$("Indexed base must be an interface type"));
|
|
typeArguments = environment._rest;
|
|
if (index <= typeArguments.length)
|
|
return typeArguments[index - 1];
|
|
throw H.wrapException(P.AssertionError$("Bad index " + index + " for " + environment.toString$0(0)));
|
|
},
|
|
_isSubtype: function (universe, s, sEnv, t, tEnv) {
|
|
var t1, sKind, leftTypeVariable, tKind, sBounds, tBounds, sLength, i, sBound, tBound;
|
|
if (s === t)
|
|
return true;
|
|
if (!H.isStrongTopType(t))
|
|
if (!(t === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return true;
|
|
sKind = s._kind;
|
|
if (sKind === 4)
|
|
return true;
|
|
if (H.isStrongTopType(s))
|
|
return false;
|
|
if (s._kind !== 1)
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return true;
|
|
leftTypeVariable = sKind === 13;
|
|
if (leftTypeVariable)
|
|
if (H._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv))
|
|
return true;
|
|
tKind = t._kind;
|
|
t1 = s === type$.Null || s === type$.JSNull;
|
|
if (t1) {
|
|
if (tKind === 8)
|
|
return H._isSubtype(universe, s, sEnv, t._primary, tEnv);
|
|
return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6;
|
|
}
|
|
if (t === type$.Object) {
|
|
if (sKind === 8)
|
|
return H._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
if (sKind === 6)
|
|
return H._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
return sKind !== 7;
|
|
}
|
|
if (sKind === 6)
|
|
return H._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
if (tKind === 6) {
|
|
t1 = H.Rti__getQuestionFromStar(universe, t);
|
|
return H._isSubtype(universe, s, sEnv, t1, tEnv);
|
|
}
|
|
if (sKind === 8) {
|
|
if (!H._isSubtype(universe, s._primary, sEnv, t, tEnv))
|
|
return false;
|
|
return H._isSubtype(universe, H.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv);
|
|
}
|
|
if (sKind === 7) {
|
|
t1 = H._isSubtype(universe, type$.Null, sEnv, t, tEnv);
|
|
return t1 && H._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
}
|
|
if (tKind === 8) {
|
|
if (H._isSubtype(universe, s, sEnv, t._primary, tEnv))
|
|
return true;
|
|
return H._isSubtype(universe, s, sEnv, H.Rti__getFutureFromFutureOr(universe, t), tEnv);
|
|
}
|
|
if (tKind === 7) {
|
|
t1 = H._isSubtype(universe, s, sEnv, type$.Null, tEnv);
|
|
return t1 || H._isSubtype(universe, s, sEnv, t._primary, tEnv);
|
|
}
|
|
if (leftTypeVariable)
|
|
return false;
|
|
t1 = sKind !== 11;
|
|
if ((!t1 || sKind === 12) && t === type$.Function)
|
|
return true;
|
|
if (tKind === 12) {
|
|
if (s === type$.JavaScriptFunction)
|
|
return true;
|
|
if (sKind !== 12)
|
|
return false;
|
|
sBounds = s._rest;
|
|
tBounds = t._rest;
|
|
sLength = sBounds.length;
|
|
if (sLength !== tBounds.length)
|
|
return false;
|
|
sEnv = sEnv == null ? sBounds : sBounds.concat(sEnv);
|
|
tEnv = tEnv == null ? tBounds : tBounds.concat(tEnv);
|
|
for (i = 0; i < sLength; ++i) {
|
|
sBound = sBounds[i];
|
|
tBound = tBounds[i];
|
|
if (!H._isSubtype(universe, sBound, sEnv, tBound, tEnv) || !H._isSubtype(universe, tBound, tEnv, sBound, sEnv))
|
|
return false;
|
|
}
|
|
return H._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv);
|
|
}
|
|
if (tKind === 11) {
|
|
if (s === type$.JavaScriptFunction)
|
|
return true;
|
|
if (t1)
|
|
return false;
|
|
return H._isFunctionSubtype(universe, s, sEnv, t, tEnv);
|
|
}
|
|
if (sKind === 9) {
|
|
if (tKind !== 9)
|
|
return false;
|
|
return H._isInterfaceSubtype(universe, s, sEnv, t, tEnv);
|
|
}
|
|
return false;
|
|
},
|
|
_isFunctionSubtype: function (universe, s, sEnv, t, tEnv) {
|
|
var sParameters, tParameters, sRequiredPositional, tRequiredPositional, sRequiredPositionalLength, tRequiredPositionalLength, requiredPositionalDelta, sOptionalPositional, tOptionalPositional, sOptionalPositionalLength, tOptionalPositionalLength, i, t1, sNamed, tNamed, sNamedLength, tNamedLength, sIndex, tIndex, tName, sName, sIsRequired;
|
|
if (!H._isSubtype(universe, s._primary, sEnv, t._primary, tEnv))
|
|
return false;
|
|
sParameters = s._rest;
|
|
tParameters = t._rest;
|
|
sRequiredPositional = sParameters._requiredPositional;
|
|
tRequiredPositional = tParameters._requiredPositional;
|
|
sRequiredPositionalLength = sRequiredPositional.length;
|
|
tRequiredPositionalLength = tRequiredPositional.length;
|
|
if (sRequiredPositionalLength > tRequiredPositionalLength)
|
|
return false;
|
|
requiredPositionalDelta = tRequiredPositionalLength - sRequiredPositionalLength;
|
|
sOptionalPositional = sParameters._optionalPositional;
|
|
tOptionalPositional = tParameters._optionalPositional;
|
|
sOptionalPositionalLength = sOptionalPositional.length;
|
|
tOptionalPositionalLength = tOptionalPositional.length;
|
|
if (sRequiredPositionalLength + sOptionalPositionalLength < tRequiredPositionalLength + tOptionalPositionalLength)
|
|
return false;
|
|
for (i = 0; i < sRequiredPositionalLength; ++i) {
|
|
t1 = sRequiredPositional[i];
|
|
if (!H._isSubtype(universe, tRequiredPositional[i], tEnv, t1, sEnv))
|
|
return false;
|
|
}
|
|
for (i = 0; i < requiredPositionalDelta; ++i) {
|
|
t1 = sOptionalPositional[i];
|
|
if (!H._isSubtype(universe, tRequiredPositional[sRequiredPositionalLength + i], tEnv, t1, sEnv))
|
|
return false;
|
|
}
|
|
for (i = 0; i < tOptionalPositionalLength; ++i) {
|
|
t1 = sOptionalPositional[requiredPositionalDelta + i];
|
|
if (!H._isSubtype(universe, tOptionalPositional[i], tEnv, t1, sEnv))
|
|
return false;
|
|
}
|
|
sNamed = sParameters._named;
|
|
tNamed = tParameters._named;
|
|
sNamedLength = sNamed.length;
|
|
tNamedLength = tNamed.length;
|
|
for (sIndex = 0, tIndex = 0; tIndex < tNamedLength; tIndex += 3) {
|
|
tName = tNamed[tIndex];
|
|
for (; true;) {
|
|
if (sIndex >= sNamedLength)
|
|
return false;
|
|
sName = sNamed[sIndex];
|
|
sIndex += 3;
|
|
if (tName < sName)
|
|
return false;
|
|
sIsRequired = sNamed[sIndex - 2];
|
|
if (sName < tName) {
|
|
if (sIsRequired)
|
|
return false;
|
|
continue;
|
|
}
|
|
t1 = tNamed[tIndex + 1];
|
|
if (sIsRequired && !t1)
|
|
return false;
|
|
t1 = sNamed[sIndex - 1];
|
|
if (!H._isSubtype(universe, tNamed[tIndex + 2], tEnv, t1, sEnv))
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
for (; sIndex < sNamedLength;) {
|
|
if (sNamed[sIndex + 1])
|
|
return false;
|
|
sIndex += 3;
|
|
}
|
|
return true;
|
|
},
|
|
_isInterfaceSubtype: function (universe, s, sEnv, t, tEnv) {
|
|
var sArgs, tArgs, $length, i, t1, t2, rule, supertypeArgs,
|
|
sName = s._primary,
|
|
tName = t._primary;
|
|
if (sName === tName) {
|
|
sArgs = s._rest;
|
|
tArgs = t._rest;
|
|
$length = sArgs.length;
|
|
for (i = 0; i < $length; ++i) {
|
|
t1 = sArgs[i];
|
|
t2 = tArgs[i];
|
|
if (!H._isSubtype(universe, t1, sEnv, t2, tEnv))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (t === type$.Object)
|
|
return true;
|
|
rule = H._Universe_findRule(universe, sName);
|
|
if (rule == null)
|
|
return false;
|
|
supertypeArgs = rule[tName];
|
|
if (supertypeArgs == null)
|
|
return false;
|
|
$length = supertypeArgs.length;
|
|
tArgs = t._rest;
|
|
for (i = 0; i < $length; ++i)
|
|
if (!H._isSubtype(universe, H._Universe_evalInEnvironment(universe, s, supertypeArgs[i]), sEnv, tArgs[i], tEnv))
|
|
return false;
|
|
return true;
|
|
},
|
|
isNullable: function (t) {
|
|
var t1,
|
|
kind = t._kind;
|
|
if (!(t === type$.Null || t === type$.JSNull))
|
|
if (!H.isStrongTopType(t))
|
|
if (kind !== 7)
|
|
if (!(kind === 6 && H.isNullable(t._primary)))
|
|
t1 = kind === 8 && H.isNullable(t._primary);
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
return t1;
|
|
},
|
|
isTopType: function (t) {
|
|
var t1;
|
|
if (!H.isStrongTopType(t))
|
|
if (!(t === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
return t1;
|
|
},
|
|
isStrongTopType: function (t) {
|
|
var kind = t._kind;
|
|
return kind === 2 || kind === 3 || kind === 4 || kind === 5 || t === type$.nullable_Object;
|
|
},
|
|
_Utils_objectAssign: function (o, other) {
|
|
var i, key,
|
|
keys = Object.keys(other),
|
|
$length = keys.length;
|
|
for (i = 0; i < $length; ++i) {
|
|
key = keys[i];
|
|
o[key] = other[key];
|
|
}
|
|
},
|
|
Rti: function Rti(t0, t1) {
|
|
var _ = this;
|
|
_._as = t0;
|
|
_._is = t1;
|
|
_._cachedRuntimeType = _._specializedTestResource = _._precomputed1 = null;
|
|
_._kind = 0;
|
|
_._canonicalRecipe = _._bindCache = _._evalCache = _._rest = _._primary = null;
|
|
},
|
|
_FunctionParameters: function _FunctionParameters() {
|
|
this._named = this._optionalPositional = this._requiredPositional = null;
|
|
},
|
|
_Error: function _Error() {},
|
|
_TypeError: function _TypeError(t0) {
|
|
this.__rti$_message = t0;
|
|
},
|
|
unmangleGlobalNameIfPreservedAnyways: function ($name) {
|
|
return init.mangledGlobalNames[$name];
|
|
},
|
|
printString: function (string) {
|
|
if (typeof dartPrint == "function") {
|
|
dartPrint(string);
|
|
return;
|
|
}
|
|
if (typeof console == "object" && typeof console.log != "undefined") {
|
|
console.log(string);
|
|
return;
|
|
}
|
|
if (typeof window == "object")
|
|
return;
|
|
if (typeof print == "function") {
|
|
print(string);
|
|
return;
|
|
}
|
|
throw "Unable to print message: " + String(string);
|
|
}
|
|
},
|
|
J = {
|
|
makeDispatchRecord: function (interceptor, proto, extension, indexability) {
|
|
return {
|
|
i: interceptor,
|
|
p: proto,
|
|
e: extension,
|
|
x: indexability
|
|
};
|
|
},
|
|
getNativeInterceptor: function (object) {
|
|
var proto, objectProto, $constructor, interceptor,
|
|
record = object[init.dispatchPropertyName];
|
|
if (record == null)
|
|
if ($.initNativeDispatchFlag == null) {
|
|
H.initNativeDispatch();
|
|
record = object[init.dispatchPropertyName];
|
|
}
|
|
if (record != null) {
|
|
proto = record.p;
|
|
if (false === proto)
|
|
return record.i;
|
|
if (true === proto)
|
|
return object;
|
|
objectProto = Object.getPrototypeOf(object);
|
|
if (proto === objectProto)
|
|
return record.i;
|
|
if (record.e === objectProto)
|
|
throw H.wrapException(P.UnimplementedError$("Return interceptor for " + H.S(proto(object, record))));
|
|
}
|
|
$constructor = object.constructor;
|
|
interceptor = $constructor == null ? null : $constructor[J.JS_INTEROP_INTERCEPTOR_TAG()];
|
|
if (interceptor != null)
|
|
return interceptor;
|
|
interceptor = H.lookupAndCacheInterceptor(object);
|
|
if (interceptor != null)
|
|
return interceptor;
|
|
if (typeof object == "function")
|
|
return C.JavaScriptFunction_methods;
|
|
proto = Object.getPrototypeOf(object);
|
|
if (proto == null)
|
|
return C.PlainJavaScriptObject_methods;
|
|
if (proto === Object.prototype)
|
|
return C.PlainJavaScriptObject_methods;
|
|
if (typeof $constructor == "function") {
|
|
Object.defineProperty($constructor, J.JS_INTEROP_INTERCEPTOR_TAG(), {
|
|
value: C.UnknownJavaScriptObject_methods,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return C.UnknownJavaScriptObject_methods;
|
|
}
|
|
return C.UnknownJavaScriptObject_methods;
|
|
},
|
|
JS_INTEROP_INTERCEPTOR_TAG: function () {
|
|
var t1 = $._JS_INTEROP_INTERCEPTOR_TAG;
|
|
return t1 == null ? $._JS_INTEROP_INTERCEPTOR_TAG = init.getIsolateTag("_$dart_js") : t1;
|
|
},
|
|
JSArray_markFixedList: function (list, $T) {
|
|
list.fixed$length = Array;
|
|
return list;
|
|
},
|
|
getInterceptor$: function (receiver) {
|
|
if (typeof receiver == "number") {
|
|
if (Math.floor(receiver) == receiver)
|
|
return J.JSInt.prototype;
|
|
return J.JSDouble.prototype;
|
|
}
|
|
if (typeof receiver == "string")
|
|
return J.JSString.prototype;
|
|
if (receiver == null)
|
|
return J.JSNull.prototype;
|
|
if (typeof receiver == "boolean")
|
|
return J.JSBool.prototype;
|
|
if (receiver.constructor == Array)
|
|
return J.JSArray.prototype;
|
|
if (typeof receiver != "object") {
|
|
if (typeof receiver == "function")
|
|
return J.JavaScriptFunction.prototype;
|
|
return receiver;
|
|
}
|
|
if (receiver instanceof P.Object)
|
|
return receiver;
|
|
return J.getNativeInterceptor(receiver);
|
|
},
|
|
getInterceptor$asx: function (receiver) {
|
|
if (typeof receiver == "string")
|
|
return J.JSString.prototype;
|
|
if (receiver == null)
|
|
return receiver;
|
|
if (receiver.constructor == Array)
|
|
return J.JSArray.prototype;
|
|
if (typeof receiver != "object") {
|
|
if (typeof receiver == "function")
|
|
return J.JavaScriptFunction.prototype;
|
|
return receiver;
|
|
}
|
|
if (receiver instanceof P.Object)
|
|
return receiver;
|
|
return J.getNativeInterceptor(receiver);
|
|
},
|
|
getInterceptor$ax: function (receiver) {
|
|
if (receiver == null)
|
|
return receiver;
|
|
if (receiver.constructor == Array)
|
|
return J.JSArray.prototype;
|
|
if (typeof receiver != "object") {
|
|
if (typeof receiver == "function")
|
|
return J.JavaScriptFunction.prototype;
|
|
return receiver;
|
|
}
|
|
if (receiver instanceof P.Object)
|
|
return receiver;
|
|
return J.getNativeInterceptor(receiver);
|
|
},
|
|
get$hashCode$: function (receiver) {
|
|
return J.getInterceptor$(receiver).get$hashCode(receiver);
|
|
},
|
|
get$iterator$ax: function (receiver) {
|
|
return J.getInterceptor$ax(receiver).get$iterator(receiver);
|
|
},
|
|
get$length$asx: function (receiver) {
|
|
return J.getInterceptor$asx(receiver).get$length(receiver);
|
|
},
|
|
$eq$: function (receiver, a0) {
|
|
if (receiver == null)
|
|
return a0 == null;
|
|
if (typeof receiver != "object")
|
|
return a0 != null && receiver === a0;
|
|
return J.getInterceptor$(receiver).$eq(receiver, a0);
|
|
},
|
|
toString$0$: function (receiver) {
|
|
return J.getInterceptor$(receiver).toString$0(receiver);
|
|
},
|
|
Interceptor: function Interceptor() {},
|
|
JSBool: function JSBool() {},
|
|
JSNull: function JSNull() {},
|
|
JavaScriptObject: function JavaScriptObject() {},
|
|
PlainJavaScriptObject: function PlainJavaScriptObject() {},
|
|
UnknownJavaScriptObject: function UnknownJavaScriptObject() {},
|
|
JavaScriptFunction: function JavaScriptFunction() {},
|
|
JSArray: function JSArray(t0) {
|
|
this.$ti = t0;
|
|
},
|
|
JSUnmodifiableArray: function JSUnmodifiableArray(t0) {
|
|
this.$ti = t0;
|
|
},
|
|
ArrayIterator: function ArrayIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_._iterable = t0;
|
|
_._length = t1;
|
|
_._index = 0;
|
|
_._current = null;
|
|
_.$ti = t2;
|
|
},
|
|
JSNumber: function JSNumber() {},
|
|
JSInt: function JSInt() {},
|
|
JSDouble: function JSDouble() {},
|
|
JSString: function JSString() {}
|
|
},
|
|
P = {
|
|
_AsyncRun__initializeScheduleImmediate: function () {
|
|
var div, span, t1 = {};
|
|
if (self.scheduleImmediate != null)
|
|
return P.async__AsyncRun__scheduleImmediateJsOverride$closure();
|
|
if (self.MutationObserver != null && self.document != null) {
|
|
div = self.document.createElement("div");
|
|
span = self.document.createElement("span");
|
|
t1.storedCallback = null;
|
|
new self.MutationObserver(H.convertDartClosureToJS(new P._AsyncRun__initializeScheduleImmediate_internalCallback(t1), 1)).observe(div, {
|
|
childList: true
|
|
});
|
|
return new P._AsyncRun__initializeScheduleImmediate_closure(t1, div, span);
|
|
} else if (self.setImmediate != null)
|
|
return P.async__AsyncRun__scheduleImmediateWithSetImmediate$closure();
|
|
return P.async__AsyncRun__scheduleImmediateWithTimer$closure();
|
|
},
|
|
_AsyncRun__scheduleImmediateJsOverride: function (callback) {
|
|
self.scheduleImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateJsOverride_internalCallback(type$.void_Function._as(callback)), 0));
|
|
},
|
|
_AsyncRun__scheduleImmediateWithSetImmediate: function (callback) {
|
|
self.setImmediate(H.convertDartClosureToJS(new P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(type$.void_Function._as(callback)), 0));
|
|
},
|
|
_AsyncRun__scheduleImmediateWithTimer: function (callback) {
|
|
P.Timer__createTimer(C.Duration_0, type$.void_Function._as(callback));
|
|
},
|
|
Timer__createTimer: function (duration, callback) {
|
|
var milliseconds = C.JSInt_methods._tdivFast$1(duration._duration, 1000);
|
|
return P._TimerImpl$(milliseconds < 0 ? 0 : milliseconds, callback);
|
|
},
|
|
_TimerImpl$: function (milliseconds, callback) {
|
|
var t1 = new P._TimerImpl();
|
|
t1._TimerImpl$2(milliseconds, callback);
|
|
return t1;
|
|
},
|
|
AsyncError$: function (error, stackTrace) {
|
|
var t1 = H.checkNotNullable(error, "error", type$.Object);
|
|
return new P.AsyncError(t1, stackTrace == null ? P.AsyncError_defaultStackTrace(error) : stackTrace);
|
|
},
|
|
AsyncError_defaultStackTrace: function (error) {
|
|
var stackTrace;
|
|
if (type$.Error._is(error)) {
|
|
stackTrace = error.get$stackTrace();
|
|
if (stackTrace != null)
|
|
return stackTrace;
|
|
}
|
|
return C.C__StringStackTrace;
|
|
},
|
|
Future_Future$delayed: function (duration, $T) {
|
|
var result,
|
|
t1 = !$T._is(null);
|
|
if (t1)
|
|
throw H.wrapException(P.ArgumentError$value(null, "computation", "The type parameter is not nullable"));
|
|
result = new P._Future($.Zone__current, $T._eval$1("_Future<0>"));
|
|
P.Timer_Timer(duration, new P.Future_Future$delayed_closure(null, result, $T));
|
|
return result;
|
|
},
|
|
_Future__chainCoreFuture: function (source, target) {
|
|
var t1, t2, listeners;
|
|
for (t1 = type$._Future_dynamic; t2 = source._state, t2 === 2;)
|
|
source = t1._as(source._resultOrListeners);
|
|
if (t2 >= 4) {
|
|
listeners = target._removeListeners$0();
|
|
target._state = source._state;
|
|
target._resultOrListeners = source._resultOrListeners;
|
|
P._Future__propagateToListeners(target, listeners);
|
|
} else {
|
|
listeners = type$.nullable__FutureListener_dynamic_dynamic._as(target._resultOrListeners);
|
|
target._state = 2;
|
|
target._resultOrListeners = source;
|
|
source._prependListeners$1(listeners);
|
|
}
|
|
},
|
|
_Future__propagateToListeners: function (source, listeners) {
|
|
var t2, t3, t4, _box_0, hasError, asyncError, nextListener, nextListener0, t5, sourceResult, t6, t7, zone, oldZone, result, current, _null = null,
|
|
_box_1 = {},
|
|
t1 = _box_1.source = source;
|
|
for (t2 = type$.AsyncError, t3 = type$.nullable__FutureListener_dynamic_dynamic, t4 = type$.Future_dynamic; true;) {
|
|
_box_0 = {};
|
|
hasError = t1._state === 8;
|
|
if (listeners == null) {
|
|
if (hasError) {
|
|
asyncError = t2._as(t1._resultOrListeners);
|
|
P._rootHandleUncaughtError(_null, _null, t1._zone, asyncError.error, asyncError.stackTrace);
|
|
}
|
|
return;
|
|
}
|
|
_box_0.listener = listeners;
|
|
nextListener = listeners._nextListener;
|
|
for (t1 = listeners; nextListener != null; t1 = nextListener, nextListener = nextListener0) {
|
|
t1._nextListener = null;
|
|
P._Future__propagateToListeners(_box_1.source, t1);
|
|
_box_0.listener = nextListener;
|
|
nextListener0 = nextListener._nextListener;
|
|
}
|
|
t5 = _box_1.source;
|
|
sourceResult = t5._resultOrListeners;
|
|
_box_0.listenerHasError = hasError;
|
|
_box_0.listenerValueOrError = sourceResult;
|
|
t6 = !hasError;
|
|
if (t6) {
|
|
t7 = t1.state;
|
|
t7 = (t7 & 1) !== 0 || (t7 & 15) === 8;
|
|
} else
|
|
t7 = true;
|
|
if (t7) {
|
|
zone = t1.result._zone;
|
|
if (hasError) {
|
|
t7 = t5._zone === zone;
|
|
t7 = !(t7 || t7);
|
|
} else
|
|
t7 = false;
|
|
if (t7) {
|
|
t2._as(sourceResult);
|
|
P._rootHandleUncaughtError(_null, _null, t5._zone, sourceResult.error, sourceResult.stackTrace);
|
|
return;
|
|
}
|
|
oldZone = $.Zone__current;
|
|
if (oldZone !== zone)
|
|
$.Zone__current = zone;
|
|
else
|
|
oldZone = _null;
|
|
t1 = t1.state;
|
|
if ((t1 & 15) === 8)
|
|
new P._Future__propagateToListeners_handleWhenCompleteCallback(_box_0, _box_1, hasError).call$0();
|
|
else if (t6) {
|
|
if ((t1 & 1) !== 0)
|
|
new P._Future__propagateToListeners_handleValueCallback(_box_0, sourceResult).call$0();
|
|
} else if ((t1 & 2) !== 0)
|
|
new P._Future__propagateToListeners_handleError(_box_1, _box_0).call$0();
|
|
if (oldZone != null)
|
|
$.Zone__current = oldZone;
|
|
t1 = _box_0.listenerValueOrError;
|
|
if (t4._is(t1)) {
|
|
t5 = _box_0.listener.$ti;
|
|
t5 = t5._eval$1("Future<2>")._is(t1) || !t5._rest[1]._is(t1);
|
|
} else
|
|
t5 = false;
|
|
if (t5) {
|
|
t4._as(t1);
|
|
result = _box_0.listener.result;
|
|
if (t1._state >= 4) {
|
|
current = t3._as(result._resultOrListeners);
|
|
result._resultOrListeners = null;
|
|
listeners = result._reverseListeners$1(current);
|
|
result._state = t1._state;
|
|
result._resultOrListeners = t1._resultOrListeners;
|
|
_box_1.source = t1;
|
|
continue;
|
|
} else
|
|
P._Future__chainCoreFuture(t1, result);
|
|
return;
|
|
}
|
|
}
|
|
result = _box_0.listener.result;
|
|
current = t3._as(result._resultOrListeners);
|
|
result._resultOrListeners = null;
|
|
listeners = result._reverseListeners$1(current);
|
|
t1 = _box_0.listenerHasError;
|
|
t5 = _box_0.listenerValueOrError;
|
|
if (!t1) {
|
|
result.$ti._precomputed1._as(t5);
|
|
result._state = 4;
|
|
result._resultOrListeners = t5;
|
|
} else {
|
|
t2._as(t5);
|
|
result._state = 8;
|
|
result._resultOrListeners = t5;
|
|
}
|
|
_box_1.source = result;
|
|
t1 = result;
|
|
}
|
|
},
|
|
_registerErrorHandler: function (errorHandler, zone) {
|
|
var t1 = type$.dynamic_Function_Object_StackTrace;
|
|
if (t1._is(errorHandler))
|
|
return t1._as(errorHandler);
|
|
t1 = type$.dynamic_Function_Object;
|
|
if (t1._is(errorHandler))
|
|
return t1._as(errorHandler);
|
|
throw H.wrapException(P.ArgumentError$value(errorHandler, "onError", "Error handler must accept one Object or one Object and a StackTrace as arguments, and return a valid result"));
|
|
},
|
|
_microtaskLoop: function () {
|
|
var entry, next;
|
|
for (entry = $._nextCallback; entry != null; entry = $._nextCallback) {
|
|
$._lastPriorityCallback = null;
|
|
next = entry.next;
|
|
$._nextCallback = next;
|
|
if (next == null)
|
|
$._lastCallback = null;
|
|
entry.callback.call$0();
|
|
}
|
|
},
|
|
_startMicrotaskLoop: function () {
|
|
$._isInCallbackLoop = true;
|
|
try {
|
|
P._microtaskLoop();
|
|
} finally {
|
|
$._lastPriorityCallback = null;
|
|
$._isInCallbackLoop = false;
|
|
if ($._nextCallback != null)
|
|
$.$get$_AsyncRun__scheduleImmediateClosure().call$1(P.async___startMicrotaskLoop$closure());
|
|
}
|
|
},
|
|
_scheduleAsyncCallback: function (callback) {
|
|
var newEntry = new P._AsyncCallbackEntry(callback),
|
|
lastCallback = $._lastCallback;
|
|
if (lastCallback == null) {
|
|
$._nextCallback = $._lastCallback = newEntry;
|
|
if (!$._isInCallbackLoop)
|
|
$.$get$_AsyncRun__scheduleImmediateClosure().call$1(P.async___startMicrotaskLoop$closure());
|
|
} else
|
|
$._lastCallback = lastCallback.next = newEntry;
|
|
},
|
|
_schedulePriorityAsyncCallback: function (callback) {
|
|
var entry, lastPriorityCallback, next,
|
|
t1 = $._nextCallback;
|
|
if (t1 == null) {
|
|
P._scheduleAsyncCallback(callback);
|
|
$._lastPriorityCallback = $._lastCallback;
|
|
return;
|
|
}
|
|
entry = new P._AsyncCallbackEntry(callback);
|
|
lastPriorityCallback = $._lastPriorityCallback;
|
|
if (lastPriorityCallback == null) {
|
|
entry.next = t1;
|
|
$._nextCallback = $._lastPriorityCallback = entry;
|
|
} else {
|
|
next = lastPriorityCallback.next;
|
|
entry.next = next;
|
|
$._lastPriorityCallback = lastPriorityCallback.next = entry;
|
|
if (next == null)
|
|
$._lastCallback = entry;
|
|
}
|
|
},
|
|
scheduleMicrotask: function (callback) {
|
|
var _null = null,
|
|
currentZone = $.Zone__current;
|
|
if (C.C__RootZone === currentZone) {
|
|
P._rootScheduleMicrotask(_null, _null, C.C__RootZone, callback);
|
|
return;
|
|
}
|
|
P._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(currentZone.bindCallbackGuarded$1(callback)));
|
|
},
|
|
Timer_Timer: function (duration, callback) {
|
|
var t1 = $.Zone__current;
|
|
if (t1 === C.C__RootZone)
|
|
return P.Timer__createTimer(duration, type$.void_Function._as(callback));
|
|
return P.Timer__createTimer(duration, type$.void_Function._as(t1.bindCallbackGuarded$1(callback)));
|
|
},
|
|
_rootHandleUncaughtError: function ($self, $parent, zone, error, stackTrace) {
|
|
P._schedulePriorityAsyncCallback(new P._rootHandleUncaughtError_closure(error, stackTrace));
|
|
},
|
|
_rootRun: function ($self, $parent, zone, f, $R) {
|
|
var old,
|
|
t1 = $.Zone__current;
|
|
if (t1 === zone)
|
|
return f.call$0();
|
|
$.Zone__current = zone;
|
|
old = t1;
|
|
try {
|
|
t1 = f.call$0();
|
|
return t1;
|
|
} finally {
|
|
$.Zone__current = old;
|
|
}
|
|
},
|
|
_rootRunUnary: function ($self, $parent, zone, f, arg, $R, $T) {
|
|
var old,
|
|
t1 = $.Zone__current;
|
|
if (t1 === zone)
|
|
return f.call$1(arg);
|
|
$.Zone__current = zone;
|
|
old = t1;
|
|
try {
|
|
t1 = f.call$1(arg);
|
|
return t1;
|
|
} finally {
|
|
$.Zone__current = old;
|
|
}
|
|
},
|
|
_rootRunBinary: function ($self, $parent, zone, f, arg1, arg2, $R, T1, T2) {
|
|
var old,
|
|
t1 = $.Zone__current;
|
|
if (t1 === zone)
|
|
return f.call$2(arg1, arg2);
|
|
$.Zone__current = zone;
|
|
old = t1;
|
|
try {
|
|
t1 = f.call$2(arg1, arg2);
|
|
return t1;
|
|
} finally {
|
|
$.Zone__current = old;
|
|
}
|
|
},
|
|
_rootScheduleMicrotask: function ($self, $parent, zone, f) {
|
|
var t1;
|
|
type$.void_Function._as(f);
|
|
t1 = C.C__RootZone !== zone;
|
|
if (t1)
|
|
f = !(!t1 || false) ? zone.bindCallbackGuarded$1(f) : zone.bindCallback$1$1(f, type$.void);
|
|
P._scheduleAsyncCallback(f);
|
|
},
|
|
_AsyncRun__initializeScheduleImmediate_internalCallback: function _AsyncRun__initializeScheduleImmediate_internalCallback(t0) {
|
|
this._box_0 = t0;
|
|
},
|
|
_AsyncRun__initializeScheduleImmediate_closure: function _AsyncRun__initializeScheduleImmediate_closure(t0, t1, t2) {
|
|
this._box_0 = t0;
|
|
this.div = t1;
|
|
this.span = t2;
|
|
},
|
|
_AsyncRun__scheduleImmediateJsOverride_internalCallback: function _AsyncRun__scheduleImmediateJsOverride_internalCallback(t0) {
|
|
this.callback = t0;
|
|
},
|
|
_AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: function _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(t0) {
|
|
this.callback = t0;
|
|
},
|
|
_TimerImpl: function _TimerImpl() {},
|
|
_TimerImpl_internalCallback: function _TimerImpl_internalCallback(t0, t1) {
|
|
this.$this = t0;
|
|
this.callback = t1;
|
|
},
|
|
AsyncError: function AsyncError(t0, t1) {
|
|
this.error = t0;
|
|
this.stackTrace = t1;
|
|
},
|
|
Future_Future$delayed_closure: function Future_Future$delayed_closure(t0, t1, t2) {
|
|
this.computation = t0;
|
|
this.result = t1;
|
|
this.T = t2;
|
|
},
|
|
_FutureListener: function _FutureListener(t0, t1, t2, t3, t4) {
|
|
var _ = this;
|
|
_._nextListener = null;
|
|
_.result = t0;
|
|
_.state = t1;
|
|
_.callback = t2;
|
|
_.errorCallback = t3;
|
|
_.$ti = t4;
|
|
},
|
|
_Future: function _Future(t0, t1) {
|
|
var _ = this;
|
|
_._state = 0;
|
|
_._zone = t0;
|
|
_._resultOrListeners = null;
|
|
_.$ti = t1;
|
|
},
|
|
_Future__addListener_closure: function _Future__addListener_closure(t0, t1) {
|
|
this.$this = t0;
|
|
this.listener = t1;
|
|
},
|
|
_Future__prependListeners_closure: function _Future__prependListeners_closure(t0, t1) {
|
|
this._box_0 = t0;
|
|
this.$this = t1;
|
|
},
|
|
_Future__chainForeignFuture_closure: function _Future__chainForeignFuture_closure(t0) {
|
|
this.$this = t0;
|
|
},
|
|
_Future__chainForeignFuture_closure0: function _Future__chainForeignFuture_closure0(t0) {
|
|
this.$this = t0;
|
|
},
|
|
_Future__chainForeignFuture_closure1: function _Future__chainForeignFuture_closure1(t0, t1, t2) {
|
|
this.$this = t0;
|
|
this.e = t1;
|
|
this.s = t2;
|
|
},
|
|
_Future__propagateToListeners_handleWhenCompleteCallback: function _Future__propagateToListeners_handleWhenCompleteCallback(t0, t1, t2) {
|
|
this._box_0 = t0;
|
|
this._box_1 = t1;
|
|
this.hasError = t2;
|
|
},
|
|
_Future__propagateToListeners_handleWhenCompleteCallback_closure: function _Future__propagateToListeners_handleWhenCompleteCallback_closure(t0) {
|
|
this.originalSource = t0;
|
|
},
|
|
_Future__propagateToListeners_handleValueCallback: function _Future__propagateToListeners_handleValueCallback(t0, t1) {
|
|
this._box_0 = t0;
|
|
this.sourceResult = t1;
|
|
},
|
|
_Future__propagateToListeners_handleError: function _Future__propagateToListeners_handleError(t0, t1) {
|
|
this._box_1 = t0;
|
|
this._box_0 = t1;
|
|
},
|
|
_AsyncCallbackEntry: function _AsyncCallbackEntry(t0) {
|
|
this.callback = t0;
|
|
this.next = null;
|
|
},
|
|
_Zone: function _Zone() {},
|
|
_rootHandleUncaughtError_closure: function _rootHandleUncaughtError_closure(t0, t1) {
|
|
this.error = t0;
|
|
this.stackTrace = t1;
|
|
},
|
|
_RootZone: function _RootZone() {},
|
|
_RootZone_bindCallback_closure: function _RootZone_bindCallback_closure(t0, t1, t2) {
|
|
this.$this = t0;
|
|
this.f = t1;
|
|
this.R = t2;
|
|
},
|
|
_RootZone_bindCallbackGuarded_closure: function _RootZone_bindCallbackGuarded_closure(t0, t1) {
|
|
this.$this = t0;
|
|
this.f = t1;
|
|
},
|
|
LinkedHashMap_LinkedHashMap$_literal: function (keyValuePairs, $K, $V) {
|
|
return $K._eval$1("@<0>")._bind$1($V)._eval$1("LinkedHashMap<1,2>")._as(H.fillLiteralMap(keyValuePairs, new H.JsLinkedHashMap($K._eval$1("@<0>")._bind$1($V)._eval$1("JsLinkedHashMap<1,2>"))));
|
|
},
|
|
IterableBase_iterableToFullString: function (iterable, leftDelimiter, rightDelimiter) {
|
|
var buffer, t1;
|
|
if (P._isToStringVisiting(iterable))
|
|
return leftDelimiter + "..." + rightDelimiter;
|
|
buffer = new P.StringBuffer(leftDelimiter);
|
|
C.JSArray_methods.add$1($._toStringVisiting, iterable);
|
|
try {
|
|
t1 = buffer;
|
|
t1._contents = P.StringBuffer__writeAll(t1._contents, iterable, ", ");
|
|
} finally {
|
|
if (0 >= $._toStringVisiting.length)
|
|
return H.ioore($._toStringVisiting, -1);
|
|
$._toStringVisiting.pop();
|
|
}
|
|
buffer._contents += rightDelimiter;
|
|
t1 = buffer._contents;
|
|
return t1.charCodeAt(0) == 0 ? t1 : t1;
|
|
},
|
|
_isToStringVisiting: function (o) {
|
|
var t1, i;
|
|
for (t1 = $._toStringVisiting.length, i = 0; i < t1; ++i)
|
|
if (o === $._toStringVisiting[i])
|
|
return true;
|
|
return false;
|
|
},
|
|
MapBase_mapToString: function (m) {
|
|
var result, t1 = {};
|
|
if (P._isToStringVisiting(m))
|
|
return "{...}";
|
|
result = new P.StringBuffer("");
|
|
try {
|
|
C.JSArray_methods.add$1($._toStringVisiting, m);
|
|
result._contents += "{";
|
|
t1.first = true;
|
|
m.forEach$1(0, new P.MapBase_mapToString_closure(t1, result));
|
|
result._contents += "}";
|
|
} finally {
|
|
if (0 >= $._toStringVisiting.length)
|
|
return H.ioore($._toStringVisiting, -1);
|
|
$._toStringVisiting.pop();
|
|
}
|
|
t1 = result._contents;
|
|
return t1.charCodeAt(0) == 0 ? t1 : t1;
|
|
},
|
|
ListBase: function ListBase() {},
|
|
ListMixin: function ListMixin() {},
|
|
MapBase: function MapBase() {},
|
|
MapBase_mapToString_closure: function MapBase_mapToString_closure(t0, t1) {
|
|
this._box_0 = t0;
|
|
this.result = t1;
|
|
},
|
|
MapMixin: function MapMixin() {},
|
|
_ListBase_Object_ListMixin: function _ListBase_Object_ListMixin() {},
|
|
Error__objectToString: function (object) {
|
|
if (object instanceof H.Closure)
|
|
return object.toString$0(0);
|
|
return "Instance of '" + H.Primitives_objectTypeName(object) + "'";
|
|
},
|
|
StringBuffer__writeAll: function (string, objects, separator) {
|
|
var iterator = J.get$iterator$ax(objects);
|
|
if (!iterator.moveNext$0())
|
|
return string;
|
|
if (separator.length === 0) {
|
|
do
|
|
string += H.S(iterator.get$current());
|
|
while (iterator.moveNext$0());
|
|
} else {
|
|
string += H.S(iterator.get$current());
|
|
for (; iterator.moveNext$0();)
|
|
string = string + separator + H.S(iterator.get$current());
|
|
}
|
|
return string;
|
|
},
|
|
Error_safeToString: function (object) {
|
|
if (typeof object == "number" || H._isBool(object) || null == object)
|
|
return J.toString$0$(object);
|
|
if (typeof object == "string")
|
|
return JSON.stringify(object);
|
|
return P.Error__objectToString(object);
|
|
},
|
|
AssertionError$: function (message) {
|
|
return new P.AssertionError(message);
|
|
},
|
|
ArgumentError$: function (message) {
|
|
return new P.ArgumentError(false, null, null, message);
|
|
},
|
|
ArgumentError$value: function (value, $name, message) {
|
|
return new P.ArgumentError(true, value, $name, message);
|
|
},
|
|
RangeError$value: function (value, $name) {
|
|
return new P.RangeError(null, null, true, value, $name, "Value not in range");
|
|
},
|
|
IndexError$: function (invalidValue, indexable, $name, message, $length) {
|
|
var t1 = H._asInt($length == null ? J.get$length$asx(indexable) : $length);
|
|
return new P.IndexError(t1, true, invalidValue, $name, "Index out of range");
|
|
},
|
|
UnsupportedError$: function (message) {
|
|
return new P.UnsupportedError(message);
|
|
},
|
|
UnimplementedError$: function (message) {
|
|
return new P.UnimplementedError(message);
|
|
},
|
|
ConcurrentModificationError$: function (modifiedObject) {
|
|
return new P.ConcurrentModificationError(modifiedObject);
|
|
},
|
|
print: function (object) {
|
|
H.printString(J.toString$0$(object));
|
|
},
|
|
Duration: function Duration(t0) {
|
|
this._duration = t0;
|
|
},
|
|
Duration_toString_sixDigits: function Duration_toString_sixDigits() {},
|
|
Duration_toString_twoDigits: function Duration_toString_twoDigits() {},
|
|
Error: function Error() {},
|
|
AssertionError: function AssertionError(t0) {
|
|
this.message = t0;
|
|
},
|
|
TypeError: function TypeError() {},
|
|
NullThrownError: function NullThrownError() {},
|
|
ArgumentError: function ArgumentError(t0, t1, t2, t3) {
|
|
var _ = this;
|
|
_._hasValue = t0;
|
|
_.invalidValue = t1;
|
|
_.name = t2;
|
|
_.message = t3;
|
|
},
|
|
RangeError: function RangeError(t0, t1, t2, t3, t4, t5) {
|
|
var _ = this;
|
|
_.start = t0;
|
|
_.end = t1;
|
|
_._hasValue = t2;
|
|
_.invalidValue = t3;
|
|
_.name = t4;
|
|
_.message = t5;
|
|
},
|
|
IndexError: function IndexError(t0, t1, t2, t3, t4) {
|
|
var _ = this;
|
|
_.length = t0;
|
|
_._hasValue = t1;
|
|
_.invalidValue = t2;
|
|
_.name = t3;
|
|
_.message = t4;
|
|
},
|
|
UnsupportedError: function UnsupportedError(t0) {
|
|
this.message = t0;
|
|
},
|
|
UnimplementedError: function UnimplementedError(t0) {
|
|
this.message = t0;
|
|
},
|
|
ConcurrentModificationError: function ConcurrentModificationError(t0) {
|
|
this.modifiedObject = t0;
|
|
},
|
|
StackOverflowError: function StackOverflowError() {},
|
|
CyclicInitializationError: function CyclicInitializationError(t0) {
|
|
this.variableName = t0;
|
|
},
|
|
_Exception: function _Exception(t0) {
|
|
this.message = t0;
|
|
},
|
|
Null: function Null() {},
|
|
Object: function Object() {},
|
|
_StringStackTrace: function _StringStackTrace() {},
|
|
StringBuffer: function StringBuffer(t0) {
|
|
this._contents = t0;
|
|
}
|
|
},
|
|
W = {
|
|
HtmlElement: function HtmlElement() {},
|
|
AnchorElement: function AnchorElement() {},
|
|
AreaElement: function AreaElement() {},
|
|
CharacterData: function CharacterData() {},
|
|
CssStyleDeclaration: function CssStyleDeclaration() {},
|
|
CssStyleDeclarationBase: function CssStyleDeclarationBase() {},
|
|
DivElement: function DivElement() {},
|
|
DomException: function DomException() {},
|
|
DomTokenList: function DomTokenList() {},
|
|
_FrozenElementList: function _FrozenElementList(t0, t1) {
|
|
this._nodeList = t0;
|
|
this.$ti = t1;
|
|
},
|
|
Element: function Element() {},
|
|
EventTarget: function EventTarget() {},
|
|
FormElement: function FormElement() {},
|
|
Node: function Node() {},
|
|
NodeList: function NodeList() {},
|
|
SelectElement: function SelectElement() {},
|
|
TableCellElement: function TableCellElement() {},
|
|
ImmutableListMixin: function ImmutableListMixin() {},
|
|
FixedSizeListIterator: function FixedSizeListIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_._array = t0;
|
|
_._html$_length = t1;
|
|
_._position = -1;
|
|
_._html$_current = null;
|
|
_.$ti = t2;
|
|
},
|
|
_CssStyleDeclaration_Interceptor_CssStyleDeclarationBase: function _CssStyleDeclaration_Interceptor_CssStyleDeclarationBase() {},
|
|
_NodeList_Interceptor_ListMixin: function _NodeList_Interceptor_ListMixin() {},
|
|
_NodeList_Interceptor_ListMixin_ImmutableListMixin: function _NodeList_Interceptor_ListMixin_ImmutableListMixin() {}
|
|
},
|
|
V = {
|
|
main: function () {
|
|
var t1, t2, t3, t4, t5, tr, td, t6, plist, pbody, p, a, i, b,
|
|
_s13_ = "Hello, World!";
|
|
P.print($.$get$Dt_at());
|
|
t1 = document;
|
|
t2 = t1.querySelector("#an-id");
|
|
t2.toString;
|
|
t3 = t1.querySelector(".a-class");
|
|
t3.toString;
|
|
t4 = type$.Element;
|
|
H.checkTypeBound(t4, t4, "T", "querySelectorAll");
|
|
t4 = t1.querySelectorAll("div");
|
|
t5 = type$.dynamic;
|
|
P.print(P.LinkedHashMap_LinkedHashMap$_literal(["a", 1], t5, t5));
|
|
tr = t1.createElement("tr");
|
|
td = t1.createElement("td");
|
|
tr.appendChild(td);
|
|
C.TableCellElement_methods.set$text(td, "\u51fb\u6740");
|
|
t6 = td.style;
|
|
t6.width = "44px";
|
|
td = t1.createElement("td");
|
|
tr.appendChild(td);
|
|
C.TableCellElement_methods.set$text(td, "\u81f4\u547d\u4e00\u51fb");
|
|
t6 = td.style;
|
|
t6.minWidth = "112px";
|
|
t6 = type$.DivElement;
|
|
plist = t6._as(t1.querySelector(".plist"));
|
|
pbody = t6._as(t1.querySelector(".pbody"));
|
|
p = t1.createElement("div");
|
|
p.classList.add("p");
|
|
p.appendChild(tr);
|
|
pbody.appendChild(p);
|
|
plist.appendChild(pbody);
|
|
P.print(t2);
|
|
P.print(t3);
|
|
P.print(new W._FrozenElementList(t4, type$._FrozenElementList_Element));
|
|
t1.querySelector("#inputs").appendChild(t2);
|
|
P.print(_s13_);
|
|
for (a = _s13_, i = 0; i < 10; ++i)
|
|
a += " " + C.JSInt_methods.toString$0(i);
|
|
for (b = 124242424, i = 0; i < 10; ++i)
|
|
b += b * i;
|
|
P.Future_Future$delayed(new P.Duration(1000000), t5).then$1$1(new V.main_closure(), type$.Null);
|
|
new V.main_closure0().call$0();
|
|
P.print(a);
|
|
},
|
|
main_closure: function main_closure() {},
|
|
main_closure0: function main_closure0() {}
|
|
};
|
|
var holders = [C, H, J, P, W, V];
|
|
hunkHelpers.setFunctionNamesIfNecessary(holders);
|
|
var $ = {};
|
|
H.JS_CONST.prototype = {};
|
|
J.Interceptor.prototype = {
|
|
$eq: function (receiver, other) {
|
|
return receiver === other;
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
return H.Primitives_objectHashCode(receiver);
|
|
},
|
|
toString$0: function (receiver) {
|
|
return "Instance of '" + H.Primitives_objectTypeName(receiver) + "'";
|
|
}
|
|
};
|
|
J.JSBool.prototype = {
|
|
toString$0: function (receiver) {
|
|
return String(receiver);
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
return receiver ? 519018 : 218159;
|
|
},
|
|
$isbool: 1
|
|
};
|
|
J.JSNull.prototype = {
|
|
$eq: function (receiver, other) {
|
|
return null == other;
|
|
},
|
|
toString$0: function (receiver) {
|
|
return "null";
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
return 0;
|
|
},
|
|
$isNull: 1
|
|
};
|
|
J.JavaScriptObject.prototype = {
|
|
get$hashCode: function (receiver) {
|
|
return 0;
|
|
},
|
|
toString$0: function (receiver) {
|
|
return String(receiver);
|
|
}
|
|
};
|
|
J.PlainJavaScriptObject.prototype = {};
|
|
J.UnknownJavaScriptObject.prototype = {};
|
|
J.JavaScriptFunction.prototype = {
|
|
toString$0: function (receiver) {
|
|
var dartClosure = receiver[$.$get$DART_CLOSURE_PROPERTY_NAME()];
|
|
if (dartClosure == null)
|
|
return this.super$JavaScriptObject$toString(receiver);
|
|
return "JavaScript function for " + J.toString$0$(dartClosure);
|
|
},
|
|
$isFunction: 1
|
|
};
|
|
J.JSArray.prototype = {
|
|
add$1: function (receiver, value) {
|
|
H._arrayInstanceType(receiver)._precomputed1._as(value);
|
|
if (!!receiver.fixed$length)
|
|
H.throwExpression(P.UnsupportedError$("add"));
|
|
receiver.push(value);
|
|
},
|
|
toString$0: function (receiver) {
|
|
return P.IterableBase_iterableToFullString(receiver, "[", "]");
|
|
},
|
|
get$iterator: function (receiver) {
|
|
return new J.ArrayIterator(receiver, receiver.length, H._arrayInstanceType(receiver)._eval$1("ArrayIterator<1>"));
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
return H.Primitives_objectHashCode(receiver);
|
|
},
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
},
|
|
$isIterable: 1,
|
|
$isList: 1
|
|
};
|
|
J.JSUnmodifiableArray.prototype = {};
|
|
J.ArrayIterator.prototype = {
|
|
get$current: function () {
|
|
return this.$ti._precomputed1._as(this._current);
|
|
},
|
|
moveNext$0: function () {
|
|
var t2, _this = this,
|
|
t1 = _this._iterable,
|
|
$length = t1.length;
|
|
if (_this._length !== $length)
|
|
throw H.wrapException(H.throwConcurrentModificationError(t1));
|
|
t2 = _this._index;
|
|
if (t2 >= $length) {
|
|
_this.set$_current(null);
|
|
return false;
|
|
}
|
|
_this.set$_current(t1[t2]);
|
|
++_this._index;
|
|
return true;
|
|
},
|
|
set$_current: function (_current) {
|
|
this._current = this.$ti._eval$1("1?")._as(_current);
|
|
}
|
|
};
|
|
J.JSNumber.prototype = {
|
|
toString$0: function (receiver) {
|
|
if (receiver === 0 && 1 / receiver < 0)
|
|
return "-0.0";
|
|
else
|
|
return "" + receiver;
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
var absolute, floorLog2, factor, scaled,
|
|
intValue = receiver | 0;
|
|
if (receiver === intValue)
|
|
return intValue & 536870911;
|
|
absolute = Math.abs(receiver);
|
|
floorLog2 = Math.log(absolute) / 0.6931471805599453 | 0;
|
|
factor = Math.pow(2, floorLog2);
|
|
scaled = absolute < 1 ? absolute / factor : factor / absolute;
|
|
return ((scaled * 9007199254740992 | 0) + (scaled * 3542243181176521 | 0)) * 599197 + floorLog2 * 1259 & 536870911;
|
|
},
|
|
_tdivFast$1: function (receiver, other) {
|
|
return (receiver | 0) === receiver ? receiver / other | 0 : this._tdivSlow$1(receiver, other);
|
|
},
|
|
_tdivSlow$1: function (receiver, other) {
|
|
var quotient = receiver / other;
|
|
if (quotient >= -2147483648 && quotient <= 2147483647)
|
|
return quotient | 0;
|
|
if (quotient > 0) {
|
|
if (quotient !== 1 / 0)
|
|
return Math.floor(quotient);
|
|
} else if (quotient > -1 / 0)
|
|
return Math.ceil(quotient);
|
|
throw H.wrapException(P.UnsupportedError$("Result of truncating division is " + H.S(quotient) + ": " + H.S(receiver) + " ~/ " + other));
|
|
},
|
|
_shrOtherPositive$1: function (receiver, other) {
|
|
var t1;
|
|
if (receiver > 0)
|
|
t1 = this._shrBothPositive$1(receiver, other);
|
|
else {
|
|
t1 = other > 31 ? 31 : other;
|
|
t1 = receiver >> t1 >>> 0;
|
|
}
|
|
return t1;
|
|
},
|
|
_shrBothPositive$1: function (receiver, other) {
|
|
return other > 31 ? 0 : receiver >>> other;
|
|
},
|
|
$isnum: 1
|
|
};
|
|
J.JSInt.prototype = {
|
|
$isint: 1
|
|
};
|
|
J.JSDouble.prototype = {};
|
|
J.JSString.prototype = {
|
|
$add: function (receiver, other) {
|
|
return receiver + other;
|
|
},
|
|
toString$0: function (receiver) {
|
|
return receiver;
|
|
},
|
|
get$hashCode: function (receiver) {
|
|
var t1, hash, i;
|
|
for (t1 = receiver.length, hash = 0, i = 0; i < t1; ++i) {
|
|
hash = hash + receiver.charCodeAt(i) & 536870911;
|
|
hash = hash + ((hash & 524287) << 10) & 536870911;
|
|
hash ^= hash >> 6;
|
|
}
|
|
hash = hash + ((hash & 67108863) << 3) & 536870911;
|
|
hash ^= hash >> 11;
|
|
return hash + ((hash & 16383) << 15) & 536870911;
|
|
},
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
},
|
|
$isString: 1
|
|
};
|
|
H.LateError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = "LateInitializationError: " + this._message;
|
|
return t1;
|
|
}
|
|
};
|
|
H.ListIterator.prototype = {
|
|
get$current: function () {
|
|
return this.$ti._precomputed1._as(this.__internal$_current);
|
|
},
|
|
moveNext$0: function () {
|
|
var t3, _this = this,
|
|
t1 = _this.__internal$_iterable,
|
|
t2 = J.getInterceptor$asx(t1),
|
|
$length = t2.get$length(t1);
|
|
if (_this.__internal$_length !== $length)
|
|
throw H.wrapException(P.ConcurrentModificationError$(t1));
|
|
t3 = _this.__internal$_index;
|
|
if (t3 >= $length) {
|
|
_this.set$__internal$_current(null);
|
|
return false;
|
|
}
|
|
_this.set$__internal$_current(t2.elementAt$1(t1, t3));
|
|
++_this.__internal$_index;
|
|
return true;
|
|
},
|
|
set$__internal$_current: function (_current) {
|
|
this.__internal$_current = this.$ti._eval$1("1?")._as(_current);
|
|
}
|
|
};
|
|
H.TypeErrorDecoder.prototype = {
|
|
matchTypeError$1: function (message) {
|
|
var result, t1, _this = this,
|
|
match = new RegExp(_this._pattern).exec(message);
|
|
if (match == null)
|
|
return null;
|
|
result = Object.create(null);
|
|
t1 = _this._arguments;
|
|
if (t1 !== -1)
|
|
result.arguments = match[t1 + 1];
|
|
t1 = _this._argumentsExpr;
|
|
if (t1 !== -1)
|
|
result.argumentsExpr = match[t1 + 1];
|
|
t1 = _this._expr;
|
|
if (t1 !== -1)
|
|
result.expr = match[t1 + 1];
|
|
t1 = _this._method;
|
|
if (t1 !== -1)
|
|
result.method = match[t1 + 1];
|
|
t1 = _this._receiver;
|
|
if (t1 !== -1)
|
|
result.receiver = match[t1 + 1];
|
|
return result;
|
|
}
|
|
};
|
|
H.NullError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = this._method;
|
|
if (t1 == null)
|
|
return "NoSuchMethodError: " + this.__js_helper$_message;
|
|
return "NoSuchMethodError: method not found: '" + t1 + "' on null";
|
|
}
|
|
};
|
|
H.JsNoSuchMethodError.prototype = {
|
|
toString$0: function (_) {
|
|
var t2, _this = this,
|
|
_s38_ = "NoSuchMethodError: method not found: '",
|
|
t1 = _this._method;
|
|
if (t1 == null)
|
|
return "NoSuchMethodError: " + _this.__js_helper$_message;
|
|
t2 = _this._receiver;
|
|
if (t2 == null)
|
|
return _s38_ + t1 + "' (" + _this.__js_helper$_message + ")";
|
|
return _s38_ + t1 + "' on '" + t2 + "' (" + _this.__js_helper$_message + ")";
|
|
}
|
|
};
|
|
H.UnknownJsTypeError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = this.__js_helper$_message;
|
|
return t1.length === 0 ? "Error" : "Error: " + t1;
|
|
}
|
|
};
|
|
H.NullThrownFromJavaScriptException.prototype = {
|
|
toString$0: function (_) {
|
|
return "Throw of null ('" + (this._irritant === null ? "null" : "undefined") + "' from JavaScript)";
|
|
}
|
|
};
|
|
H._StackTrace.prototype = {
|
|
toString$0: function (_) {
|
|
var trace,
|
|
t1 = this._trace;
|
|
if (t1 != null)
|
|
return t1;
|
|
t1 = this._exception;
|
|
trace = t1 !== null && typeof t1 === "object" ? t1.stack : null;
|
|
return this._trace = trace == null ? "" : trace;
|
|
},
|
|
$isStackTrace: 1
|
|
};
|
|
H.Closure.prototype = {
|
|
toString$0: function (_) {
|
|
var $constructor = this.constructor,
|
|
$name = $constructor == null ? null : $constructor.name;
|
|
return "Closure '" + H.unminifyOrTag($name == null ? "unknown" : $name) + "'";
|
|
},
|
|
$isFunction: 1,
|
|
get$$call: function () {
|
|
return this;
|
|
},
|
|
"call*": "call$1",
|
|
$requiredArgCount: 1,
|
|
$defaultValues: null
|
|
};
|
|
H.TearOffClosure.prototype = {};
|
|
H.StaticClosure.prototype = {
|
|
toString$0: function (_) {
|
|
var $name = this.$static_name;
|
|
if ($name == null)
|
|
return "Closure of unknown static method";
|
|
return "Closure '" + H.unminifyOrTag($name) + "'";
|
|
}
|
|
};
|
|
H.BoundClosure.prototype = {
|
|
$eq: function (_, other) {
|
|
var _this = this;
|
|
if (other == null)
|
|
return false;
|
|
if (_this === other)
|
|
return true;
|
|
if (!(other instanceof H.BoundClosure))
|
|
return false;
|
|
return _this._self === other._self && _this._target === other._target && _this._receiver === other._receiver;
|
|
},
|
|
get$hashCode: function (_) {
|
|
var receiverHashCode,
|
|
t1 = this._receiver;
|
|
if (t1 == null)
|
|
receiverHashCode = H.Primitives_objectHashCode(this._self);
|
|
else
|
|
receiverHashCode = typeof t1 !== "object" ? J.get$hashCode$(t1) : H.Primitives_objectHashCode(t1);
|
|
return (receiverHashCode ^ H.Primitives_objectHashCode(this._target)) >>> 0;
|
|
},
|
|
toString$0: function (_) {
|
|
var receiver = this._receiver;
|
|
if (receiver == null)
|
|
receiver = this._self;
|
|
return "Closure '" + H.S(this._name) + "' of " + ("Instance of '" + H.Primitives_objectTypeName(type$.Object._as(receiver)) + "'");
|
|
}
|
|
};
|
|
H.RuntimeError.prototype = {
|
|
toString$0: function (_) {
|
|
return "RuntimeError: " + this.message;
|
|
}
|
|
};
|
|
H.JsLinkedHashMap.prototype = {
|
|
get$length: function (_) {
|
|
return this.__js_helper$_length;
|
|
},
|
|
forEach$1: function (_, action) {
|
|
var cell, modifications, _this = this;
|
|
H._instanceType(_this)._eval$1("~(1,2)")._as(action);
|
|
cell = _this._first;
|
|
modifications = _this._modifications;
|
|
for (; cell != null;) {
|
|
action.call$2(cell.hashMapCellKey, cell.hashMapCellValue);
|
|
if (modifications !== _this._modifications)
|
|
throw H.wrapException(P.ConcurrentModificationError$(_this));
|
|
cell = cell._next;
|
|
}
|
|
},
|
|
_newLinkedCell$2: function (key, value) {
|
|
var _this = this,
|
|
t1 = H._instanceType(_this),
|
|
cell = new H.LinkedHashMapCell(t1._precomputed1._as(key), t1._rest[1]._as(value));
|
|
if (_this._first == null)
|
|
_this._first = _this._last = cell;
|
|
else
|
|
_this._last = _this._last._next = cell;
|
|
++_this.__js_helper$_length;
|
|
_this._modifications = _this._modifications + 1 & 67108863;
|
|
return cell;
|
|
},
|
|
internalFindBucketIndex$2: function (bucket, key) {
|
|
var $length, i;
|
|
if (bucket == null)
|
|
return -1;
|
|
$length = bucket.length;
|
|
for (i = 0; i < $length; ++i)
|
|
if (J.$eq$(bucket[i].hashMapCellKey, key))
|
|
return i;
|
|
return -1;
|
|
},
|
|
toString$0: function (_) {
|
|
return P.MapBase_mapToString(this);
|
|
},
|
|
_getTableCell$2: function (table, key) {
|
|
return table[key];
|
|
},
|
|
_getTableBucket$2: function (table, key) {
|
|
return table[key];
|
|
},
|
|
_setTableEntry$3: function (table, key, value) {
|
|
table[key] = value;
|
|
},
|
|
_deleteTableEntry$2: function (table, key) {
|
|
delete table[key];
|
|
},
|
|
_newHashTable$0: function () {
|
|
var _s20_ = "<non-identifier-key>",
|
|
table = Object.create(null);
|
|
this._setTableEntry$3(table, _s20_, table);
|
|
this._deleteTableEntry$2(table, _s20_);
|
|
return table;
|
|
},
|
|
$isLinkedHashMap: 1
|
|
};
|
|
H.LinkedHashMapCell.prototype = {};
|
|
H.initHooks_closure.prototype = {
|
|
call$1: function (o) {
|
|
return this.getTag(o);
|
|
},
|
|
$signature: 5
|
|
};
|
|
H.initHooks_closure0.prototype = {
|
|
call$2: function (o, tag) {
|
|
return this.getUnknownTag(o, tag);
|
|
},
|
|
$signature: 6
|
|
};
|
|
H.initHooks_closure1.prototype = {
|
|
call$1: function (tag) {
|
|
return this.prototypeForTag(H._asString(tag));
|
|
},
|
|
$signature: 7
|
|
};
|
|
H.Rti.prototype = {
|
|
_eval$1: function (recipe) {
|
|
return H._Universe_evalInEnvironment(init.typeUniverse, this, recipe);
|
|
},
|
|
_bind$1: function (typeOrTuple) {
|
|
return H._Universe_bind(init.typeUniverse, this, typeOrTuple);
|
|
}
|
|
};
|
|
H._FunctionParameters.prototype = {};
|
|
H._Error.prototype = {
|
|
toString$0: function (_) {
|
|
return this.__rti$_message;
|
|
}
|
|
};
|
|
H._TypeError.prototype = {};
|
|
P._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = {
|
|
call$1: function (_) {
|
|
var t1 = this._box_0,
|
|
f = t1.storedCallback;
|
|
t1.storedCallback = null;
|
|
f.call$0();
|
|
},
|
|
$signature: 1
|
|
};
|
|
P._AsyncRun__initializeScheduleImmediate_closure.prototype = {
|
|
call$1: function (callback) {
|
|
var t1, t2;
|
|
this._box_0.storedCallback = type$.void_Function._as(callback);
|
|
t1 = this.div;
|
|
t2 = this.span;
|
|
t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2);
|
|
},
|
|
$signature: 8
|
|
};
|
|
P._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = {
|
|
call$0: function () {
|
|
this.callback.call$0();
|
|
},
|
|
$signature: 2
|
|
};
|
|
P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = {
|
|
call$0: function () {
|
|
this.callback.call$0();
|
|
},
|
|
$signature: 2
|
|
};
|
|
P._TimerImpl.prototype = {
|
|
_TimerImpl$2: function (milliseconds, callback) {
|
|
if (self.setTimeout != null)
|
|
self.setTimeout(H.convertDartClosureToJS(new P._TimerImpl_internalCallback(this, callback), 0), milliseconds);
|
|
else
|
|
throw H.wrapException(P.UnsupportedError$("`setTimeout()` not found."));
|
|
}
|
|
};
|
|
P._TimerImpl_internalCallback.prototype = {
|
|
call$0: function () {
|
|
this.callback.call$0();
|
|
},
|
|
$signature: 0
|
|
};
|
|
P.AsyncError.prototype = {
|
|
toString$0: function (_) {
|
|
return H.S(this.error);
|
|
},
|
|
$isError: 1,
|
|
get$stackTrace: function () {
|
|
return this.stackTrace;
|
|
}
|
|
};
|
|
P.Future_Future$delayed_closure.prototype = {
|
|
call$0: function () {
|
|
this.result._complete$1(this.T._as(null));
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._FutureListener.prototype = {
|
|
matchesErrorTest$1: function (asyncError) {
|
|
if ((this.state & 15) !== 6)
|
|
return true;
|
|
return this.result._zone.runUnary$2$2(type$.bool_Function_Object._as(this.callback), asyncError.error, type$.bool, type$.Object);
|
|
},
|
|
handleError$1: function (asyncError) {
|
|
var errorCallback = this.errorCallback,
|
|
t1 = type$.dynamic,
|
|
t2 = type$.Object,
|
|
t3 = asyncError.error,
|
|
t4 = this.$ti._eval$1("2/"),
|
|
t5 = this.result._zone;
|
|
if (type$.dynamic_Function_Object_StackTrace._is(errorCallback))
|
|
return t4._as(t5.runBinary$3$3(errorCallback, t3, asyncError.stackTrace, t1, t2, type$.StackTrace));
|
|
else
|
|
return t4._as(t5.runUnary$2$2(type$.dynamic_Function_Object._as(errorCallback), t3, t1, t2));
|
|
}
|
|
};
|
|
P._Future.prototype = {
|
|
then$1$2$onError: function (f, onError, $R) {
|
|
var currentZone, result, t2,
|
|
t1 = this.$ti;
|
|
t1._bind$1($R)._eval$1("1/(2)")._as(f);
|
|
currentZone = $.Zone__current;
|
|
if (currentZone !== C.C__RootZone) {
|
|
$R._eval$1("@<0/>")._bind$1(t1._precomputed1)._eval$1("1(2)")._as(f);
|
|
if (onError != null)
|
|
onError = P._registerErrorHandler(onError, currentZone);
|
|
}
|
|
result = new P._Future(currentZone, $R._eval$1("_Future<0>"));
|
|
t2 = onError == null ? 1 : 3;
|
|
this._addListener$1(new P._FutureListener(result, t2, f, onError, t1._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>")));
|
|
return result;
|
|
},
|
|
then$1$1: function (f, $R) {
|
|
return this.then$1$2$onError(f, null, $R);
|
|
},
|
|
_addListener$1: function (listener) {
|
|
var source, _this = this,
|
|
t1 = _this._state;
|
|
if (t1 <= 1) {
|
|
listener._nextListener = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
|
|
_this._resultOrListeners = listener;
|
|
} else {
|
|
if (t1 === 2) {
|
|
source = type$._Future_dynamic._as(_this._resultOrListeners);
|
|
t1 = source._state;
|
|
if (t1 < 4) {
|
|
source._addListener$1(listener);
|
|
return;
|
|
}
|
|
_this._state = t1;
|
|
_this._resultOrListeners = source._resultOrListeners;
|
|
}
|
|
P._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new P._Future__addListener_closure(_this, listener)));
|
|
}
|
|
},
|
|
_prependListeners$1: function (listeners) {
|
|
var t1, existingListeners, next, cursor, next0, source, _this = this,
|
|
_box_0 = {};
|
|
_box_0.listeners = listeners;
|
|
if (listeners == null)
|
|
return;
|
|
t1 = _this._state;
|
|
if (t1 <= 1) {
|
|
existingListeners = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
|
|
_this._resultOrListeners = listeners;
|
|
if (existingListeners != null) {
|
|
next = listeners._nextListener;
|
|
for (cursor = listeners; next != null; cursor = next, next = next0)
|
|
next0 = next._nextListener;
|
|
cursor._nextListener = existingListeners;
|
|
}
|
|
} else {
|
|
if (t1 === 2) {
|
|
source = type$._Future_dynamic._as(_this._resultOrListeners);
|
|
t1 = source._state;
|
|
if (t1 < 4) {
|
|
source._prependListeners$1(listeners);
|
|
return;
|
|
}
|
|
_this._state = t1;
|
|
_this._resultOrListeners = source._resultOrListeners;
|
|
}
|
|
_box_0.listeners = _this._reverseListeners$1(listeners);
|
|
P._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new P._Future__prependListeners_closure(_box_0, _this)));
|
|
}
|
|
},
|
|
_removeListeners$0: function () {
|
|
var current = type$.nullable__FutureListener_dynamic_dynamic._as(this._resultOrListeners);
|
|
this._resultOrListeners = null;
|
|
return this._reverseListeners$1(current);
|
|
},
|
|
_reverseListeners$1: function (listeners) {
|
|
var current, prev, next;
|
|
for (current = listeners, prev = null; current != null; prev = current, current = next) {
|
|
next = current._nextListener;
|
|
current._nextListener = prev;
|
|
}
|
|
return prev;
|
|
},
|
|
_chainForeignFuture$1: function (source) {
|
|
var e, s, exception, _this = this;
|
|
_this._state = 1;
|
|
try {
|
|
source.then$1$2$onError(new P._Future__chainForeignFuture_closure(_this), new P._Future__chainForeignFuture_closure0(_this), type$.Null);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
P.scheduleMicrotask(new P._Future__chainForeignFuture_closure1(_this, e, s));
|
|
}
|
|
},
|
|
_complete$1: function (value) {
|
|
var listeners, _this = this,
|
|
t1 = _this.$ti;
|
|
t1._eval$1("1/")._as(value);
|
|
if (t1._eval$1("Future<1>")._is(value))
|
|
_this._chainForeignFuture$1(value);
|
|
else {
|
|
listeners = _this._removeListeners$0();
|
|
t1._precomputed1._as(value);
|
|
_this._state = 4;
|
|
_this._resultOrListeners = value;
|
|
P._Future__propagateToListeners(_this, listeners);
|
|
}
|
|
},
|
|
_completeError$2: function (error, stackTrace) {
|
|
var listeners, t1, _this = this;
|
|
type$.StackTrace._as(stackTrace);
|
|
listeners = _this._removeListeners$0();
|
|
t1 = P.AsyncError$(error, stackTrace);
|
|
_this._state = 8;
|
|
_this._resultOrListeners = t1;
|
|
P._Future__propagateToListeners(_this, listeners);
|
|
},
|
|
$isFuture: 1
|
|
};
|
|
P._Future__addListener_closure.prototype = {
|
|
call$0: function () {
|
|
P._Future__propagateToListeners(this.$this, this.listener);
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._Future__prependListeners_closure.prototype = {
|
|
call$0: function () {
|
|
P._Future__propagateToListeners(this.$this, this._box_0.listeners);
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._Future__chainForeignFuture_closure.prototype = {
|
|
call$1: function (value) {
|
|
var error, stackTrace, t2, listeners, exception,
|
|
t1 = this.$this;
|
|
t1._state = 0;
|
|
try {
|
|
t2 = t1.$ti._precomputed1;
|
|
value = t2._as(t2._as(value));
|
|
listeners = t1._removeListeners$0();
|
|
t1._state = 4;
|
|
t1._resultOrListeners = value;
|
|
P._Future__propagateToListeners(t1, listeners);
|
|
} catch (exception) {
|
|
error = H.unwrapException(exception);
|
|
stackTrace = H.getTraceFromException(exception);
|
|
t1._completeError$2(error, stackTrace);
|
|
}
|
|
},
|
|
$signature: 1
|
|
};
|
|
P._Future__chainForeignFuture_closure0.prototype = {
|
|
call$2: function (error, stackTrace) {
|
|
this.$this._completeError$2(type$.Object._as(error), type$.StackTrace._as(stackTrace));
|
|
},
|
|
$signature: 9
|
|
};
|
|
P._Future__chainForeignFuture_closure1.prototype = {
|
|
call$0: function () {
|
|
this.$this._completeError$2(this.e, this.s);
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._Future__propagateToListeners_handleWhenCompleteCallback.prototype = {
|
|
call$0: function () {
|
|
var e, s, t1, exception, t2, originalSource, _this = this,
|
|
completeResult = null;
|
|
try {
|
|
t1 = _this._box_0.listener;
|
|
completeResult = t1.result._zone.run$1$1(type$.dynamic_Function._as(t1.callback), type$.dynamic);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
t1 = _this.hasError && type$.AsyncError._as(_this._box_1.source._resultOrListeners).error === e;
|
|
t2 = _this._box_0;
|
|
if (t1)
|
|
t2.listenerValueOrError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
|
|
else
|
|
t2.listenerValueOrError = P.AsyncError$(e, s);
|
|
t2.listenerHasError = true;
|
|
return;
|
|
}
|
|
if (completeResult instanceof P._Future && completeResult._state >= 4) {
|
|
if (completeResult._state === 8) {
|
|
t1 = _this._box_0;
|
|
t1.listenerValueOrError = type$.AsyncError._as(completeResult._resultOrListeners);
|
|
t1.listenerHasError = true;
|
|
}
|
|
return;
|
|
}
|
|
if (type$.Future_dynamic._is(completeResult)) {
|
|
originalSource = _this._box_1.source;
|
|
t1 = _this._box_0;
|
|
t1.listenerValueOrError = completeResult.then$1$1(new P._Future__propagateToListeners_handleWhenCompleteCallback_closure(originalSource), type$.dynamic);
|
|
t1.listenerHasError = false;
|
|
}
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = {
|
|
call$1: function (_) {
|
|
return this.originalSource;
|
|
},
|
|
$signature: 10
|
|
};
|
|
P._Future__propagateToListeners_handleValueCallback.prototype = {
|
|
call$0: function () {
|
|
var e, s, t1, t2, t3, t4, t5, exception;
|
|
try {
|
|
t1 = this._box_0;
|
|
t2 = t1.listener;
|
|
t3 = t2.$ti;
|
|
t4 = t3._precomputed1;
|
|
t5 = t4._as(this.sourceResult);
|
|
t1.listenerValueOrError = t2.result._zone.runUnary$2$2(t3._eval$1("2/(1)")._as(t2.callback), t5, t3._eval$1("2/"), t4);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
t1 = this._box_0;
|
|
t1.listenerValueOrError = P.AsyncError$(e, s);
|
|
t1.listenerHasError = true;
|
|
}
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._Future__propagateToListeners_handleError.prototype = {
|
|
call$0: function () {
|
|
var asyncError, e, s, t1, exception, t2, _this = this;
|
|
try {
|
|
asyncError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
|
|
t1 = _this._box_0;
|
|
if (t1.listener.matchesErrorTest$1(asyncError) && t1.listener.errorCallback != null) {
|
|
t1.listenerValueOrError = t1.listener.handleError$1(asyncError);
|
|
t1.listenerHasError = false;
|
|
}
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
t1 = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
|
|
t2 = _this._box_0;
|
|
if (t1.error === e)
|
|
t2.listenerValueOrError = t1;
|
|
else
|
|
t2.listenerValueOrError = P.AsyncError$(e, s);
|
|
t2.listenerHasError = true;
|
|
}
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._AsyncCallbackEntry.prototype = {};
|
|
P._Zone.prototype = {
|
|
$isZone: 1
|
|
};
|
|
P._rootHandleUncaughtError_closure.prototype = {
|
|
call$0: function () {
|
|
var error = type$.Object._as(H.wrapException(this.error));
|
|
error.stack = this.stackTrace.toString$0(0);
|
|
throw error;
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._RootZone.prototype = {
|
|
runGuarded$1: function (f) {
|
|
var e, s, exception, _null = null;
|
|
type$.void_Function._as(f);
|
|
try {
|
|
if (C.C__RootZone === $.Zone__current) {
|
|
f.call$0();
|
|
return;
|
|
}
|
|
P._rootRun(_null, _null, this, f, type$.void);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
P._rootHandleUncaughtError(_null, _null, this, type$.Object._as(e), type$.StackTrace._as(s));
|
|
}
|
|
},
|
|
bindCallback$1$1: function (f, $R) {
|
|
return new P._RootZone_bindCallback_closure(this, $R._eval$1("0()")._as(f), $R);
|
|
},
|
|
bindCallbackGuarded$1: function (f) {
|
|
return new P._RootZone_bindCallbackGuarded_closure(this, type$.void_Function._as(f));
|
|
},
|
|
run$1$1: function (f, $R) {
|
|
$R._eval$1("0()")._as(f);
|
|
if ($.Zone__current === C.C__RootZone)
|
|
return f.call$0();
|
|
return P._rootRun(null, null, this, f, $R);
|
|
},
|
|
runUnary$2$2: function (f, arg, $R, $T) {
|
|
$R._eval$1("@<0>")._bind$1($T)._eval$1("1(2)")._as(f);
|
|
$T._as(arg);
|
|
if ($.Zone__current === C.C__RootZone)
|
|
return f.call$1(arg);
|
|
return P._rootRunUnary(null, null, this, f, arg, $R, $T);
|
|
},
|
|
runBinary$3$3: function (f, arg1, arg2, $R, T1, T2) {
|
|
$R._eval$1("@<0>")._bind$1(T1)._bind$1(T2)._eval$1("1(2,3)")._as(f);
|
|
T1._as(arg1);
|
|
T2._as(arg2);
|
|
if ($.Zone__current === C.C__RootZone)
|
|
return f.call$2(arg1, arg2);
|
|
return P._rootRunBinary(null, null, this, f, arg1, arg2, $R, T1, T2);
|
|
}
|
|
};
|
|
P._RootZone_bindCallback_closure.prototype = {
|
|
call$0: function () {
|
|
return this.$this.run$1$1(this.f, this.R);
|
|
},
|
|
$signature: function () {
|
|
return this.R._eval$1("0()");
|
|
}
|
|
};
|
|
P._RootZone_bindCallbackGuarded_closure.prototype = {
|
|
call$0: function () {
|
|
return this.$this.runGuarded$1(this.f);
|
|
},
|
|
$signature: 0
|
|
};
|
|
P.ListBase.prototype = {
|
|
$isIterable: 1,
|
|
$isList: 1
|
|
};
|
|
P.ListMixin.prototype = {
|
|
get$iterator: function (receiver) {
|
|
return new H.ListIterator(receiver, this.get$length(receiver), H.instanceType(receiver)._eval$1("ListIterator<ListMixin.E>"));
|
|
},
|
|
elementAt$1: function (receiver, index) {
|
|
return this.$index(receiver, index);
|
|
},
|
|
toString$0: function (receiver) {
|
|
return P.IterableBase_iterableToFullString(receiver, "[", "]");
|
|
}
|
|
};
|
|
P.MapBase.prototype = {};
|
|
P.MapBase_mapToString_closure.prototype = {
|
|
call$2: function (k, v) {
|
|
var t2,
|
|
t1 = this._box_0;
|
|
if (!t1.first)
|
|
this.result._contents += ", ";
|
|
t1.first = false;
|
|
t1 = this.result;
|
|
t2 = t1._contents += H.S(k);
|
|
t1._contents = t2 + ": ";
|
|
t1._contents += H.S(v);
|
|
},
|
|
$signature: 11
|
|
};
|
|
P.MapMixin.prototype = {
|
|
get$length: function (_) {
|
|
return this.__js_helper$_length;
|
|
},
|
|
toString$0: function (_) {
|
|
return P.MapBase_mapToString(this);
|
|
}
|
|
};
|
|
P._ListBase_Object_ListMixin.prototype = {};
|
|
P.Duration.prototype = {
|
|
$eq: function (_, other) {
|
|
if (other == null)
|
|
return false;
|
|
return other instanceof P.Duration && this._duration === other._duration;
|
|
},
|
|
get$hashCode: function (_) {
|
|
return C.JSInt_methods.get$hashCode(this._duration);
|
|
},
|
|
toString$0: function (_) {
|
|
var twoDigitMinutes, twoDigitSeconds, sixDigitUs,
|
|
t1 = new P.Duration_toString_twoDigits(),
|
|
t2 = this._duration;
|
|
if (t2 < 0)
|
|
return "-" + new P.Duration(0 - t2).toString$0(0);
|
|
twoDigitMinutes = t1.call$1(C.JSInt_methods._tdivFast$1(t2, 60000000) % 60);
|
|
twoDigitSeconds = t1.call$1(C.JSInt_methods._tdivFast$1(t2, 1000000) % 60);
|
|
sixDigitUs = new P.Duration_toString_sixDigits().call$1(t2 % 1000000);
|
|
return "" + C.JSInt_methods._tdivFast$1(t2, 3600000000) + ":" + twoDigitMinutes + ":" + twoDigitSeconds + "." + sixDigitUs;
|
|
}
|
|
};
|
|
P.Duration_toString_sixDigits.prototype = {
|
|
call$1: function (n) {
|
|
if (n >= 100000)
|
|
return "" + n;
|
|
if (n >= 10000)
|
|
return "0" + n;
|
|
if (n >= 1000)
|
|
return "00" + n;
|
|
if (n >= 100)
|
|
return "000" + n;
|
|
if (n >= 10)
|
|
return "0000" + n;
|
|
return "00000" + n;
|
|
},
|
|
$signature: 4
|
|
};
|
|
P.Duration_toString_twoDigits.prototype = {
|
|
call$1: function (n) {
|
|
if (n >= 10)
|
|
return "" + n;
|
|
return "0" + n;
|
|
},
|
|
$signature: 4
|
|
};
|
|
P.Error.prototype = {
|
|
get$stackTrace: function () {
|
|
return H.getTraceFromException(this.$thrownJsError);
|
|
}
|
|
};
|
|
P.AssertionError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = this.message;
|
|
if (t1 != null)
|
|
return "Assertion failed: " + P.Error_safeToString(t1);
|
|
return "Assertion failed";
|
|
}
|
|
};
|
|
P.TypeError.prototype = {};
|
|
P.NullThrownError.prototype = {
|
|
toString$0: function (_) {
|
|
return "Throw of null.";
|
|
}
|
|
};
|
|
P.ArgumentError.prototype = {
|
|
get$_errorName: function () {
|
|
return "Invalid argument" + (!this._hasValue ? "(s)" : "");
|
|
},
|
|
get$_errorExplanation: function () {
|
|
return "";
|
|
},
|
|
toString$0: function (_) {
|
|
var explanation, errorValue, _this = this,
|
|
$name = _this.name,
|
|
nameString = $name == null ? "" : " (" + $name + ")",
|
|
message = _this.message,
|
|
messageString = message == null ? "" : ": " + message,
|
|
prefix = _this.get$_errorName() + nameString + messageString;
|
|
if (!_this._hasValue)
|
|
return prefix;
|
|
explanation = _this.get$_errorExplanation();
|
|
errorValue = P.Error_safeToString(_this.invalidValue);
|
|
return prefix + explanation + ": " + errorValue;
|
|
}
|
|
};
|
|
P.RangeError.prototype = {
|
|
get$_errorName: function () {
|
|
return "RangeError";
|
|
},
|
|
get$_errorExplanation: function () {
|
|
var explanation,
|
|
start = this.start,
|
|
end = this.end;
|
|
if (start == null)
|
|
explanation = end != null ? ": Not less than or equal to " + H.S(end) : "";
|
|
else if (end == null)
|
|
explanation = ": Not greater than or equal to " + H.S(start);
|
|
else if (end > start)
|
|
explanation = ": Not in inclusive range " + H.S(start) + ".." + H.S(end);
|
|
else
|
|
explanation = end < start ? ": Valid value range is empty" : ": Only valid value is " + H.S(start);
|
|
return explanation;
|
|
}
|
|
};
|
|
P.IndexError.prototype = {
|
|
get$_errorName: function () {
|
|
return "RangeError";
|
|
},
|
|
get$_errorExplanation: function () {
|
|
if (H._asInt(this.invalidValue) < 0)
|
|
return ": index must not be negative";
|
|
var t1 = this.length;
|
|
if (t1 === 0)
|
|
return ": no indices are valid";
|
|
return ": index should be less than " + t1;
|
|
},
|
|
get$length: function (receiver) {
|
|
return this.length;
|
|
}
|
|
};
|
|
P.UnsupportedError.prototype = {
|
|
toString$0: function (_) {
|
|
return "Unsupported operation: " + this.message;
|
|
}
|
|
};
|
|
P.UnimplementedError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = "UnimplementedError: " + this.message;
|
|
return t1;
|
|
}
|
|
};
|
|
P.ConcurrentModificationError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = this.modifiedObject;
|
|
if (t1 == null)
|
|
return "Concurrent modification during iteration.";
|
|
return "Concurrent modification during iteration: " + P.Error_safeToString(t1) + ".";
|
|
}
|
|
};
|
|
P.StackOverflowError.prototype = {
|
|
toString$0: function (_) {
|
|
return "Stack Overflow";
|
|
},
|
|
get$stackTrace: function () {
|
|
return null;
|
|
},
|
|
$isError: 1
|
|
};
|
|
P.CyclicInitializationError.prototype = {
|
|
toString$0: function (_) {
|
|
var t1 = "Reading static variable '" + this.variableName + "' during its initialization";
|
|
return t1;
|
|
}
|
|
};
|
|
P._Exception.prototype = {
|
|
toString$0: function (_) {
|
|
return "Exception: " + this.message;
|
|
}
|
|
};
|
|
P.Null.prototype = {
|
|
get$hashCode: function (_) {
|
|
return P.Object.prototype.get$hashCode.call(C.JSNull_methods, this);
|
|
},
|
|
toString$0: function (_) {
|
|
return "null";
|
|
}
|
|
};
|
|
P.Object.prototype = {
|
|
constructor: P.Object,
|
|
$isObject: 1,
|
|
$eq: function (_, other) {
|
|
return this === other;
|
|
},
|
|
get$hashCode: function (_) {
|
|
return H.Primitives_objectHashCode(this);
|
|
},
|
|
toString$0: function (_) {
|
|
return "Instance of '" + H.Primitives_objectTypeName(this) + "'";
|
|
},
|
|
toString: function () {
|
|
return this.toString$0(this);
|
|
}
|
|
};
|
|
P._StringStackTrace.prototype = {
|
|
toString$0: function (_) {
|
|
return "";
|
|
},
|
|
$isStackTrace: 1
|
|
};
|
|
P.StringBuffer.prototype = {
|
|
get$length: function (_) {
|
|
return this._contents.length;
|
|
},
|
|
toString$0: function (_) {
|
|
var t1 = this._contents;
|
|
return t1.charCodeAt(0) == 0 ? t1 : t1;
|
|
}
|
|
};
|
|
W.HtmlElement.prototype = {};
|
|
W.AnchorElement.prototype = {
|
|
toString$0: function (receiver) {
|
|
return String(receiver);
|
|
}
|
|
};
|
|
W.AreaElement.prototype = {
|
|
toString$0: function (receiver) {
|
|
return String(receiver);
|
|
}
|
|
};
|
|
W.CharacterData.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.CssStyleDeclaration.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.CssStyleDeclarationBase.prototype = {};
|
|
W.DivElement.prototype = {
|
|
$isDivElement: 1
|
|
};
|
|
W.DomException.prototype = {
|
|
toString$0: function (receiver) {
|
|
return String(receiver);
|
|
}
|
|
};
|
|
W.DomTokenList.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W._FrozenElementList.prototype = {
|
|
get$length: function (_) {
|
|
return this._nodeList.length;
|
|
},
|
|
$index: function (_, index) {
|
|
var t1 = this._nodeList;
|
|
if (index < 0 || index >= t1.length)
|
|
return H.ioore(t1, index);
|
|
return this.$ti._precomputed1._as(t1[index]);
|
|
}
|
|
};
|
|
W.Element.prototype = {
|
|
toString$0: function (receiver) {
|
|
return receiver.localName;
|
|
},
|
|
$isElement: 1
|
|
};
|
|
W.EventTarget.prototype = {};
|
|
W.FormElement.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.Node.prototype = {
|
|
toString$0: function (receiver) {
|
|
var value = receiver.nodeValue;
|
|
return value == null ? this.super$Interceptor$toString(receiver) : value;
|
|
},
|
|
set$text: function (receiver, value) {
|
|
receiver.textContent = value;
|
|
},
|
|
$isNode: 1
|
|
};
|
|
W.NodeList.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
},
|
|
$index: function (receiver, index) {
|
|
if (index >>> 0 !== index || index >= receiver.length)
|
|
throw H.wrapException(P.IndexError$(index, receiver, null, null, null));
|
|
return receiver[index];
|
|
},
|
|
elementAt$1: function (receiver, index) {
|
|
if (index >= receiver.length)
|
|
return H.ioore(receiver, index);
|
|
return receiver[index];
|
|
},
|
|
$isJavaScriptIndexingBehavior: 1,
|
|
$isIterable: 1,
|
|
$isList: 1
|
|
};
|
|
W.SelectElement.prototype = {
|
|
get$length: function (receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.TableCellElement.prototype = {};
|
|
W.ImmutableListMixin.prototype = {
|
|
get$iterator: function (receiver) {
|
|
return new W.FixedSizeListIterator(receiver, receiver.length, H.instanceType(receiver)._eval$1("FixedSizeListIterator<ImmutableListMixin.E>"));
|
|
}
|
|
};
|
|
W.FixedSizeListIterator.prototype = {
|
|
moveNext$0: function () {
|
|
var _this = this,
|
|
nextPosition = _this._position + 1,
|
|
t1 = _this._html$_length;
|
|
if (nextPosition < t1) {
|
|
t1 = _this._array;
|
|
if (nextPosition < 0 || nextPosition >= t1.length)
|
|
return H.ioore(t1, nextPosition);
|
|
_this.set$_html$_current(t1[nextPosition]);
|
|
_this._position = nextPosition;
|
|
return true;
|
|
}
|
|
_this.set$_html$_current(null);
|
|
_this._position = t1;
|
|
return false;
|
|
},
|
|
get$current: function () {
|
|
return this.$ti._precomputed1._as(this._html$_current);
|
|
},
|
|
set$_html$_current: function (_current) {
|
|
this._html$_current = this.$ti._eval$1("1?")._as(_current);
|
|
}
|
|
};
|
|
W._CssStyleDeclaration_Interceptor_CssStyleDeclarationBase.prototype = {};
|
|
W._NodeList_Interceptor_ListMixin.prototype = {};
|
|
W._NodeList_Interceptor_ListMixin_ImmutableListMixin.prototype = {};
|
|
V.main_closure.prototype = {
|
|
call$1: function (value) {
|
|
P.print("\u5ef6\u65f61\u79d2\u6267\u884c then ");
|
|
P.print(value);
|
|
},
|
|
$signature: 1
|
|
};
|
|
V.main_closure0.prototype = {
|
|
call$0: function () {
|
|
P.print("closuer");
|
|
},
|
|
$signature: 2
|
|
};
|
|
(function aliases() {
|
|
var _ = J.Interceptor.prototype;
|
|
_.super$Interceptor$toString = _.toString$0;
|
|
_ = J.JavaScriptObject.prototype;
|
|
_.super$JavaScriptObject$toString = _.toString$0;
|
|
})();
|
|
(function installTearOffs() {
|
|
var _static_1 = hunkHelpers._static_1,
|
|
_static_0 = hunkHelpers._static_0;
|
|
_static_1(P, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 3);
|
|
_static_1(P, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 3);
|
|
_static_1(P, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 3);
|
|
_static_0(P, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0);
|
|
})();
|
|
(function inheritance() {
|
|
var _mixin = hunkHelpers.mixin,
|
|
_inherit = hunkHelpers.inherit,
|
|
_inheritMany = hunkHelpers.inheritMany;
|
|
_inherit(P.Object, null);
|
|
_inheritMany(P.Object, [H.JS_CONST, J.Interceptor, J.ArrayIterator, P.Error, H.ListIterator, H.TypeErrorDecoder, H.NullThrownFromJavaScriptException, H._StackTrace, H.Closure, P.MapMixin, H.LinkedHashMapCell, H.Rti, H._FunctionParameters, P._TimerImpl, P.AsyncError, P._FutureListener, P._Future, P._AsyncCallbackEntry, P._Zone, P._ListBase_Object_ListMixin, P.ListMixin, P.Duration, P.StackOverflowError, P._Exception, P.Null, P._StringStackTrace, P.StringBuffer, W.CssStyleDeclarationBase, W.ImmutableListMixin, W.FixedSizeListIterator]);
|
|
_inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JSArray, J.JSNumber, J.JSString, W.EventTarget, W._CssStyleDeclaration_Interceptor_CssStyleDeclarationBase, W.DomException, W.DomTokenList, W._NodeList_Interceptor_ListMixin]);
|
|
_inheritMany(J.JavaScriptObject, [J.PlainJavaScriptObject, J.UnknownJavaScriptObject, J.JavaScriptFunction]);
|
|
_inherit(J.JSUnmodifiableArray, J.JSArray);
|
|
_inheritMany(J.JSNumber, [J.JSInt, J.JSDouble]);
|
|
_inheritMany(P.Error, [H.LateError, P.TypeError, H.JsNoSuchMethodError, H.UnknownJsTypeError, H.RuntimeError, H._Error, P.AssertionError, P.NullThrownError, P.ArgumentError, P.UnsupportedError, P.UnimplementedError, P.ConcurrentModificationError, P.CyclicInitializationError]);
|
|
_inherit(H.NullError, P.TypeError);
|
|
_inheritMany(H.Closure, [H.TearOffClosure, H.initHooks_closure, H.initHooks_closure0, H.initHooks_closure1, P._AsyncRun__initializeScheduleImmediate_internalCallback, P._AsyncRun__initializeScheduleImmediate_closure, P._AsyncRun__scheduleImmediateJsOverride_internalCallback, P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, P._TimerImpl_internalCallback, P.Future_Future$delayed_closure, P._Future__addListener_closure, P._Future__prependListeners_closure, P._Future__chainForeignFuture_closure, P._Future__chainForeignFuture_closure0, P._Future__chainForeignFuture_closure1, P._Future__propagateToListeners_handleWhenCompleteCallback, P._Future__propagateToListeners_handleWhenCompleteCallback_closure, P._Future__propagateToListeners_handleValueCallback, P._Future__propagateToListeners_handleError, P._rootHandleUncaughtError_closure, P._RootZone_bindCallback_closure, P._RootZone_bindCallbackGuarded_closure, P.MapBase_mapToString_closure, P.Duration_toString_sixDigits, P.Duration_toString_twoDigits, V.main_closure, V.main_closure0]);
|
|
_inheritMany(H.TearOffClosure, [H.StaticClosure, H.BoundClosure]);
|
|
_inherit(P.MapBase, P.MapMixin);
|
|
_inherit(H.JsLinkedHashMap, P.MapBase);
|
|
_inherit(H._TypeError, H._Error);
|
|
_inherit(P._RootZone, P._Zone);
|
|
_inherit(P.ListBase, P._ListBase_Object_ListMixin);
|
|
_inheritMany(P.ArgumentError, [P.RangeError, P.IndexError]);
|
|
_inherit(W.Node, W.EventTarget);
|
|
_inheritMany(W.Node, [W.Element, W.CharacterData]);
|
|
_inherit(W.HtmlElement, W.Element);
|
|
_inheritMany(W.HtmlElement, [W.AnchorElement, W.AreaElement, W.DivElement, W.FormElement, W.SelectElement, W.TableCellElement]);
|
|
_inherit(W.CssStyleDeclaration, W._CssStyleDeclaration_Interceptor_CssStyleDeclarationBase);
|
|
_inherit(W._FrozenElementList, P.ListBase);
|
|
_inherit(W._NodeList_Interceptor_ListMixin_ImmutableListMixin, W._NodeList_Interceptor_ListMixin);
|
|
_inherit(W.NodeList, W._NodeList_Interceptor_ListMixin_ImmutableListMixin);
|
|
_mixin(P._ListBase_Object_ListMixin, P.ListMixin);
|
|
_mixin(W._CssStyleDeclaration_Interceptor_CssStyleDeclarationBase, W.CssStyleDeclarationBase);
|
|
_mixin(W._NodeList_Interceptor_ListMixin, P.ListMixin);
|
|
_mixin(W._NodeList_Interceptor_ListMixin_ImmutableListMixin, W.ImmutableListMixin);
|
|
})();
|
|
var init = {
|
|
typeUniverse: {
|
|
eC: new Map(),
|
|
tR: {},
|
|
eT: {},
|
|
tPV: {},
|
|
sEA: []
|
|
},
|
|
mangledGlobalNames: {
|
|
int: "int",
|
|
double: "double",
|
|
num: "num",
|
|
String: "String",
|
|
bool: "bool",
|
|
Null: "Null",
|
|
List: "List"
|
|
},
|
|
mangledNames: {},
|
|
getTypeFromName: getGlobalFromName,
|
|
metadata: [],
|
|
types: ["~()", "Null(@)", "Null()", "~(~())", "String(int)", "@(@)", "@(@,String)", "@(String)", "Null(~())", "Null(Object,StackTrace)", "_Future<@>(@)", "~(Object?,Object?)"],
|
|
interceptorsByTag: null,
|
|
leafTags: null,
|
|
arrayRti: typeof Symbol == "function" && typeof Symbol() == "symbol" ? Symbol("$ti") : "$ti"
|
|
};
|
|
H._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"JavaScriptObject","UnknownJavaScriptObject":"JavaScriptObject","JavaScriptFunction":"JavaScriptObject","AElement":"Element","GraphicsElement":"Element","SvgElement":"Element","AudioElement":"HtmlElement","MediaElement":"HtmlElement","HtmlDocument":"Node","Document":"Node","CDataSection":"CharacterData","Text":"CharacterData","JSBool":{"bool":[]},"JSNull":{"Null":[]},"JavaScriptObject":{"Function":[]},"JSArray":{"List":["1"],"Iterable":["1"]},"JSUnmodifiableArray":{"JSArray":["1"],"List":["1"],"Iterable":["1"]},"JSNumber":{"num":[]},"JSInt":{"int":[],"num":[]},"JSDouble":{"num":[]},"JSString":{"String":[]},"LateError":{"Error":[]},"NullError":{"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"Closure":{"Function":[]},"TearOffClosure":{"Function":[]},"StaticClosure":{"Function":[]},"BoundClosure":{"Function":[]},"RuntimeError":{"Error":[]},"JsLinkedHashMap":{"MapMixin":["1","2"],"LinkedHashMap":["1","2"]},"_Error":{"Error":[]},"_TypeError":{"Error":[]},"AsyncError":{"Error":[]},"_Future":{"Future":["1"]},"_Zone":{"Zone":[]},"_RootZone":{"_Zone":[],"Zone":[]},"ListBase":{"ListMixin":["1"],"List":["1"],"Iterable":["1"]},"MapBase":{"MapMixin":["1","2"]},"int":{"num":[]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"NullThrownError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"StackOverflowError":{"Error":[]},"CyclicInitializationError":{"Error":[]},"_StringStackTrace":{"StackTrace":[]},"HtmlElement":{"Element":[],"Node":[]},"AnchorElement":{"Element":[],"Node":[]},"AreaElement":{"Element":[],"Node":[]},"CharacterData":{"Node":[]},"DivElement":{"Element":[],"Node":[]},"_FrozenElementList":{"ListMixin":["1"],"List":["1"],"Iterable":["1"],"ListMixin.E":"1"},"Element":{"Node":[]},"FormElement":{"Element":[],"Node":[]},"NodeList":{"ListMixin":["Node"],"ImmutableListMixin":["Node"],"List":["Node"],"JavaScriptIndexingBehavior":["Node"],"Iterable":["Node"],"ListMixin.E":"Node","ImmutableListMixin.E":"Node"},"SelectElement":{"Element":[],"Node":[]},"TableCellElement":{"Element":[],"Node":[]}}'));
|
|
H._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"ListBase":1,"MapBase":2,"_ListBase_Object_ListMixin":1}'));
|
|
0;
|
|
var type$ = (function rtii() {
|
|
var findType = H.findType;
|
|
return {
|
|
AsyncError: findType("AsyncError"),
|
|
DivElement: findType("DivElement"),
|
|
Element: findType("Element"),
|
|
Error: findType("Error"),
|
|
Function: findType("Function"),
|
|
Future_dynamic: findType("Future<@>"),
|
|
JSArray_String: findType("JSArray<String>"),
|
|
JSArray_dynamic: findType("JSArray<@>"),
|
|
JSNull: findType("JSNull"),
|
|
JavaScriptFunction: findType("JavaScriptFunction"),
|
|
JavaScriptIndexingBehavior_dynamic: findType("JavaScriptIndexingBehavior<@>"),
|
|
Null: findType("Null"),
|
|
Object: findType("Object"),
|
|
StackTrace: findType("StackTrace"),
|
|
String: findType("String"),
|
|
UnknownJavaScriptObject: findType("UnknownJavaScriptObject"),
|
|
_FrozenElementList_Element: findType("_FrozenElementList<Element>"),
|
|
_Future_dynamic: findType("_Future<@>"),
|
|
bool: findType("bool"),
|
|
bool_Function_Object: findType("bool(Object)"),
|
|
double: findType("double"),
|
|
dynamic: findType("@"),
|
|
dynamic_Function: findType("@()"),
|
|
dynamic_Function_Object: findType("@(Object)"),
|
|
dynamic_Function_Object_StackTrace: findType("@(Object,StackTrace)"),
|
|
int: findType("int"),
|
|
legacy_Never: findType("0&*"),
|
|
legacy_Object: findType("Object*"),
|
|
nullable_Future_Null: findType("Future<Null>?"),
|
|
nullable_Object: findType("Object?"),
|
|
nullable__FutureListener_dynamic_dynamic: findType("_FutureListener<@,@>?"),
|
|
num: findType("num"),
|
|
void: findType("~"),
|
|
void_Function: findType("~()")
|
|
};
|
|
})();
|
|
(function constants() {
|
|
C.Interceptor_methods = J.Interceptor.prototype;
|
|
C.JSArray_methods = J.JSArray.prototype;
|
|
C.JSInt_methods = J.JSInt.prototype;
|
|
C.JSNull_methods = J.JSNull.prototype;
|
|
C.JSString_methods = J.JSString.prototype;
|
|
C.JavaScriptFunction_methods = J.JavaScriptFunction.prototype;
|
|
C.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.prototype;
|
|
C.TableCellElement_methods = W.TableCellElement.prototype;
|
|
C.UnknownJavaScriptObject_methods = J.UnknownJavaScriptObject.prototype;
|
|
C.C_JS_CONST = function getTagFallback(o) {
|
|
var s = Object.prototype.toString.call(o);
|
|
return s.substring(8, s.length - 1);
|
|
};
|
|
C.C_JS_CONST0 = function () {
|
|
var toStringFunction = Object.prototype.toString;
|
|
|
|
function getTag(o) {
|
|
var s = toStringFunction.call(o);
|
|
return s.substring(8, s.length - 1);
|
|
}
|
|
|
|
function getUnknownTag(object, tag) {
|
|
if (/^HTML[A-Z].*Element$/.test(tag)) {
|
|
var name = toStringFunction.call(object);
|
|
if (name == "[object Object]") return null;
|
|
return "HTMLElement";
|
|
}
|
|
}
|
|
|
|
function getUnknownTagGenericBrowser(object, tag) {
|
|
if (self.HTMLElement && object instanceof HTMLElement) return "HTMLElement";
|
|
return getUnknownTag(object, tag);
|
|
}
|
|
|
|
function prototypeForTag(tag) {
|
|
if (typeof window == "undefined") return null;
|
|
if (typeof window[tag] == "undefined") return null;
|
|
var constructor = window[tag];
|
|
if (typeof constructor != "function") return null;
|
|
return constructor.prototype;
|
|
}
|
|
|
|
function discriminator(tag) {
|
|
return null;
|
|
}
|
|
var isBrowser = typeof navigator == "object";
|
|
return {
|
|
getTag: getTag,
|
|
getUnknownTag: isBrowser ? getUnknownTagGenericBrowser : getUnknownTag,
|
|
prototypeForTag: prototypeForTag,
|
|
discriminator: discriminator
|
|
};
|
|
};
|
|
C.C_JS_CONST6 = function (getTagFallback) {
|
|
return function (hooks) {
|
|
if (typeof navigator != "object") return hooks;
|
|
var ua = navigator.userAgent;
|
|
if (ua.indexOf("DumpRenderTree") >= 0) return hooks;
|
|
if (ua.indexOf("Chrome") >= 0) {
|
|
function confirm(p) {
|
|
return typeof window == "object" && window[p] && window[p].name == p;
|
|
}
|
|
if (confirm("Window") && confirm("HTMLElement")) return hooks;
|
|
}
|
|
hooks.getTag = getTagFallback;
|
|
};
|
|
};
|
|
C.C_JS_CONST1 = function (hooks) {
|
|
if (typeof dartExperimentalFixupGetTag != "function") return hooks;
|
|
hooks.getTag = dartExperimentalFixupGetTag(hooks.getTag);
|
|
};
|
|
C.C_JS_CONST2 = function (hooks) {
|
|
var getTag = hooks.getTag;
|
|
var prototypeForTag = hooks.prototypeForTag;
|
|
|
|
function getTagFixed(o) {
|
|
var tag = getTag(o);
|
|
if (tag == "Document") {
|
|
if (!!o.xmlVersion) return "!Document";
|
|
return "!HTMLDocument";
|
|
}
|
|
return tag;
|
|
}
|
|
|
|
function prototypeForTagFixed(tag) {
|
|
if (tag == "Document") return null;
|
|
return prototypeForTag(tag);
|
|
}
|
|
hooks.getTag = getTagFixed;
|
|
hooks.prototypeForTag = prototypeForTagFixed;
|
|
};
|
|
C.C_JS_CONST5 = function (hooks) {
|
|
var userAgent = typeof navigator == "object" ? navigator.userAgent : "";
|
|
if (userAgent.indexOf("Firefox") == -1) return hooks;
|
|
var getTag = hooks.getTag;
|
|
var quickMap = {
|
|
"BeforeUnloadEvent": "Event",
|
|
"DataTransfer": "Clipboard",
|
|
"GeoGeolocation": "Geolocation",
|
|
"Location": "!Location",
|
|
"WorkerMessageEvent": "MessageEvent",
|
|
"XMLDocument": "!Document"
|
|
};
|
|
|
|
function getTagFirefox(o) {
|
|
var tag = getTag(o);
|
|
return quickMap[tag] || tag;
|
|
}
|
|
hooks.getTag = getTagFirefox;
|
|
};
|
|
C.C_JS_CONST4 = function (hooks) {
|
|
var userAgent = typeof navigator == "object" ? navigator.userAgent : "";
|
|
if (userAgent.indexOf("Trident/") == -1) return hooks;
|
|
var getTag = hooks.getTag;
|
|
var quickMap = {
|
|
"BeforeUnloadEvent": "Event",
|
|
"DataTransfer": "Clipboard",
|
|
"HTMLDDElement": "HTMLElement",
|
|
"HTMLDTElement": "HTMLElement",
|
|
"HTMLPhraseElement": "HTMLElement",
|
|
"Position": "Geoposition"
|
|
};
|
|
|
|
function getTagIE(o) {
|
|
var tag = getTag(o);
|
|
var newTag = quickMap[tag];
|
|
if (newTag) return newTag;
|
|
if (tag == "Object") {
|
|
if (window.DataView && (o instanceof window.DataView)) return "DataView";
|
|
}
|
|
return tag;
|
|
}
|
|
|
|
function prototypeForTagIE(tag) {
|
|
var constructor = window[tag];
|
|
if (constructor == null) return null;
|
|
return constructor.prototype;
|
|
}
|
|
hooks.getTag = getTagIE;
|
|
hooks.prototypeForTag = prototypeForTagIE;
|
|
};
|
|
C.C_JS_CONST3 = function (hooks) {
|
|
return hooks;
|
|
};
|
|
C.C__RootZone = new P._RootZone();
|
|
C.C__StringStackTrace = new P._StringStackTrace();
|
|
C.Duration_0 = new P.Duration(0);
|
|
})();
|
|
(function staticFields() {
|
|
$._JS_INTEROP_INTERCEPTOR_TAG = null;
|
|
$.Closure_functionCounter = 0;
|
|
$.BoundClosure_selfFieldNameCache = null;
|
|
$.BoundClosure_receiverFieldNameCache = null;
|
|
$.getTagFunction = null;
|
|
$.alternateTagFunction = null;
|
|
$.prototypeForTagFunction = null;
|
|
$.dispatchRecordsForInstanceTags = null;
|
|
$.interceptorsForUncacheableTags = null;
|
|
$.initNativeDispatchFlag = null;
|
|
$._nextCallback = null;
|
|
$._lastCallback = null;
|
|
$._lastPriorityCallback = null;
|
|
$._isInCallbackLoop = false;
|
|
$.Zone__current = C.C__RootZone;
|
|
$._toStringVisiting = H.setRuntimeTypeInfo([], H.findType("JSArray<Object>"));
|
|
})();
|
|
(function lazyInitializers() {
|
|
var _lazyFinal = hunkHelpers.lazyFinal,
|
|
_lazy = hunkHelpers.lazy;
|
|
_lazyFinal($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", function () {
|
|
return H.getIsolateAffinityTag("_$dart_dartClosure");
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({
|
|
toString: function () {
|
|
return "$receiver$";
|
|
}
|
|
}));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({
|
|
$method$: null,
|
|
toString: function () {
|
|
return "$receiver$";
|
|
}
|
|
}));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(function () {
|
|
var $argumentsExpr$ = "$arguments$";
|
|
try {
|
|
null.$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(function () {
|
|
var $argumentsExpr$ = "$arguments$";
|
|
try {
|
|
(void 0).$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(function () {
|
|
try {
|
|
null.$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0));
|
|
});
|
|
_lazyFinal($, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", function () {
|
|
return H.TypeErrorDecoder_extractPattern(function () {
|
|
try {
|
|
(void 0).$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazyFinal($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", function () {
|
|
return P._AsyncRun__initializeScheduleImmediate();
|
|
});
|
|
_lazy($, "Dt_at", "$get$Dt_at", function () {
|
|
return "@";
|
|
});
|
|
})();
|
|
(function nativeSupport() {
|
|
! function () {
|
|
var intern = function (s) {
|
|
var o = {};
|
|
o[s] = 1;
|
|
return Object.keys(hunkHelpers.convertToFastObject(o))[0];
|
|
};
|
|
init.getIsolateTag = function (name) {
|
|
return intern("___dart_" + name + init.isolateTag);
|
|
};
|
|
var tableProperty = "___dart_isolate_tags_";
|
|
var usedProperties = Object[tableProperty] || (Object[tableProperty] = Object.create(null));
|
|
var rootProperty = "_ZxYxX";
|
|
for (var i = 0;; i++) {
|
|
var property = intern(rootProperty + "_" + i + "_");
|
|
if (!(property in usedProperties)) {
|
|
usedProperties[property] = 1;
|
|
init.isolateTag = property;
|
|
break;
|
|
}
|
|
}
|
|
init.dispatchPropertyName = init.getIsolateTag("dispatch_record");
|
|
}();
|
|
hunkHelpers.setOrUpdateInterceptorsByTag({
|
|
ApplicationCacheErrorEvent: J.Interceptor,
|
|
DOMError: J.Interceptor,
|
|
ErrorEvent: J.Interceptor,
|
|
Event: J.Interceptor,
|
|
InputEvent: J.Interceptor,
|
|
SubmitEvent: J.Interceptor,
|
|
MediaError: J.Interceptor,
|
|
Navigator: J.Interceptor,
|
|
NavigatorConcurrentHardware: J.Interceptor,
|
|
NavigatorUserMediaError: J.Interceptor,
|
|
OverconstrainedError: J.Interceptor,
|
|
PositionError: J.Interceptor,
|
|
SensorErrorEvent: J.Interceptor,
|
|
SpeechRecognitionError: J.Interceptor,
|
|
SQLError: J.Interceptor,
|
|
HTMLAudioElement: W.HtmlElement,
|
|
HTMLBRElement: W.HtmlElement,
|
|
HTMLBaseElement: W.HtmlElement,
|
|
HTMLBodyElement: W.HtmlElement,
|
|
HTMLButtonElement: W.HtmlElement,
|
|
HTMLCanvasElement: W.HtmlElement,
|
|
HTMLContentElement: W.HtmlElement,
|
|
HTMLDListElement: W.HtmlElement,
|
|
HTMLDataElement: W.HtmlElement,
|
|
HTMLDataListElement: W.HtmlElement,
|
|
HTMLDetailsElement: W.HtmlElement,
|
|
HTMLDialogElement: W.HtmlElement,
|
|
HTMLEmbedElement: W.HtmlElement,
|
|
HTMLFieldSetElement: W.HtmlElement,
|
|
HTMLHRElement: W.HtmlElement,
|
|
HTMLHeadElement: W.HtmlElement,
|
|
HTMLHeadingElement: W.HtmlElement,
|
|
HTMLHtmlElement: W.HtmlElement,
|
|
HTMLIFrameElement: W.HtmlElement,
|
|
HTMLImageElement: W.HtmlElement,
|
|
HTMLInputElement: W.HtmlElement,
|
|
HTMLLIElement: W.HtmlElement,
|
|
HTMLLabelElement: W.HtmlElement,
|
|
HTMLLegendElement: W.HtmlElement,
|
|
HTMLLinkElement: W.HtmlElement,
|
|
HTMLMapElement: W.HtmlElement,
|
|
HTMLMediaElement: W.HtmlElement,
|
|
HTMLMenuElement: W.HtmlElement,
|
|
HTMLMetaElement: W.HtmlElement,
|
|
HTMLMeterElement: W.HtmlElement,
|
|
HTMLModElement: W.HtmlElement,
|
|
HTMLOListElement: W.HtmlElement,
|
|
HTMLObjectElement: W.HtmlElement,
|
|
HTMLOptGroupElement: W.HtmlElement,
|
|
HTMLOptionElement: W.HtmlElement,
|
|
HTMLOutputElement: W.HtmlElement,
|
|
HTMLParagraphElement: W.HtmlElement,
|
|
HTMLParamElement: W.HtmlElement,
|
|
HTMLPictureElement: W.HtmlElement,
|
|
HTMLPreElement: W.HtmlElement,
|
|
HTMLProgressElement: W.HtmlElement,
|
|
HTMLQuoteElement: W.HtmlElement,
|
|
HTMLScriptElement: W.HtmlElement,
|
|
HTMLShadowElement: W.HtmlElement,
|
|
HTMLSlotElement: W.HtmlElement,
|
|
HTMLSourceElement: W.HtmlElement,
|
|
HTMLSpanElement: W.HtmlElement,
|
|
HTMLStyleElement: W.HtmlElement,
|
|
HTMLTableCaptionElement: W.HtmlElement,
|
|
HTMLTableColElement: W.HtmlElement,
|
|
HTMLTableElement: W.HtmlElement,
|
|
HTMLTableRowElement: W.HtmlElement,
|
|
HTMLTableSectionElement: W.HtmlElement,
|
|
HTMLTemplateElement: W.HtmlElement,
|
|
HTMLTextAreaElement: W.HtmlElement,
|
|
HTMLTimeElement: W.HtmlElement,
|
|
HTMLTitleElement: W.HtmlElement,
|
|
HTMLTrackElement: W.HtmlElement,
|
|
HTMLUListElement: W.HtmlElement,
|
|
HTMLUnknownElement: W.HtmlElement,
|
|
HTMLVideoElement: W.HtmlElement,
|
|
HTMLDirectoryElement: W.HtmlElement,
|
|
HTMLFontElement: W.HtmlElement,
|
|
HTMLFrameElement: W.HtmlElement,
|
|
HTMLFrameSetElement: W.HtmlElement,
|
|
HTMLMarqueeElement: W.HtmlElement,
|
|
HTMLElement: W.HtmlElement,
|
|
HTMLAnchorElement: W.AnchorElement,
|
|
HTMLAreaElement: W.AreaElement,
|
|
CDATASection: W.CharacterData,
|
|
CharacterData: W.CharacterData,
|
|
Comment: W.CharacterData,
|
|
ProcessingInstruction: W.CharacterData,
|
|
Text: W.CharacterData,
|
|
CSSStyleDeclaration: W.CssStyleDeclaration,
|
|
MSStyleCSSProperties: W.CssStyleDeclaration,
|
|
CSS2Properties: W.CssStyleDeclaration,
|
|
HTMLDivElement: W.DivElement,
|
|
DOMException: W.DomException,
|
|
DOMTokenList: W.DomTokenList,
|
|
SVGAElement: W.Element,
|
|
SVGAnimateElement: W.Element,
|
|
SVGAnimateMotionElement: W.Element,
|
|
SVGAnimateTransformElement: W.Element,
|
|
SVGAnimationElement: W.Element,
|
|
SVGCircleElement: W.Element,
|
|
SVGClipPathElement: W.Element,
|
|
SVGDefsElement: W.Element,
|
|
SVGDescElement: W.Element,
|
|
SVGDiscardElement: W.Element,
|
|
SVGEllipseElement: W.Element,
|
|
SVGFEBlendElement: W.Element,
|
|
SVGFEColorMatrixElement: W.Element,
|
|
SVGFEComponentTransferElement: W.Element,
|
|
SVGFECompositeElement: W.Element,
|
|
SVGFEConvolveMatrixElement: W.Element,
|
|
SVGFEDiffuseLightingElement: W.Element,
|
|
SVGFEDisplacementMapElement: W.Element,
|
|
SVGFEDistantLightElement: W.Element,
|
|
SVGFEFloodElement: W.Element,
|
|
SVGFEFuncAElement: W.Element,
|
|
SVGFEFuncBElement: W.Element,
|
|
SVGFEFuncGElement: W.Element,
|
|
SVGFEFuncRElement: W.Element,
|
|
SVGFEGaussianBlurElement: W.Element,
|
|
SVGFEImageElement: W.Element,
|
|
SVGFEMergeElement: W.Element,
|
|
SVGFEMergeNodeElement: W.Element,
|
|
SVGFEMorphologyElement: W.Element,
|
|
SVGFEOffsetElement: W.Element,
|
|
SVGFEPointLightElement: W.Element,
|
|
SVGFESpecularLightingElement: W.Element,
|
|
SVGFESpotLightElement: W.Element,
|
|
SVGFETileElement: W.Element,
|
|
SVGFETurbulenceElement: W.Element,
|
|
SVGFilterElement: W.Element,
|
|
SVGForeignObjectElement: W.Element,
|
|
SVGGElement: W.Element,
|
|
SVGGeometryElement: W.Element,
|
|
SVGGraphicsElement: W.Element,
|
|
SVGImageElement: W.Element,
|
|
SVGLineElement: W.Element,
|
|
SVGLinearGradientElement: W.Element,
|
|
SVGMarkerElement: W.Element,
|
|
SVGMaskElement: W.Element,
|
|
SVGMetadataElement: W.Element,
|
|
SVGPathElement: W.Element,
|
|
SVGPatternElement: W.Element,
|
|
SVGPolygonElement: W.Element,
|
|
SVGPolylineElement: W.Element,
|
|
SVGRadialGradientElement: W.Element,
|
|
SVGRectElement: W.Element,
|
|
SVGScriptElement: W.Element,
|
|
SVGSetElement: W.Element,
|
|
SVGStopElement: W.Element,
|
|
SVGStyleElement: W.Element,
|
|
SVGElement: W.Element,
|
|
SVGSVGElement: W.Element,
|
|
SVGSwitchElement: W.Element,
|
|
SVGSymbolElement: W.Element,
|
|
SVGTSpanElement: W.Element,
|
|
SVGTextContentElement: W.Element,
|
|
SVGTextElement: W.Element,
|
|
SVGTextPathElement: W.Element,
|
|
SVGTextPositioningElement: W.Element,
|
|
SVGTitleElement: W.Element,
|
|
SVGUseElement: W.Element,
|
|
SVGViewElement: W.Element,
|
|
SVGGradientElement: W.Element,
|
|
SVGComponentTransferFunctionElement: W.Element,
|
|
SVGFEDropShadowElement: W.Element,
|
|
SVGMPathElement: W.Element,
|
|
Element: W.Element,
|
|
Window: W.EventTarget,
|
|
DOMWindow: W.EventTarget,
|
|
EventTarget: W.EventTarget,
|
|
HTMLFormElement: W.FormElement,
|
|
Document: W.Node,
|
|
DocumentFragment: W.Node,
|
|
HTMLDocument: W.Node,
|
|
ShadowRoot: W.Node,
|
|
XMLDocument: W.Node,
|
|
Attr: W.Node,
|
|
DocumentType: W.Node,
|
|
Node: W.Node,
|
|
NodeList: W.NodeList,
|
|
RadioNodeList: W.NodeList,
|
|
HTMLSelectElement: W.SelectElement,
|
|
HTMLTableCellElement: W.TableCellElement,
|
|
HTMLTableDataCellElement: W.TableCellElement,
|
|
HTMLTableHeaderCellElement: W.TableCellElement
|
|
});
|
|
hunkHelpers.setOrUpdateLeafTags({
|
|
ApplicationCacheErrorEvent: true,
|
|
DOMError: true,
|
|
ErrorEvent: true,
|
|
Event: true,
|
|
InputEvent: true,
|
|
SubmitEvent: true,
|
|
MediaError: true,
|
|
Navigator: true,
|
|
NavigatorConcurrentHardware: true,
|
|
NavigatorUserMediaError: true,
|
|
OverconstrainedError: true,
|
|
PositionError: true,
|
|
SensorErrorEvent: true,
|
|
SpeechRecognitionError: true,
|
|
SQLError: true,
|
|
HTMLAudioElement: true,
|
|
HTMLBRElement: true,
|
|
HTMLBaseElement: true,
|
|
HTMLBodyElement: true,
|
|
HTMLButtonElement: true,
|
|
HTMLCanvasElement: true,
|
|
HTMLContentElement: true,
|
|
HTMLDListElement: true,
|
|
HTMLDataElement: true,
|
|
HTMLDataListElement: true,
|
|
HTMLDetailsElement: true,
|
|
HTMLDialogElement: true,
|
|
HTMLEmbedElement: true,
|
|
HTMLFieldSetElement: true,
|
|
HTMLHRElement: true,
|
|
HTMLHeadElement: true,
|
|
HTMLHeadingElement: true,
|
|
HTMLHtmlElement: true,
|
|
HTMLIFrameElement: true,
|
|
HTMLImageElement: true,
|
|
HTMLInputElement: true,
|
|
HTMLLIElement: true,
|
|
HTMLLabelElement: true,
|
|
HTMLLegendElement: true,
|
|
HTMLLinkElement: true,
|
|
HTMLMapElement: true,
|
|
HTMLMediaElement: true,
|
|
HTMLMenuElement: true,
|
|
HTMLMetaElement: true,
|
|
HTMLMeterElement: true,
|
|
HTMLModElement: true,
|
|
HTMLOListElement: true,
|
|
HTMLObjectElement: true,
|
|
HTMLOptGroupElement: true,
|
|
HTMLOptionElement: true,
|
|
HTMLOutputElement: true,
|
|
HTMLParagraphElement: true,
|
|
HTMLParamElement: true,
|
|
HTMLPictureElement: true,
|
|
HTMLPreElement: true,
|
|
HTMLProgressElement: true,
|
|
HTMLQuoteElement: true,
|
|
HTMLScriptElement: true,
|
|
HTMLShadowElement: true,
|
|
HTMLSlotElement: true,
|
|
HTMLSourceElement: true,
|
|
HTMLSpanElement: true,
|
|
HTMLStyleElement: true,
|
|
HTMLTableCaptionElement: true,
|
|
HTMLTableColElement: true,
|
|
HTMLTableElement: true,
|
|
HTMLTableRowElement: true,
|
|
HTMLTableSectionElement: true,
|
|
HTMLTemplateElement: true,
|
|
HTMLTextAreaElement: true,
|
|
HTMLTimeElement: true,
|
|
HTMLTitleElement: true,
|
|
HTMLTrackElement: true,
|
|
HTMLUListElement: true,
|
|
HTMLUnknownElement: true,
|
|
HTMLVideoElement: true,
|
|
HTMLDirectoryElement: true,
|
|
HTMLFontElement: true,
|
|
HTMLFrameElement: true,
|
|
HTMLFrameSetElement: true,
|
|
HTMLMarqueeElement: true,
|
|
HTMLElement: false,
|
|
HTMLAnchorElement: true,
|
|
HTMLAreaElement: true,
|
|
CDATASection: true,
|
|
CharacterData: true,
|
|
Comment: true,
|
|
ProcessingInstruction: true,
|
|
Text: true,
|
|
CSSStyleDeclaration: true,
|
|
MSStyleCSSProperties: true,
|
|
CSS2Properties: true,
|
|
HTMLDivElement: true,
|
|
DOMException: true,
|
|
DOMTokenList: true,
|
|
SVGAElement: true,
|
|
SVGAnimateElement: true,
|
|
SVGAnimateMotionElement: true,
|
|
SVGAnimateTransformElement: true,
|
|
SVGAnimationElement: true,
|
|
SVGCircleElement: true,
|
|
SVGClipPathElement: true,
|
|
SVGDefsElement: true,
|
|
SVGDescElement: true,
|
|
SVGDiscardElement: true,
|
|
SVGEllipseElement: true,
|
|
SVGFEBlendElement: true,
|
|
SVGFEColorMatrixElement: true,
|
|
SVGFEComponentTransferElement: true,
|
|
SVGFECompositeElement: true,
|
|
SVGFEConvolveMatrixElement: true,
|
|
SVGFEDiffuseLightingElement: true,
|
|
SVGFEDisplacementMapElement: true,
|
|
SVGFEDistantLightElement: true,
|
|
SVGFEFloodElement: true,
|
|
SVGFEFuncAElement: true,
|
|
SVGFEFuncBElement: true,
|
|
SVGFEFuncGElement: true,
|
|
SVGFEFuncRElement: true,
|
|
SVGFEGaussianBlurElement: true,
|
|
SVGFEImageElement: true,
|
|
SVGFEMergeElement: true,
|
|
SVGFEMergeNodeElement: true,
|
|
SVGFEMorphologyElement: true,
|
|
SVGFEOffsetElement: true,
|
|
SVGFEPointLightElement: true,
|
|
SVGFESpecularLightingElement: true,
|
|
SVGFESpotLightElement: true,
|
|
SVGFETileElement: true,
|
|
SVGFETurbulenceElement: true,
|
|
SVGFilterElement: true,
|
|
SVGForeignObjectElement: true,
|
|
SVGGElement: true,
|
|
SVGGeometryElement: true,
|
|
SVGGraphicsElement: true,
|
|
SVGImageElement: true,
|
|
SVGLineElement: true,
|
|
SVGLinearGradientElement: true,
|
|
SVGMarkerElement: true,
|
|
SVGMaskElement: true,
|
|
SVGMetadataElement: true,
|
|
SVGPathElement: true,
|
|
SVGPatternElement: true,
|
|
SVGPolygonElement: true,
|
|
SVGPolylineElement: true,
|
|
SVGRadialGradientElement: true,
|
|
SVGRectElement: true,
|
|
SVGScriptElement: true,
|
|
SVGSetElement: true,
|
|
SVGStopElement: true,
|
|
SVGStyleElement: true,
|
|
SVGElement: true,
|
|
SVGSVGElement: true,
|
|
SVGSwitchElement: true,
|
|
SVGSymbolElement: true,
|
|
SVGTSpanElement: true,
|
|
SVGTextContentElement: true,
|
|
SVGTextElement: true,
|
|
SVGTextPathElement: true,
|
|
SVGTextPositioningElement: true,
|
|
SVGTitleElement: true,
|
|
SVGUseElement: true,
|
|
SVGViewElement: true,
|
|
SVGGradientElement: true,
|
|
SVGComponentTransferFunctionElement: true,
|
|
SVGFEDropShadowElement: true,
|
|
SVGMPathElement: true,
|
|
Element: false,
|
|
Window: true,
|
|
DOMWindow: true,
|
|
EventTarget: false,
|
|
HTMLFormElement: true,
|
|
Document: true,
|
|
DocumentFragment: true,
|
|
HTMLDocument: true,
|
|
ShadowRoot: true,
|
|
XMLDocument: true,
|
|
Attr: true,
|
|
DocumentType: true,
|
|
Node: false,
|
|
NodeList: true,
|
|
RadioNodeList: true,
|
|
HTMLSelectElement: true,
|
|
HTMLTableCellElement: true,
|
|
HTMLTableDataCellElement: true,
|
|
HTMLTableHeaderCellElement: true
|
|
});
|
|
})();
|
|
convertAllToFastObject(holders);
|
|
convertToFastObject($);
|
|
(function (callback) {
|
|
if (typeof document === "undefined") {
|
|
callback(null);
|
|
return;
|
|
}
|
|
if (typeof document.currentScript != "undefined") {
|
|
callback(document.currentScript);
|
|
return;
|
|
}
|
|
var scripts = document.scripts;
|
|
|
|
function onLoad(event) {
|
|
for (var i = 0; i < scripts.length; ++i)
|
|
scripts[i].removeEventListener("load", onLoad, false);
|
|
callback(event.target);
|
|
}
|
|
for (var i = 0; i < scripts.length; ++i)
|
|
scripts[i].addEventListener("load", onLoad, false);
|
|
})(function (currentScript) {
|
|
init.currentScript = currentScript;
|
|
var callMain = V.main;
|
|
if (typeof dartMainRunner === "function")
|
|
dartMainRunner(callMain, []);
|
|
else
|
|
callMain([]);
|
|
});
|
|
})();
|
|
|
|
//# sourceMappingURL=out.js.map
|