4487 lines
180 KiB
JavaScript
4487 lines
180 KiB
JavaScript
// Generated by dart2js (fast startup emitter, strong), the Dart to JavaScript compiler version: 2.9.2.
|
|
// 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];
|
|
}
|
|
}
|
|
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) {
|
|
copyProperties(mixin.prototype, cls.prototype);
|
|
cls.prototype.constructor = cls;
|
|
}
|
|
function lazy(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 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, 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() {
|
|
},
|
|
unminifyOrTag: function(rawClassName) {
|
|
var preserved = H.unmangleGlobalNameIfPreservedAnyways(rawClassName);
|
|
if (preserved != null)
|
|
return preserved;
|
|
return rawClassName;
|
|
},
|
|
S: function(value) {
|
|
var res;
|
|
if (typeof value == "string")
|
|
return value;
|
|
if (typeof value == "number") {
|
|
if (value !== 0)
|
|
return "" + value;
|
|
} else if (true === value)
|
|
return "true";
|
|
else if (false === value)
|
|
return "false";
|
|
else if (value == null)
|
|
return "null";
|
|
res = J.toString$0$(value);
|
|
if (typeof res != "string")
|
|
throw H.wrapException(H.argumentErrorValue(value));
|
|
return res;
|
|
},
|
|
Primitives_parseInt: function(source, radix) {
|
|
var match, decimalMatch;
|
|
if (typeof source != "string")
|
|
H.throwExpression(H.argumentErrorValue(source));
|
|
match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
|
|
if (match == null)
|
|
return null;
|
|
if (3 >= match.length)
|
|
return H.ioore(match, 3);
|
|
decimalMatch = match[3];
|
|
if (decimalMatch != null)
|
|
return parseInt(source, 10);
|
|
if (match[2] != null)
|
|
return parseInt(source, 16);
|
|
return null;
|
|
},
|
|
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;
|
|
},
|
|
iae: function(argument) {
|
|
throw H.wrapException(H.argumentErrorValue(argument));
|
|
},
|
|
ioore: function(receiver, index) {
|
|
if (receiver == null)
|
|
J.get$length$asx(receiver);
|
|
throw H.wrapException(H.diagnoseIndexError(receiver, index));
|
|
},
|
|
diagnoseIndexError: function(indexable, index) {
|
|
var t1, $length, t2, _s5_ = "index";
|
|
if (!H._isInt(index))
|
|
return new P.ArgumentError(true, index, _s5_, null);
|
|
t1 = J.getInterceptor$asx(indexable);
|
|
$length = H._asIntS(t1.get$length(indexable));
|
|
if (!(index < 0)) {
|
|
if (typeof $length !== "number")
|
|
return H.iae($length);
|
|
t2 = index >= $length;
|
|
} else
|
|
t2 = true;
|
|
if (t2) {
|
|
t1 = H._asIntS($length == null ? t1.get$length(indexable) : $length);
|
|
return new P.IndexError(t1, true, index, _s5_, "Index out of range");
|
|
}
|
|
return P.RangeError$value(index, _s5_);
|
|
},
|
|
argumentErrorValue: function(object) {
|
|
return new P.ArgumentError(true, object, null, null);
|
|
},
|
|
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(new 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._asStringS(message), match));
|
|
else {
|
|
match = notClosure.matchTypeError$1(message);
|
|
if (match != null) {
|
|
match.method = "call";
|
|
return H.saveStackTrace(ex, H.JsNoSuchMethodError$(H._asStringS(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._asStringS(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);
|
|
},
|
|
invokeClosure: function(closure, numberOfArguments, arg1, arg2, arg3, arg4) {
|
|
type$.Function._as(closure);
|
|
switch (H._asIntS(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;
|
|
if (closure == null)
|
|
return null;
|
|
$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;
|
|
}
|
|
$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.S(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.S(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." + H.S(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." + H.S(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 names, i, $name,
|
|
template = new H.BoundClosure("self", "target", "receiver", "name"),
|
|
t1 = Object.getOwnPropertyNames(template);
|
|
t1.fixed$length = Array;
|
|
names = t1;
|
|
for (t1 = names.length, i = 0; i < t1; ++i) {
|
|
$name = names[i];
|
|
if (template[$name] === fieldName)
|
|
return $name;
|
|
}
|
|
throw H.wrapException(P.ArgumentError$("Field name " + fieldName + " not found."));
|
|
},
|
|
boolConversionCheck: function(value) {
|
|
if (value == null)
|
|
H.assertThrow("boolean expression must not be null");
|
|
return value;
|
|
},
|
|
assertThrow: function(message) {
|
|
throw H.wrapException(new H._AssertionError(message));
|
|
},
|
|
throwCyclicInit: function(staticName) {
|
|
throw H.wrapException(new P.CyclicInitializationError(staticName));
|
|
},
|
|
getIsolateAffinityTag: function($name) {
|
|
return init.getIsolateTag($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._asStringS($.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._message = t0;
|
|
this._method = t1;
|
|
},
|
|
JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) {
|
|
this._message = t0;
|
|
this._method = t1;
|
|
this._receiver = t2;
|
|
},
|
|
UnknownJsTypeError: function UnknownJsTypeError(t0) {
|
|
this._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;
|
|
_.__js_helper$_target = t1;
|
|
_._receiver = t2;
|
|
_._name = t3;
|
|
},
|
|
RuntimeError: function RuntimeError(t0) {
|
|
this.message = t0;
|
|
},
|
|
_AssertionError: function _AssertionError(t0) {
|
|
this.message = t0;
|
|
},
|
|
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._asIntS(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 unstarred, isFn, testRti = this,
|
|
t1 = type$.Object;
|
|
if (testRti === t1)
|
|
return H._finishIsFn(testRti, object, H._isObject);
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = testRti === t1;
|
|
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, asFn, testRti = this;
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = testRti === type$.Object;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
asFn = H._asTop;
|
|
else if (testRti === type$.Object)
|
|
asFn = H._asObject;
|
|
else
|
|
asFn = H._generalNullableAsCheckImplementation;
|
|
testRti._as = asFn;
|
|
return testRti._as(object);
|
|
},
|
|
_nullIs: function(testRti) {
|
|
var t2,
|
|
t1 = testRti._kind;
|
|
if (!H.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t2 = testRti === type$.Object;
|
|
else
|
|
t2 = true;
|
|
else
|
|
t2 = true;
|
|
return t2 || testRti === type$.legacy_Never || t1 === 7 || testRti === type$.Null || testRti === type$.JSNull;
|
|
},
|
|
_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 t1 = this,
|
|
tag = t1._specializedTestResource;
|
|
if (object instanceof P.Object)
|
|
return !!object[tag];
|
|
return !!J.getInterceptor$(object)[tag];
|
|
},
|
|
_generalAsCheckImplementation: function(object) {
|
|
var testRti = this;
|
|
if (object == null)
|
|
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))));
|
|
},
|
|
_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 '" + H.S(objectTypeDescription) + "' is not a subtype of type '" + H.S(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) {
|
|
return 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 += C.JSString_methods.$add(sep, H._rtiToString(array[i], genericContext));
|
|
return s;
|
|
},
|
|
_functionRtiToString: function(functionType, genericContext, bounds) {
|
|
var boundsLength, outerContextLength, offset, i, t1, t2, t3, typeParametersText, typeSep, t4, t5, 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, t3 = type$.Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) {
|
|
typeParametersText += typeSep;
|
|
t4 = genericContext.length;
|
|
t5 = t4 - 1 - i;
|
|
if (t5 < 0)
|
|
return H.ioore(genericContext, t5);
|
|
typeParametersText = C.JSString_methods.$add(typeParametersText, genericContext[t5]);
|
|
boundRti = bounds[i];
|
|
kind = boundRti._kind;
|
|
if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1))
|
|
if (!(boundRti === t2))
|
|
t4 = boundRti === t3;
|
|
else
|
|
t4 = true;
|
|
else
|
|
t4 = true;
|
|
if (!t4)
|
|
typeParametersText += C.JSString_methods.$add(" 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 += C.JSString_methods.$add(sep, H._rtiToString(requiredPositional[i], genericContext));
|
|
if (optionalPositionalLength > 0) {
|
|
argumentsText += sep + "[";
|
|
for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_)
|
|
argumentsText += C.JSString_methods.$add(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 += J.$add$ns(H._rtiToString(named[i + 2], genericContext), " ") + named[i];
|
|
}
|
|
argumentsText += "}";
|
|
}
|
|
if (outerContextLength != null) {
|
|
genericContext.toString;
|
|
genericContext.length = outerContextLength;
|
|
}
|
|
return typeParametersText + "(" + argumentsText + ") => " + H.S(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 J.$add$ns(argumentKind === 11 || argumentKind === 12 ? C.JSString_methods.$add("(", s) + ")" : s, "?");
|
|
}
|
|
if (kind === 8)
|
|
return "FutureOr<" + H.S(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) {
|
|
genericContext.toString;
|
|
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,
|
|
metadata = universe.eT,
|
|
probe = metadata[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);
|
|
metadata[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,
|
|
cache = universe.eC,
|
|
probe = cache.get(recipe);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = H._Parser_parse(H._Parser_create(universe, null, recipe, normalize));
|
|
cache.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 = baseType === type$.Object;
|
|
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 t1, i, ch, universe, array, head, base, u, parameters, optionalPositional, named, item,
|
|
source = parser.r,
|
|
stack = parser.s;
|
|
for (t1 = source.length, i = 0; i < t1;) {
|
|
ch = source.charCodeAt(i);
|
|
if (ch >= 48 && ch <= 57)
|
|
i = H._Parser_handleDigit(i + 1, ch, source, stack);
|
|
else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36)
|
|
i = H._Parser_handleIdentifier(parser, i, source, stack, false);
|
|
else if (ch === 46)
|
|
i = H._Parser_handleIdentifier(parser, i, source, stack, true);
|
|
else {
|
|
++i;
|
|
switch (ch) {
|
|
case 44:
|
|
break;
|
|
case 58:
|
|
stack.push(false);
|
|
break;
|
|
case 33:
|
|
stack.push(true);
|
|
break;
|
|
case 59:
|
|
stack.push(H._Parser_toType(parser.u, parser.e, stack.pop()));
|
|
break;
|
|
case 94:
|
|
stack.push(H._Universe__lookupGenericFunctionParameterRti(parser.u, stack.pop()));
|
|
break;
|
|
case 35:
|
|
stack.push(H._Universe__lookupTerminalRti(parser.u, 5, "#"));
|
|
break;
|
|
case 64:
|
|
stack.push(H._Universe__lookupTerminalRti(parser.u, 2, "@"));
|
|
break;
|
|
case 126:
|
|
stack.push(H._Universe__lookupTerminalRti(parser.u, 3, "~"));
|
|
break;
|
|
case 60:
|
|
stack.push(parser.p);
|
|
parser.p = stack.length;
|
|
break;
|
|
case 62:
|
|
universe = parser.u;
|
|
array = stack.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = stack.pop();
|
|
head = stack.pop();
|
|
if (typeof head == "string")
|
|
stack.push(H._Universe__lookupInterfaceRti(universe, head, array));
|
|
else {
|
|
base = H._Parser_toType(universe, parser.e, head);
|
|
switch (base._kind) {
|
|
case 11:
|
|
stack.push(H._Universe__lookupGenericFunctionRti(universe, base, array, parser.n));
|
|
break;
|
|
default:
|
|
stack.push(H._Universe__lookupBindingRti(universe, base, array));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 38:
|
|
H._Parser_handleExtendedOperations(parser, stack);
|
|
break;
|
|
case 42:
|
|
u = parser.u;
|
|
stack.push(H._Universe__lookupStarRti(u, H._Parser_toType(u, parser.e, stack.pop()), parser.n));
|
|
break;
|
|
case 63:
|
|
u = parser.u;
|
|
stack.push(H._Universe__lookupQuestionRti(u, H._Parser_toType(u, parser.e, stack.pop()), parser.n));
|
|
break;
|
|
case 47:
|
|
u = parser.u;
|
|
stack.push(H._Universe__lookupFutureOrRti(u, H._Parser_toType(u, parser.e, stack.pop()), parser.n));
|
|
break;
|
|
case 40:
|
|
stack.push(parser.p);
|
|
parser.p = stack.length;
|
|
break;
|
|
case 41:
|
|
universe = parser.u;
|
|
parameters = new H._FunctionParameters();
|
|
optionalPositional = universe.sEA;
|
|
named = universe.sEA;
|
|
head = stack.pop();
|
|
if (typeof head == "number")
|
|
switch (head) {
|
|
case -1:
|
|
optionalPositional = stack.pop();
|
|
break;
|
|
case -2:
|
|
named = stack.pop();
|
|
break;
|
|
default:
|
|
stack.push(head);
|
|
break;
|
|
}
|
|
else
|
|
stack.push(head);
|
|
array = stack.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = stack.pop();
|
|
parameters._requiredPositional = array;
|
|
parameters._optionalPositional = optionalPositional;
|
|
parameters._named = named;
|
|
stack.push(H._Universe__lookupFunctionRti(universe, H._Parser_toType(universe, parser.e, stack.pop()), parameters));
|
|
break;
|
|
case 91:
|
|
stack.push(parser.p);
|
|
parser.p = stack.length;
|
|
break;
|
|
case 93:
|
|
array = stack.splice(parser.p);
|
|
H._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = stack.pop();
|
|
stack.push(array);
|
|
stack.push(-1);
|
|
break;
|
|
case 123:
|
|
stack.push(parser.p);
|
|
parser.p = stack.length;
|
|
break;
|
|
case 125:
|
|
array = stack.splice(parser.p);
|
|
H._Parser_toTypesNamed(parser.u, parser.e, array);
|
|
parser.p = stack.pop();
|
|
stack.push(array);
|
|
stack.push(-2);
|
|
break;
|
|
default:
|
|
throw "Bad character " + ch;
|
|
}
|
|
}
|
|
}
|
|
item = stack.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 = t === type$.Object;
|
|
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 = s === type$.Null || s === type$.JSNull;
|
|
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;
|
|
if (sKind === 6)
|
|
return H._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
if (tKind === 6) {
|
|
t1 = t._primary;
|
|
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, s._primary, sEnv, t, tEnv);
|
|
return t1;
|
|
}
|
|
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, t._primary, tEnv);
|
|
return t1;
|
|
}
|
|
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 = t === type$.Object;
|
|
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];
|
|
}
|
|
},
|
|
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;
|
|
},
|
|
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$ns: function(receiver) {
|
|
if (typeof receiver == "number")
|
|
return J.JSNumber.prototype;
|
|
if (typeof receiver == "string")
|
|
return J.JSString.prototype;
|
|
if (receiver == null)
|
|
return receiver;
|
|
if (!(receiver instanceof P.Object))
|
|
return J.UnknownJavaScriptObject.prototype;
|
|
return receiver;
|
|
},
|
|
getInterceptor$x: function(receiver) {
|
|
if (receiver == null)
|
|
return receiver;
|
|
if (typeof receiver != "object") {
|
|
if (typeof receiver == "function")
|
|
return J.JavaScriptFunction.prototype;
|
|
return receiver;
|
|
}
|
|
if (receiver instanceof P.Object)
|
|
return receiver;
|
|
return J.getNativeInterceptor(receiver);
|
|
},
|
|
set$text$x: function(receiver, value) {
|
|
return J.getInterceptor$x(receiver).set$text(receiver, value);
|
|
},
|
|
get$length$asx: function(receiver) {
|
|
return J.getInterceptor$asx(receiver).get$length(receiver);
|
|
},
|
|
get$onClick$x: function(receiver) {
|
|
return J.getInterceptor$x(receiver).get$onClick(receiver);
|
|
},
|
|
$add$ns: function(receiver, a0) {
|
|
if (typeof receiver == "number" && typeof a0 == "number")
|
|
return receiver + a0;
|
|
return J.getInterceptor$ns(receiver).$add(receiver, a0);
|
|
},
|
|
_addEventListener$3$x: function(receiver, a0, a1, a2) {
|
|
return J.getInterceptor$x(receiver)._addEventListener$3(receiver, a0, a1, a2);
|
|
},
|
|
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) {
|
|
type$.void_Function._as(callback);
|
|
P._TimerImpl$(0, callback);
|
|
},
|
|
_TimerImpl$: function(milliseconds, callback) {
|
|
var t1 = new P._TimerImpl();
|
|
t1._TimerImpl$2(milliseconds, callback);
|
|
return t1;
|
|
},
|
|
_Future__chainForeignFuture: function(source, target) {
|
|
var e, s, exception;
|
|
target._state = 1;
|
|
try {
|
|
source.then$1$2$onError(new P._Future__chainForeignFuture_closure(target), new P._Future__chainForeignFuture_closure0(target), type$.Null);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
P.scheduleMicrotask(new P._Future__chainForeignFuture_closure1(target, e, s));
|
|
}
|
|
},
|
|
_Future__chainCoreFuture: function(source, target) {
|
|
var 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)) {
|
|
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 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)));
|
|
},
|
|
AsyncError$: function(error, stackTrace) {
|
|
var t1 = stackTrace == null ? P.AsyncError_defaultStackTrace(error) : stackTrace;
|
|
if (error == null)
|
|
H.throwExpression(new P.ArgumentError(false, null, "error", "Must not be null"));
|
|
return new P.AsyncError(error, t1);
|
|
},
|
|
AsyncError_defaultStackTrace: function(error) {
|
|
var stackTrace;
|
|
if (type$.Error._is(error)) {
|
|
stackTrace = error.get$stackTrace();
|
|
if (stackTrace != null)
|
|
return stackTrace;
|
|
}
|
|
return C.C__StringStackTrace;
|
|
},
|
|
_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;
|
|
},
|
|
_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.target = t0;
|
|
},
|
|
_Future__chainForeignFuture_closure0: function _Future__chainForeignFuture_closure0(t0) {
|
|
this.target = t0;
|
|
},
|
|
_Future__chainForeignFuture_closure1: function _Future__chainForeignFuture_closure1(t0, t1, t2) {
|
|
this.target = 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;
|
|
},
|
|
Stream: function Stream() {
|
|
},
|
|
Stream_length_closure: function Stream_length_closure(t0, t1) {
|
|
this._box_0 = t0;
|
|
this.$this = t1;
|
|
},
|
|
Stream_length_closure0: function Stream_length_closure0(t0, t1) {
|
|
this._box_0 = t0;
|
|
this.future = t1;
|
|
},
|
|
StreamSubscription: function StreamSubscription() {
|
|
},
|
|
AsyncError: function AsyncError(t0, t1) {
|
|
this.error = t0;
|
|
this.stackTrace = t1;
|
|
},
|
|
_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;
|
|
},
|
|
_RootZone_bindUnaryCallbackGuarded_closure: function _RootZone_bindUnaryCallbackGuarded_closure(t0, t1, t2) {
|
|
this.$this = t0;
|
|
this.f = t1;
|
|
this.T = t2;
|
|
},
|
|
int_parse: function(source) {
|
|
var value = H.Primitives_parseInt(source, null);
|
|
if (value != null)
|
|
return value;
|
|
throw H.wrapException(new P.FormatException(source));
|
|
},
|
|
Error__objectToString: function(object) {
|
|
if (object instanceof H.Closure)
|
|
return object.toString$0(0);
|
|
return "Instance of '" + H.S(H.Primitives_objectTypeName(object)) + "'";
|
|
},
|
|
StringBuffer__writeAll: function(string, objects, separator) {
|
|
var iterator = new J.ArrayIterator(objects, objects.length, H._arrayInstanceType(objects)._eval$1("ArrayIterator<1>"));
|
|
if (!iterator.moveNext$0())
|
|
return string;
|
|
if (separator.length === 0) {
|
|
do
|
|
string += H.S(iterator._current);
|
|
while (iterator.moveNext$0());
|
|
} else {
|
|
string += H.S(iterator._current);
|
|
for (; iterator.moveNext$0();)
|
|
string = string + separator + H.S(iterator._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");
|
|
},
|
|
UnsupportedError$: function(message) {
|
|
return new P.UnsupportedError(message);
|
|
},
|
|
UnimplementedError$: function(message) {
|
|
return new P.UnimplementedError(message);
|
|
},
|
|
bool: function bool() {
|
|
},
|
|
double: function double() {
|
|
},
|
|
Error: function Error() {
|
|
},
|
|
AssertionError: function AssertionError(t0) {
|
|
this.message = t0;
|
|
},
|
|
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;
|
|
},
|
|
FormatException: function FormatException(t0) {
|
|
this.message = t0;
|
|
},
|
|
int: function int() {
|
|
},
|
|
List: function List() {
|
|
},
|
|
Null: function Null() {
|
|
},
|
|
num: function num() {
|
|
},
|
|
Object: function Object() {
|
|
},
|
|
StackTrace: function StackTrace() {
|
|
},
|
|
_StringStackTrace: function _StringStackTrace() {
|
|
},
|
|
String: function String() {
|
|
},
|
|
StringBuffer: function StringBuffer(t0) {
|
|
this._contents = t0;
|
|
},
|
|
SvgElement: function SvgElement() {
|
|
},
|
|
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;
|
|
}
|
|
},
|
|
W = {
|
|
_EventStreamSubscription$: function(_target, _eventType, onData, _useCapture, $T) {
|
|
var t1 = W._wrapZone(new W._EventStreamSubscription_closure(onData), type$.Event),
|
|
t2 = t1 != null;
|
|
if (t2 && true) {
|
|
type$.nullable_dynamic_Function_Event._as(t1);
|
|
if (t2)
|
|
J._addEventListener$3$x(_target, _eventType, t1, false);
|
|
}
|
|
return new W._EventStreamSubscription(_target, _eventType, t1, false, $T._eval$1("_EventStreamSubscription<0>"));
|
|
},
|
|
_wrapZone: function(callback, $T) {
|
|
var t1 = $.Zone__current;
|
|
if (t1 === C.C__RootZone)
|
|
return callback;
|
|
return t1.bindUnaryCallbackGuarded$1$1(callback, $T);
|
|
},
|
|
HtmlElement: function HtmlElement() {
|
|
},
|
|
AnchorElement: function AnchorElement() {
|
|
},
|
|
AreaElement: function AreaElement() {
|
|
},
|
|
DomException: function DomException() {
|
|
},
|
|
Element: function Element() {
|
|
},
|
|
Event: function Event() {
|
|
},
|
|
EventTarget: function EventTarget() {
|
|
},
|
|
FormElement: function FormElement() {
|
|
},
|
|
InputElement: function InputElement() {
|
|
},
|
|
MouseEvent: function MouseEvent() {
|
|
},
|
|
Node: function Node() {
|
|
},
|
|
SelectElement: function SelectElement() {
|
|
},
|
|
UIEvent: function UIEvent() {
|
|
},
|
|
EventStreamProvider: function EventStreamProvider(t0) {
|
|
this.$ti = t0;
|
|
},
|
|
_EventStream: function _EventStream() {
|
|
},
|
|
_ElementEventStreamImpl: function _ElementEventStreamImpl(t0, t1, t2, t3) {
|
|
var _ = this;
|
|
_._target = t0;
|
|
_._eventType = t1;
|
|
_._useCapture = t2;
|
|
_.$ti = t3;
|
|
},
|
|
_EventStreamSubscription: function _EventStreamSubscription(t0, t1, t2, t3, t4) {
|
|
var _ = this;
|
|
_._target = t0;
|
|
_._eventType = t1;
|
|
_._onData = t2;
|
|
_._useCapture = t3;
|
|
_.$ti = t4;
|
|
},
|
|
_EventStreamSubscription_closure: function _EventStreamSubscription_closure(t0) {
|
|
this.onData = t0;
|
|
}
|
|
},
|
|
F = {
|
|
main: function() {
|
|
var t1 = J.get$onClick$x(document.querySelector("#button")),
|
|
t2 = t1.$ti;
|
|
t2._eval$1("~(1)?")._as(F.main__getSum$closure());
|
|
type$.nullable_void_Function._as(null);
|
|
W._EventStreamSubscription$(t1._target, t1._eventType, F.main__getSum$closure(), false, t2._precomputed1);
|
|
},
|
|
getSum: function($event) {
|
|
var t1, t2, num1, num2, sum;
|
|
type$.legacy_MouseEvent._as($event);
|
|
t1 = document;
|
|
t2 = type$.legacy_InputElement;
|
|
num1 = P.int_parse(t2._as(t1.querySelector("#num1")).value);
|
|
num2 = P.int_parse(t2._as(t1.querySelector("#num2")).value);
|
|
if (typeof num1 !== "number")
|
|
return num1.$add();
|
|
if (typeof num2 !== "number")
|
|
return H.iae(num2);
|
|
sum = C.JSInt_methods.toString$0(num1 + num2);
|
|
J.set$text$x(t1.querySelector("#sum"), "" + num1 + " + " + num2 + " = " + sum);
|
|
}
|
|
};
|
|
var holders = [C, H, J, P, W, F];
|
|
hunkHelpers.setFunctionNamesIfNecessary(holders);
|
|
var $ = {};
|
|
H.JS_CONST.prototype = {};
|
|
J.Interceptor.prototype = {
|
|
toString$0: function(receiver) {
|
|
return "Instance of '" + H.S(H.Primitives_objectTypeName(receiver)) + "'";
|
|
}
|
|
};
|
|
J.JSBool.prototype = {
|
|
toString$0: function(receiver) {
|
|
return String(receiver);
|
|
},
|
|
$isbool: 1
|
|
};
|
|
J.JSNull.prototype = {
|
|
toString$0: function(receiver) {
|
|
return "null";
|
|
},
|
|
$isNull: 1
|
|
};
|
|
J.JavaScriptObject.prototype = {
|
|
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 " + H.S(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$length: function(receiver) {
|
|
return receiver.length;
|
|
},
|
|
$isIterable: 1
|
|
};
|
|
J.JSUnmodifiableArray.prototype = {};
|
|
J.ArrayIterator.prototype = {
|
|
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;
|
|
},
|
|
_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) {
|
|
if (typeof other != "string")
|
|
throw H.wrapException(P.ArgumentError$value(other, null, null));
|
|
return receiver + other;
|
|
},
|
|
toString$0: function(receiver) {
|
|
return receiver;
|
|
},
|
|
get$length: function(receiver) {
|
|
return receiver.length;
|
|
},
|
|
$isString: 1
|
|
};
|
|
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: " + H.S(this._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: " + H.S(_this._message);
|
|
t2 = _this._receiver;
|
|
if (t2 == null)
|
|
return _s38_ + t1 + "' (" + H.S(_this._message) + ")";
|
|
return _s38_ + t1 + "' on '" + t2 + "' (" + H.S(_this._message) + ")";
|
|
}
|
|
};
|
|
H.UnknownJsTypeError.prototype = {
|
|
toString$0: function(_) {
|
|
var t1 = this._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 = {
|
|
toString$0: function(_) {
|
|
var receiver = this._receiver;
|
|
if (receiver == null)
|
|
receiver = this._self;
|
|
return "Closure '" + H.S(this._name) + "' of " + ("Instance of '" + H.S(H.Primitives_objectTypeName(receiver)) + "'");
|
|
}
|
|
};
|
|
H.RuntimeError.prototype = {
|
|
toString$0: function(_) {
|
|
return "RuntimeError: " + this.message;
|
|
}
|
|
};
|
|
H._AssertionError.prototype = {
|
|
toString$0: function(_) {
|
|
return "Assertion failed: " + P.Error_safeToString(this.message);
|
|
}
|
|
};
|
|
H.initHooks_closure.prototype = {
|
|
call$1: function(o) {
|
|
return this.getTag(o);
|
|
},
|
|
$signature: 4
|
|
};
|
|
H.initHooks_closure0.prototype = {
|
|
call$2: function(o, tag) {
|
|
return this.getUnknownTag(o, tag);
|
|
},
|
|
$signature: 5
|
|
};
|
|
H.initHooks_closure1.prototype = {
|
|
call$1: function(tag) {
|
|
return this.prototypeForTag(H._asStringS(tag));
|
|
},
|
|
$signature: 6
|
|
};
|
|
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: 3
|
|
};
|
|
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: 7
|
|
};
|
|
P._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = {
|
|
call$0: function() {
|
|
this.callback.call$0();
|
|
},
|
|
$signature: 0
|
|
};
|
|
P._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = {
|
|
call$0: function() {
|
|
this.callback.call$0();
|
|
},
|
|
$signature: 0
|
|
};
|
|
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: 1
|
|
};
|
|
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 = this.$ti._eval$1("2/"),
|
|
t4 = this.result._zone;
|
|
if (type$.dynamic_Function_Object_StackTrace._is(errorCallback))
|
|
return t3._as(t4.runBinary$3$3(errorCallback, asyncError.error, asyncError.stackTrace, t1, t2, type$.StackTrace));
|
|
else
|
|
return t3._as(t4.runUnary$2$2(type$.dynamic_Function_Object._as(errorCallback), asyncError.error, 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($.Zone__current, $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;
|
|
},
|
|
_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))
|
|
if (t1._is(value))
|
|
P._Future__chainCoreFuture(value, _this);
|
|
else
|
|
P._Future__chainForeignFuture(value, _this);
|
|
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 t1 = this.target;
|
|
t1._state = 0;
|
|
t1._complete$1(value);
|
|
},
|
|
$signature: 3
|
|
};
|
|
P._Future__chainForeignFuture_closure0.prototype = {
|
|
call$2: function(error, stackTrace) {
|
|
this.target._completeError$2(error, type$.StackTrace._as(stackTrace));
|
|
},
|
|
$signature: 8
|
|
};
|
|
P._Future__chainForeignFuture_closure1.prototype = {
|
|
call$0: function() {
|
|
this.target._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);
|
|
if (_this.hasError) {
|
|
t1 = type$.AsyncError._as(_this._box_1.source._resultOrListeners).error;
|
|
t2 = e;
|
|
t2 = t1 == null ? t2 == null : t1 === t2;
|
|
t1 = t2;
|
|
} else
|
|
t1 = false;
|
|
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: 1
|
|
};
|
|
P._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = {
|
|
call$1: function(_) {
|
|
return this.originalSource;
|
|
},
|
|
$signature: 9
|
|
};
|
|
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: 1
|
|
};
|
|
P._Future__propagateToListeners_handleError.prototype = {
|
|
call$0: function() {
|
|
var asyncError, e, s, t1, exception, t2, t3, t4, _this = this;
|
|
try {
|
|
asyncError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
|
|
t1 = _this._box_0;
|
|
if (H.boolConversionCheck(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 = t1.error;
|
|
t3 = e;
|
|
t4 = _this._box_0;
|
|
if (t2 == null ? t3 == null : t2 === t3)
|
|
t4.listenerValueOrError = t1;
|
|
else
|
|
t4.listenerValueOrError = P.AsyncError$(e, s);
|
|
t4.listenerHasError = true;
|
|
}
|
|
},
|
|
$signature: 1
|
|
};
|
|
P._AsyncCallbackEntry.prototype = {};
|
|
P.Stream.prototype = {
|
|
get$length: function(_) {
|
|
var t2, t3, _this = this, t1 = {},
|
|
future = new P._Future($.Zone__current, type$._Future_int);
|
|
t1.count = 0;
|
|
t2 = _this.$ti;
|
|
t3 = t2._eval$1("~(1)?")._as(new P.Stream_length_closure(t1, _this));
|
|
type$.nullable_void_Function._as(new P.Stream_length_closure0(t1, future));
|
|
W._EventStreamSubscription$(_this._target, _this._eventType, t3, false, t2._precomputed1);
|
|
return future;
|
|
}
|
|
};
|
|
P.Stream_length_closure.prototype = {
|
|
call$1: function(_) {
|
|
this.$this.$ti._precomputed1._as(_);
|
|
++this._box_0.count;
|
|
},
|
|
$signature: function() {
|
|
return this.$this.$ti._eval$1("Null(1)");
|
|
}
|
|
};
|
|
P.Stream_length_closure0.prototype = {
|
|
call$0: function() {
|
|
this.future._complete$1(this._box_0.count);
|
|
},
|
|
$signature: 0
|
|
};
|
|
P.StreamSubscription.prototype = {};
|
|
P.AsyncError.prototype = {
|
|
toString$0: function(_) {
|
|
return H.S(this.error);
|
|
},
|
|
$isError: 1,
|
|
get$stackTrace: function() {
|
|
return this.stackTrace;
|
|
}
|
|
};
|
|
P._Zone.prototype = {$isZone: 1};
|
|
P._rootHandleUncaughtError_closure.prototype = {
|
|
call$0: function() {
|
|
var error = H.wrapException(this.error);
|
|
error.stack = J.toString$0$(this.stackTrace);
|
|
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, e, type$.StackTrace._as(s));
|
|
}
|
|
},
|
|
runUnaryGuarded$1$2: function(f, arg, $T) {
|
|
var e, s, exception, _null = null;
|
|
$T._eval$1("~(0)")._as(f);
|
|
$T._as(arg);
|
|
try {
|
|
if (C.C__RootZone === $.Zone__current) {
|
|
f.call$1(arg);
|
|
return;
|
|
}
|
|
P._rootRunUnary(_null, _null, this, f, arg, type$.void, $T);
|
|
} catch (exception) {
|
|
e = H.unwrapException(exception);
|
|
s = H.getTraceFromException(exception);
|
|
P._rootHandleUncaughtError(_null, _null, this, 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));
|
|
},
|
|
bindUnaryCallbackGuarded$1$1: function(f, $T) {
|
|
return new P._RootZone_bindUnaryCallbackGuarded_closure(this, $T._eval$1("~(0)")._as(f), $T);
|
|
},
|
|
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: 1
|
|
};
|
|
P._RootZone_bindUnaryCallbackGuarded_closure.prototype = {
|
|
call$1: function(arg) {
|
|
var t1 = this.T;
|
|
return this.$this.runUnaryGuarded$1$2(this.f, t1._as(arg), t1);
|
|
},
|
|
$signature: function() {
|
|
return this.T._eval$1("~(0)");
|
|
}
|
|
};
|
|
P.bool.prototype = {};
|
|
P.double.prototype = {};
|
|
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.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() {
|
|
var t1,
|
|
invalidValue = H._asIntS(this.invalidValue);
|
|
if (typeof invalidValue !== "number")
|
|
return invalidValue.$lt();
|
|
if (invalidValue < 0)
|
|
return ": index must not be negative";
|
|
t1 = this.length;
|
|
if (t1 === 0)
|
|
return ": no indices are valid";
|
|
return ": index should be less than " + H.S(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 message = this.message;
|
|
return message != null ? "UnimplementedError: " + message : "UnimplementedError";
|
|
}
|
|
};
|
|
P.ConcurrentModificationError.prototype = {
|
|
toString$0: function(_) {
|
|
return "Concurrent modification during iteration: " + P.Error_safeToString(this.modifiedObject) + ".";
|
|
}
|
|
};
|
|
P.StackOverflowError.prototype = {
|
|
toString$0: function(_) {
|
|
return "Stack Overflow";
|
|
},
|
|
get$stackTrace: function() {
|
|
return null;
|
|
},
|
|
$isError: 1
|
|
};
|
|
P.CyclicInitializationError.prototype = {
|
|
toString$0: function(_) {
|
|
var variableName = this.variableName;
|
|
return variableName == null ? "Reading static variable during its initialization" : "Reading static variable '" + variableName + "' during its initialization";
|
|
}
|
|
};
|
|
P._Exception.prototype = {
|
|
toString$0: function(_) {
|
|
return "Exception: " + this.message;
|
|
}
|
|
};
|
|
P.FormatException.prototype = {
|
|
toString$0: function(_) {
|
|
var message = this.message,
|
|
report = message != null && "" !== message ? "FormatException: " + H.S(message) : "FormatException";
|
|
return report;
|
|
}
|
|
};
|
|
P.int.prototype = {};
|
|
P.List.prototype = {$isIterable: 1};
|
|
P.Null.prototype = {
|
|
toString$0: function(_) {
|
|
return "null";
|
|
}
|
|
};
|
|
P.num.prototype = {};
|
|
P.Object.prototype = {constructor: P.Object, $isObject: 1,
|
|
toString$0: function(_) {
|
|
return "Instance of '" + H.S(H.Primitives_objectTypeName(this)) + "'";
|
|
},
|
|
toString: function() {
|
|
return this.toString$0(this);
|
|
}
|
|
};
|
|
P.StackTrace.prototype = {};
|
|
P._StringStackTrace.prototype = {
|
|
toString$0: function(_) {
|
|
return "";
|
|
},
|
|
$isStackTrace: 1
|
|
};
|
|
P.String.prototype = {};
|
|
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.DomException.prototype = {
|
|
toString$0: function(receiver) {
|
|
return String(receiver);
|
|
}
|
|
};
|
|
W.Element.prototype = {
|
|
toString$0: function(receiver) {
|
|
return receiver.localName;
|
|
},
|
|
get$onClick: function(receiver) {
|
|
return new W._ElementEventStreamImpl(receiver, "click", false, type$._ElementEventStreamImpl_legacy_MouseEvent);
|
|
},
|
|
$isElement: 1
|
|
};
|
|
W.Event.prototype = {$isEvent: 1};
|
|
W.EventTarget.prototype = {
|
|
_addEventListener$3: function(receiver, type, listener, options) {
|
|
return receiver.addEventListener(type, H.convertDartClosureToJS(type$.nullable_dynamic_Function_Event._as(listener), 1), false);
|
|
},
|
|
$isEventTarget: 1
|
|
};
|
|
W.FormElement.prototype = {
|
|
get$length: function(receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.InputElement.prototype = {$isInputElement: 1};
|
|
W.MouseEvent.prototype = {$isMouseEvent: 1};
|
|
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;
|
|
}
|
|
};
|
|
W.SelectElement.prototype = {
|
|
get$length: function(receiver) {
|
|
return receiver.length;
|
|
}
|
|
};
|
|
W.UIEvent.prototype = {};
|
|
W.EventStreamProvider.prototype = {};
|
|
W._EventStream.prototype = {};
|
|
W._ElementEventStreamImpl.prototype = {};
|
|
W._EventStreamSubscription.prototype = {};
|
|
W._EventStreamSubscription_closure.prototype = {
|
|
call$1: function(e) {
|
|
return this.onData.call$1(type$.Event._as(e));
|
|
},
|
|
$signature: 10
|
|
};
|
|
P.SvgElement.prototype = {
|
|
get$onClick: function(receiver) {
|
|
return new W._ElementEventStreamImpl(receiver, "click", false, type$._ElementEventStreamImpl_legacy_MouseEvent);
|
|
}
|
|
};
|
|
(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", 2);
|
|
_static_1(P, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 2);
|
|
_static_1(P, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 2);
|
|
_static_0(P, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 1);
|
|
_static_1(F, "main__getSum$closure", "getSum", 11);
|
|
})();
|
|
(function inheritance() {
|
|
var _inherit = hunkHelpers.inherit,
|
|
_inheritMany = hunkHelpers.inheritMany;
|
|
_inherit(P.Object, null);
|
|
_inheritMany(P.Object, [H.JS_CONST, J.Interceptor, J.ArrayIterator, H.TypeErrorDecoder, P.Error, H.NullThrownFromJavaScriptException, H._StackTrace, H.Closure, H.Rti, H._FunctionParameters, P._TimerImpl, P._FutureListener, P._Future, P._AsyncCallbackEntry, P.Stream, P.StreamSubscription, P.AsyncError, P._Zone, P.bool, P.num, P.StackOverflowError, P._Exception, P.FormatException, P.List, P.Null, P.StackTrace, P._StringStackTrace, P.String, P.StringBuffer, W.EventStreamProvider]);
|
|
_inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JSArray, J.JSNumber, J.JSString, W.EventTarget, W.DomException, W.Event]);
|
|
_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.NullError, H.JsNoSuchMethodError, H.UnknownJsTypeError, H.RuntimeError, P.AssertionError, H._Error, P.NullThrownError, P.ArgumentError, P.UnsupportedError, P.UnimplementedError, P.ConcurrentModificationError, P.CyclicInitializationError]);
|
|
_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__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.Stream_length_closure, P.Stream_length_closure0, P._rootHandleUncaughtError_closure, P._RootZone_bindCallback_closure, P._RootZone_bindCallbackGuarded_closure, P._RootZone_bindUnaryCallbackGuarded_closure, W._EventStreamSubscription_closure]);
|
|
_inheritMany(H.TearOffClosure, [H.StaticClosure, H.BoundClosure]);
|
|
_inherit(H._AssertionError, P.AssertionError);
|
|
_inherit(H._TypeError, H._Error);
|
|
_inherit(P._RootZone, P._Zone);
|
|
_inheritMany(P.num, [P.double, P.int]);
|
|
_inheritMany(P.ArgumentError, [P.RangeError, P.IndexError]);
|
|
_inherit(W.Node, W.EventTarget);
|
|
_inherit(W.Element, W.Node);
|
|
_inheritMany(W.Element, [W.HtmlElement, P.SvgElement]);
|
|
_inheritMany(W.HtmlElement, [W.AnchorElement, W.AreaElement, W.FormElement, W.InputElement, W.SelectElement]);
|
|
_inherit(W.UIEvent, W.Event);
|
|
_inherit(W.MouseEvent, W.UIEvent);
|
|
_inherit(W._EventStream, P.Stream);
|
|
_inherit(W._ElementEventStreamImpl, W._EventStream);
|
|
_inherit(W._EventStreamSubscription, P.StreamSubscription);
|
|
})();
|
|
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)", "@(String)", "Null(~())", "Null(Object,StackTrace)", "_Future<@>(@)", "@(Event)", "~(MouseEvent*)"],
|
|
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","AbortPaymentEvent":"Event","ExtendableEvent":"Event","AElement":"SvgElement","GraphicsElement":"SvgElement","AudioElement":"HtmlElement","MediaElement":"HtmlElement","PointerEvent":"MouseEvent","CompositionEvent":"UIEvent","HtmlDocument":"Node","Document":"Node","JSBool":{"bool":[]},"JSNull":{"Null":[]},"JavaScriptObject":{"Function":[]},"JSArray":{"Iterable":["1"]},"JSUnmodifiableArray":{"JSArray":["1"],"Iterable":["1"]},"JSNumber":{"num":[]},"JSInt":{"int":[],"num":[]},"JSDouble":{"num":[]},"JSString":{"String":[]},"NullError":{"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"Closure":{"Function":[]},"TearOffClosure":{"Function":[]},"StaticClosure":{"Function":[]},"BoundClosure":{"Function":[]},"RuntimeError":{"Error":[]},"_AssertionError":{"Error":[]},"_Error":{"Error":[]},"_TypeError":{"Error":[]},"_Future":{"Future":["1"]},"AsyncError":{"Error":[]},"_Zone":{"Zone":[]},"_RootZone":{"_Zone":[],"Zone":[]},"double":{"num":[]},"AssertionError":{"Error":[]},"NullThrownError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"UnsupportedError":{"Error":[]},"UnimplementedError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"StackOverflowError":{"Error":[]},"CyclicInitializationError":{"Error":[]},"int":{"num":[]},"List":{"Iterable":["1"]},"_StringStackTrace":{"StackTrace":[]},"HtmlElement":{"Element":[],"EventTarget":[]},"AnchorElement":{"Element":[],"EventTarget":[]},"AreaElement":{"Element":[],"EventTarget":[]},"Element":{"EventTarget":[]},"FormElement":{"Element":[],"EventTarget":[]},"InputElement":{"Element":[],"EventTarget":[]},"MouseEvent":{"Event":[]},"Node":{"EventTarget":[]},"SelectElement":{"Element":[],"EventTarget":[]},"UIEvent":{"Event":[]},"_EventStream":{"Stream":["1"]},"_ElementEventStreamImpl":{"_EventStream":["1"],"Stream":["1"]},"SvgElement":{"Element":[],"EventTarget":[]}}'));
|
|
H._Universe_addErasedTypes(init.typeUniverse, JSON.parse('{"StreamSubscription":1}'));
|
|
0;
|
|
var type$ = (function rtii() {
|
|
var findType = H.findType;
|
|
return {
|
|
AsyncError: findType("AsyncError"),
|
|
Error: findType("Error"),
|
|
Event: findType("Event"),
|
|
Function: findType("Function"),
|
|
Future_dynamic: findType("Future<@>"),
|
|
JSArray_String: findType("JSArray<String>"),
|
|
JSArray_dynamic: findType("JSArray<@>"),
|
|
JSNull: findType("JSNull"),
|
|
JavaScriptFunction: findType("JavaScriptFunction"),
|
|
Null: findType("Null"),
|
|
Object: findType("Object"),
|
|
StackTrace: findType("StackTrace"),
|
|
String: findType("String"),
|
|
UnknownJavaScriptObject: findType("UnknownJavaScriptObject"),
|
|
_ElementEventStreamImpl_legacy_MouseEvent: findType("_ElementEventStreamImpl<MouseEvent*>"),
|
|
_Future_dynamic: findType("_Future<@>"),
|
|
_Future_int: findType("_Future<int>"),
|
|
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_InputElement: findType("InputElement*"),
|
|
legacy_MouseEvent: findType("MouseEvent*"),
|
|
legacy_Never: findType("0&*"),
|
|
legacy_Object: findType("Object*"),
|
|
nullable_Future_Null: findType("Future<Null>?"),
|
|
nullable_Object: findType("Object?"),
|
|
nullable__FutureListener_dynamic_dynamic: findType("_FutureListener<@,@>?"),
|
|
nullable_dynamic_Function_Event: findType("@(Event)?"),
|
|
nullable_void_Function: findType("~()?"),
|
|
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.JSString_methods = J.JSString.prototype;
|
|
C.JavaScriptFunction_methods = J.JavaScriptFunction.prototype;
|
|
C.PlainJavaScriptObject_methods = J.PlainJavaScriptObject.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();
|
|
})();
|
|
(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 _lazy = hunkHelpers.lazy;
|
|
_lazy($, "DART_CLOSURE_PROPERTY_NAME", "$get$DART_CLOSURE_PROPERTY_NAME", function() {
|
|
return H.getIsolateAffinityTag("_$dart_dartClosure");
|
|
});
|
|
_lazy($, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({
|
|
toString: function() {
|
|
return "$receiver$";
|
|
}
|
|
}));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn({$method$: null,
|
|
toString: function() {
|
|
return "$receiver$";
|
|
}
|
|
}));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(null));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(function() {
|
|
var $argumentsExpr$ = '$arguments$';
|
|
try {
|
|
null.$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazy($, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokeCallErrorOn(void 0));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(function() {
|
|
var $argumentsExpr$ = '$arguments$';
|
|
try {
|
|
(void 0).$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazy($, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(null));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(function() {
|
|
try {
|
|
null.$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazy($, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(H.TypeErrorDecoder_provokePropertyErrorOn(void 0));
|
|
});
|
|
_lazy($, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", function() {
|
|
return H.TypeErrorDecoder_extractPattern(function() {
|
|
try {
|
|
(void 0).$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}());
|
|
});
|
|
_lazy($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", function() {
|
|
return P._AsyncRun__initializeScheduleImmediate();
|
|
});
|
|
})();
|
|
(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({DOMError: J.Interceptor, MediaError: J.Interceptor, NavigatorUserMediaError: J.Interceptor, OverconstrainedError: J.Interceptor, PositionError: 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, HTMLDivElement: 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, 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, HTMLTableCellElement: W.HtmlElement, HTMLTableDataCellElement: W.HtmlElement, HTMLTableHeaderCellElement: 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, DOMException: W.DomException, Element: W.Element, AbortPaymentEvent: W.Event, AnimationEvent: W.Event, AnimationPlaybackEvent: W.Event, ApplicationCacheErrorEvent: W.Event, BackgroundFetchClickEvent: W.Event, BackgroundFetchEvent: W.Event, BackgroundFetchFailEvent: W.Event, BackgroundFetchedEvent: W.Event, BeforeInstallPromptEvent: W.Event, BeforeUnloadEvent: W.Event, BlobEvent: W.Event, CanMakePaymentEvent: W.Event, ClipboardEvent: W.Event, CloseEvent: W.Event, CustomEvent: W.Event, DeviceMotionEvent: W.Event, DeviceOrientationEvent: W.Event, ErrorEvent: W.Event, ExtendableEvent: W.Event, ExtendableMessageEvent: W.Event, FetchEvent: W.Event, FontFaceSetLoadEvent: W.Event, ForeignFetchEvent: W.Event, GamepadEvent: W.Event, HashChangeEvent: W.Event, InstallEvent: W.Event, MediaEncryptedEvent: W.Event, MediaKeyMessageEvent: W.Event, MediaQueryListEvent: W.Event, MediaStreamEvent: W.Event, MediaStreamTrackEvent: W.Event, MessageEvent: W.Event, MIDIConnectionEvent: W.Event, MIDIMessageEvent: W.Event, MutationEvent: W.Event, NotificationEvent: W.Event, PageTransitionEvent: W.Event, PaymentRequestEvent: W.Event, PaymentRequestUpdateEvent: W.Event, PopStateEvent: W.Event, PresentationConnectionAvailableEvent: W.Event, PresentationConnectionCloseEvent: W.Event, ProgressEvent: W.Event, PromiseRejectionEvent: W.Event, PushEvent: W.Event, RTCDataChannelEvent: W.Event, RTCDTMFToneChangeEvent: W.Event, RTCPeerConnectionIceEvent: W.Event, RTCTrackEvent: W.Event, SecurityPolicyViolationEvent: W.Event, SensorErrorEvent: W.Event, SpeechRecognitionError: W.Event, SpeechRecognitionEvent: W.Event, SpeechSynthesisEvent: W.Event, StorageEvent: W.Event, SyncEvent: W.Event, TrackEvent: W.Event, TransitionEvent: W.Event, WebKitTransitionEvent: W.Event, VRDeviceEvent: W.Event, VRDisplayEvent: W.Event, VRSessionEvent: W.Event, MojoInterfaceRequestEvent: W.Event, ResourceProgressEvent: W.Event, USBConnectionEvent: W.Event, IDBVersionChangeEvent: W.Event, AudioProcessingEvent: W.Event, OfflineAudioCompletionEvent: W.Event, WebGLContextEvent: W.Event, Event: W.Event, InputEvent: W.Event, SubmitEvent: W.Event, EventTarget: W.EventTarget, HTMLFormElement: W.FormElement, HTMLInputElement: W.InputElement, MouseEvent: W.MouseEvent, DragEvent: W.MouseEvent, PointerEvent: W.MouseEvent, WheelEvent: W.MouseEvent, Document: W.Node, HTMLDocument: W.Node, Node: W.Node, HTMLSelectElement: W.SelectElement, CompositionEvent: W.UIEvent, FocusEvent: W.UIEvent, KeyboardEvent: W.UIEvent, TextEvent: W.UIEvent, TouchEvent: W.UIEvent, UIEvent: W.UIEvent, SVGAElement: P.SvgElement, SVGAnimateElement: P.SvgElement, SVGAnimateMotionElement: P.SvgElement, SVGAnimateTransformElement: P.SvgElement, SVGAnimationElement: P.SvgElement, SVGCircleElement: P.SvgElement, SVGClipPathElement: P.SvgElement, SVGDefsElement: P.SvgElement, SVGDescElement: P.SvgElement, SVGDiscardElement: P.SvgElement, SVGEllipseElement: P.SvgElement, SVGFEBlendElement: P.SvgElement, SVGFEColorMatrixElement: P.SvgElement, SVGFEComponentTransferElement: P.SvgElement, SVGFECompositeElement: P.SvgElement, SVGFEConvolveMatrixElement: P.SvgElement, SVGFEDiffuseLightingElement: P.SvgElement, SVGFEDisplacementMapElement: P.SvgElement, SVGFEDistantLightElement: P.SvgElement, SVGFEFloodElement: P.SvgElement, SVGFEFuncAElement: P.SvgElement, SVGFEFuncBElement: P.SvgElement, SVGFEFuncGElement: P.SvgElement, SVGFEFuncRElement: P.SvgElement, SVGFEGaussianBlurElement: P.SvgElement, SVGFEImageElement: P.SvgElement, SVGFEMergeElement: P.SvgElement, SVGFEMergeNodeElement: P.SvgElement, SVGFEMorphologyElement: P.SvgElement, SVGFEOffsetElement: P.SvgElement, SVGFEPointLightElement: P.SvgElement, SVGFESpecularLightingElement: P.SvgElement, SVGFESpotLightElement: P.SvgElement, SVGFETileElement: P.SvgElement, SVGFETurbulenceElement: P.SvgElement, SVGFilterElement: P.SvgElement, SVGForeignObjectElement: P.SvgElement, SVGGElement: P.SvgElement, SVGGeometryElement: P.SvgElement, SVGGraphicsElement: P.SvgElement, SVGImageElement: P.SvgElement, SVGLineElement: P.SvgElement, SVGLinearGradientElement: P.SvgElement, SVGMarkerElement: P.SvgElement, SVGMaskElement: P.SvgElement, SVGMetadataElement: P.SvgElement, SVGPathElement: P.SvgElement, SVGPatternElement: P.SvgElement, SVGPolygonElement: P.SvgElement, SVGPolylineElement: P.SvgElement, SVGRadialGradientElement: P.SvgElement, SVGRectElement: P.SvgElement, SVGScriptElement: P.SvgElement, SVGSetElement: P.SvgElement, SVGStopElement: P.SvgElement, SVGStyleElement: P.SvgElement, SVGElement: P.SvgElement, SVGSVGElement: P.SvgElement, SVGSwitchElement: P.SvgElement, SVGSymbolElement: P.SvgElement, SVGTSpanElement: P.SvgElement, SVGTextContentElement: P.SvgElement, SVGTextElement: P.SvgElement, SVGTextPathElement: P.SvgElement, SVGTextPositioningElement: P.SvgElement, SVGTitleElement: P.SvgElement, SVGUseElement: P.SvgElement, SVGViewElement: P.SvgElement, SVGGradientElement: P.SvgElement, SVGComponentTransferFunctionElement: P.SvgElement, SVGFEDropShadowElement: P.SvgElement, SVGMPathElement: P.SvgElement});
|
|
hunkHelpers.setOrUpdateLeafTags({DOMError: true, MediaError: true, NavigatorUserMediaError: true, OverconstrainedError: true, PositionError: 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, HTMLDivElement: true, HTMLEmbedElement: true, HTMLFieldSetElement: true, HTMLHRElement: true, HTMLHeadElement: true, HTMLHeadingElement: true, HTMLHtmlElement: true, HTMLIFrameElement: true, HTMLImageElement: 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, HTMLTableCellElement: true, HTMLTableDataCellElement: true, HTMLTableHeaderCellElement: 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, DOMException: true, Element: false, AbortPaymentEvent: true, AnimationEvent: true, AnimationPlaybackEvent: true, ApplicationCacheErrorEvent: true, BackgroundFetchClickEvent: true, BackgroundFetchEvent: true, BackgroundFetchFailEvent: true, BackgroundFetchedEvent: true, BeforeInstallPromptEvent: true, BeforeUnloadEvent: true, BlobEvent: true, CanMakePaymentEvent: true, ClipboardEvent: true, CloseEvent: true, CustomEvent: true, DeviceMotionEvent: true, DeviceOrientationEvent: true, ErrorEvent: true, ExtendableEvent: true, ExtendableMessageEvent: true, FetchEvent: true, FontFaceSetLoadEvent: true, ForeignFetchEvent: true, GamepadEvent: true, HashChangeEvent: true, InstallEvent: true, MediaEncryptedEvent: true, MediaKeyMessageEvent: true, MediaQueryListEvent: true, MediaStreamEvent: true, MediaStreamTrackEvent: true, MessageEvent: true, MIDIConnectionEvent: true, MIDIMessageEvent: true, MutationEvent: true, NotificationEvent: true, PageTransitionEvent: true, PaymentRequestEvent: true, PaymentRequestUpdateEvent: true, PopStateEvent: true, PresentationConnectionAvailableEvent: true, PresentationConnectionCloseEvent: true, ProgressEvent: true, PromiseRejectionEvent: true, PushEvent: true, RTCDataChannelEvent: true, RTCDTMFToneChangeEvent: true, RTCPeerConnectionIceEvent: true, RTCTrackEvent: true, SecurityPolicyViolationEvent: true, SensorErrorEvent: true, SpeechRecognitionError: true, SpeechRecognitionEvent: true, SpeechSynthesisEvent: true, StorageEvent: true, SyncEvent: true, TrackEvent: true, TransitionEvent: true, WebKitTransitionEvent: true, VRDeviceEvent: true, VRDisplayEvent: true, VRSessionEvent: true, MojoInterfaceRequestEvent: true, ResourceProgressEvent: true, USBConnectionEvent: true, IDBVersionChangeEvent: true, AudioProcessingEvent: true, OfflineAudioCompletionEvent: true, WebGLContextEvent: true, Event: false, InputEvent: false, SubmitEvent: false, EventTarget: false, HTMLFormElement: true, HTMLInputElement: true, MouseEvent: true, DragEvent: true, PointerEvent: true, WheelEvent: true, Document: true, HTMLDocument: true, Node: false, HTMLSelectElement: true, CompositionEvent: true, FocusEvent: true, KeyboardEvent: true, TextEvent: true, TouchEvent: true, UIEvent: false, 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});
|
|
})();
|
|
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;
|
|
if (typeof dartMainRunner === "function")
|
|
dartMainRunner(F.main, []);
|
|
else
|
|
F.main([]);
|
|
});
|
|
})();
|
|
|
|
//# sourceMappingURL=main.js.map
|