10607 lines
462 KiB
JavaScript
10607 lines
462 KiB
JavaScript
// Generated by dart2js (NullSafetyMode.sound, csp, deferred-serialization, intern-composite-values), the Dart to JavaScript compiler version: 2.19.6.
|
|
// 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, loadId):
|
|
// 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. The loadId argument is the deferred import that resulted in
|
|
// this uri being loaded.
|
|
//
|
|
// dartCallInstrumentation(id, qualifiedName):
|
|
// if this function is defined, it will be called at each entry of a
|
|
// method or constructor. Used only when compiling programs with
|
|
// --experiment-call-instrumentation.
|
|
(function dartProgram() {
|
|
function copyProperties(from, to) {
|
|
var keys = Object.keys(from);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
function mixinPropertiesHard(from, to) {
|
|
var keys = Object.keys(from);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
if (!to.hasOwnProperty(key))
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
function mixinPropertiesEasy(from, to) {
|
|
Object.assign(to, from);
|
|
}
|
|
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 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 mixinEasy(cls, mixin) {
|
|
mixinPropertiesEasy(mixin.prototype, cls.prototype);
|
|
cls.prototype.constructor = cls;
|
|
}
|
|
function mixinHard(cls, mixin) {
|
|
mixinPropertiesHard(mixin.prototype, cls.prototype);
|
|
cls.prototype.constructor = cls;
|
|
}
|
|
function lazyOld(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function() {
|
|
holder[getterName] = function() {
|
|
A.throwCyclicInit(name);
|
|
};
|
|
var result;
|
|
var sentinelInProgress = initializer;
|
|
try {
|
|
if (holder[name] === uninitializedSentinel) {
|
|
result = holder[name] = sentinelInProgress;
|
|
result = holder[name] = initializer();
|
|
} else
|
|
result = holder[name];
|
|
} finally {
|
|
if (result === sentinelInProgress)
|
|
holder[name] = null;
|
|
holder[getterName] = function() {
|
|
return this[name];
|
|
};
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
function lazy(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function() {
|
|
if (holder[name] === uninitializedSentinel)
|
|
holder[name] = initializer();
|
|
holder[getterName] = function() {
|
|
return this[name];
|
|
};
|
|
return holder[name];
|
|
};
|
|
}
|
|
function lazyFinal(holder, name, getterName, initializer) {
|
|
var uninitializedSentinel = holder;
|
|
holder[name] = uninitializedSentinel;
|
|
holder[getterName] = function() {
|
|
if (holder[name] === uninitializedSentinel) {
|
|
var value = initializer();
|
|
if (holder[name] !== uninitializedSentinel)
|
|
A.throwLateFieldADI(name);
|
|
holder[name] = value;
|
|
}
|
|
var finalValue = holder[name];
|
|
holder[getterName] = function() {
|
|
return finalValue;
|
|
};
|
|
return finalValue;
|
|
};
|
|
}
|
|
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 instanceTearOffGetter(isIntercepted, parameters) {
|
|
var cache = null;
|
|
return isIntercepted ? function(receiver) {
|
|
if (cache === null)
|
|
cache = A.closureFromTearOff(parameters);
|
|
return new cache(receiver, this);
|
|
} : function() {
|
|
if (cache === null)
|
|
cache = A.closureFromTearOff(parameters);
|
|
return new cache(this, null);
|
|
};
|
|
}
|
|
function staticTearOffGetter(parameters) {
|
|
var cache = null;
|
|
return function() {
|
|
if (cache === null)
|
|
cache = A.closureFromTearOff(parameters).prototype;
|
|
return cache;
|
|
};
|
|
}
|
|
var typesOffset = 0;
|
|
function tearOffParameters(container, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
|
|
if (typeof funType == "number")
|
|
funType += typesOffset;
|
|
return {co: container, iS: isStatic, iI: isIntercepted, rC: requiredParameterCount, dV: optionalParameterDefaultValues, cs: callNames, fs: funsOrNames, fT: funType, aI: applyIndex || 0, nDA: needsDirectAccess};
|
|
}
|
|
function installStaticTearOff(holder, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
|
|
var parameters = tearOffParameters(holder, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, false);
|
|
var getterFunction = staticTearOffGetter(parameters);
|
|
holder[getterName] = getterFunction;
|
|
}
|
|
function installInstanceTearOff(prototype, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
|
|
isIntercepted = !!isIntercepted;
|
|
var parameters = tearOffParameters(prototype, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, !!needsDirectAccess);
|
|
var getterFunction = instanceTearOffGetter(isIntercepted, parameters);
|
|
prototype[getterName] = getterFunction;
|
|
}
|
|
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, false);
|
|
};
|
|
},
|
|
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: mixinEasy, mixinHard: mixinHard, installStaticTearOff: installStaticTearOff, installInstanceTearOff: installInstanceTearOff, _instance_0u: mkInstance(0, 0, null, ["call$0"], 0), _instance_1u: mkInstance(0, 1, null, ["call$1"], 0), _instance_2u: mkInstance(0, 2, null, ["call$2"], 0), _instance_0i: mkInstance(1, 0, null, ["call$0"], 0), _instance_1i: mkInstance(1, 1, null, ["call$1"], 0), _instance_2i: mkInstance(1, 2, null, ["call$2"], 0), _static_0: mkStatic(0, null, ["call$0"], 0), _static_1: mkStatic(1, null, ["call$1"], 0), _static_2: mkStatic(2, null, ["call$2"], 0), makeConstList: makeConstList, lazy: lazy, lazyFinal: lazyFinal, lazyOld: lazyOld, updateHolder: updateHolder, convertToFastObject: convertToFastObject, updateTypes: updateTypes, setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag, setOrUpdateLeafTags: setOrUpdateLeafTags};
|
|
}();
|
|
function initializeDeferredHunk(hunk) {
|
|
typesOffset = init.types.length;
|
|
hunk(hunkHelpers, init, holders, $);
|
|
}
|
|
var A = {JS_CONST: function JS_CONST() {
|
|
},
|
|
LateError$fieldNI(fieldName) {
|
|
return new A.LateError("Field '" + fieldName + "' has not been initialized.");
|
|
},
|
|
SystemHash_combine(hash, value) {
|
|
hash = hash + value & 536870911;
|
|
hash = hash + ((hash & 524287) << 10) & 536870911;
|
|
return hash ^ hash >>> 6;
|
|
},
|
|
SystemHash_finish(hash) {
|
|
hash = hash + ((hash & 67108863) << 3) & 536870911;
|
|
hash ^= hash >>> 11;
|
|
return hash + ((hash & 16383) << 15) & 536870911;
|
|
},
|
|
checkNotNullable(value, $name, $T) {
|
|
return value;
|
|
},
|
|
SubListIterable$(_iterable, _start, _endOrLength, $E) {
|
|
A.RangeError_checkNotNegative(_start, "start");
|
|
if (_endOrLength != null) {
|
|
A.RangeError_checkNotNegative(_endOrLength, "end");
|
|
if (_start > _endOrLength)
|
|
A.throwExpression(A.RangeError$range(_start, 0, _endOrLength, "start", null));
|
|
}
|
|
return new A.SubListIterable(_iterable, _start, _endOrLength, $E._eval$1("SubListIterable<0>"));
|
|
},
|
|
MappedIterable_MappedIterable(iterable, $function, $S, $T) {
|
|
if (type$.EfficientLengthIterable_dynamic._is(iterable))
|
|
return new A.EfficientLengthMappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("EfficientLengthMappedIterable<1,2>"));
|
|
return new A.MappedIterable(iterable, $function, $S._eval$1("@<0>")._bind$1($T)._eval$1("MappedIterable<1,2>"));
|
|
},
|
|
_CopyingBytesBuilder: function _CopyingBytesBuilder(t0) {
|
|
this.__internal$_length = 0;
|
|
this._buffer = t0;
|
|
},
|
|
LateError: function LateError(t0) {
|
|
this._message = t0;
|
|
},
|
|
CodeUnits: function CodeUnits(t0) {
|
|
this._string = t0;
|
|
},
|
|
SentinelValue: function SentinelValue() {
|
|
},
|
|
EfficientLengthIterable: function EfficientLengthIterable() {
|
|
},
|
|
ListIterable: function ListIterable() {
|
|
},
|
|
SubListIterable: function SubListIterable(t0, t1, t2, t3) {
|
|
var _ = this;
|
|
_.__internal$_iterable = t0;
|
|
_._start = t1;
|
|
_._endOrLength = t2;
|
|
_.$ti = t3;
|
|
},
|
|
ListIterator: function ListIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_.__internal$_iterable = t0;
|
|
_.__internal$_length = t1;
|
|
_.__internal$_index = 0;
|
|
_.__internal$_current = null;
|
|
_.$ti = t2;
|
|
},
|
|
MappedIterable: function MappedIterable(t0, t1, t2) {
|
|
this.__internal$_iterable = t0;
|
|
this._f = t1;
|
|
this.$ti = t2;
|
|
},
|
|
EfficientLengthMappedIterable: function EfficientLengthMappedIterable(t0, t1, t2) {
|
|
this.__internal$_iterable = t0;
|
|
this._f = t1;
|
|
this.$ti = t2;
|
|
},
|
|
MappedIterator: function MappedIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_.__internal$_current = null;
|
|
_._iterator = t0;
|
|
_._f = t1;
|
|
_.$ti = t2;
|
|
},
|
|
MappedListIterable: function MappedListIterable(t0, t1, t2) {
|
|
this._source = t0;
|
|
this._f = t1;
|
|
this.$ti = t2;
|
|
},
|
|
WhereIterable: function WhereIterable(t0, t1, t2) {
|
|
this.__internal$_iterable = t0;
|
|
this._f = t1;
|
|
this.$ti = t2;
|
|
},
|
|
WhereIterator: function WhereIterator(t0, t1, t2) {
|
|
this._iterator = t0;
|
|
this._f = t1;
|
|
this.$ti = t2;
|
|
},
|
|
FixedLengthListMixin: function FixedLengthListMixin() {
|
|
},
|
|
UnmodifiableListMixin: function UnmodifiableListMixin() {
|
|
},
|
|
UnmodifiableListBase: function UnmodifiableListBase() {
|
|
},
|
|
Symbol: function Symbol(t0) {
|
|
this.__internal$_name = t0;
|
|
},
|
|
unminifyOrTag(rawClassName) {
|
|
var preserved = init.mangledGlobalNames[rawClassName];
|
|
if (preserved != null)
|
|
return preserved;
|
|
return rawClassName;
|
|
},
|
|
isJsIndexable(object, record) {
|
|
var result;
|
|
if (record != null) {
|
|
result = record.x;
|
|
if (result != null)
|
|
return result;
|
|
}
|
|
return type$.JavaScriptIndexingBehavior_dynamic._is(object);
|
|
},
|
|
S(value) {
|
|
var result;
|
|
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";
|
|
result = J.toString$0$(value);
|
|
return result;
|
|
},
|
|
Primitives_objectHashCode(object) {
|
|
var hash,
|
|
property = $.Primitives__identityHashCodeProperty;
|
|
if (property == null)
|
|
property = $.Primitives__identityHashCodeProperty = Symbol("identityHashCode");
|
|
hash = object[property];
|
|
if (hash == null) {
|
|
hash = Math.random() * 0x3fffffff | 0;
|
|
object[property] = hash;
|
|
}
|
|
return hash;
|
|
},
|
|
Primitives_objectTypeName(object) {
|
|
return A.Primitives__objectTypeNameNewRti(object);
|
|
},
|
|
Primitives__objectTypeNameNewRti(object) {
|
|
var interceptor, dispatchName, $constructor, constructorName;
|
|
if (object instanceof A.Object)
|
|
return A._rtiToString(A.instanceType(object), null);
|
|
interceptor = J.getInterceptor$(object);
|
|
if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) {
|
|
dispatchName = B.C_JS_CONST(object);
|
|
if (dispatchName !== "Object" && dispatchName !== "")
|
|
return dispatchName;
|
|
$constructor = object.constructor;
|
|
if (typeof $constructor == "function") {
|
|
constructorName = $constructor.name;
|
|
if (typeof constructorName == "string" && constructorName !== "Object" && constructorName !== "")
|
|
return constructorName;
|
|
}
|
|
}
|
|
return A._rtiToString(A.instanceType(object), null);
|
|
},
|
|
Primitives_stringFromNativeUint8List(charCodes, start, end) {
|
|
var i, result, i0, chunkEnd;
|
|
if (end <= 500 && start === 0 && end === charCodes.length)
|
|
return String.fromCharCode.apply(null, charCodes);
|
|
for (i = start, result = ""; i < end; i = i0) {
|
|
i0 = i + 500;
|
|
chunkEnd = i0 < end ? i0 : end;
|
|
result += String.fromCharCode.apply(null, charCodes.subarray(i, chunkEnd));
|
|
}
|
|
return result;
|
|
},
|
|
Primitives_lazyAsJsDate(receiver) {
|
|
if (receiver.date === void 0)
|
|
receiver.date = new Date(receiver._value);
|
|
return receiver.date;
|
|
},
|
|
Primitives_getYear(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCFullYear() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_getMonth(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCMonth() + 1;
|
|
return t1;
|
|
},
|
|
Primitives_getDay(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCDate() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_getHours(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCHours() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_getMinutes(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCMinutes() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_getSeconds(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCSeconds() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_getMilliseconds(receiver) {
|
|
var t1 = A.Primitives_lazyAsJsDate(receiver).getUTCMilliseconds() + 0;
|
|
return t1;
|
|
},
|
|
Primitives_functionNoSuchMethod($function, positionalArguments, namedArguments) {
|
|
var $arguments, namedArgumentList, t1 = {};
|
|
t1.argumentCount = 0;
|
|
$arguments = [];
|
|
namedArgumentList = [];
|
|
t1.argumentCount = positionalArguments.length;
|
|
B.JSArray_methods.addAll$1($arguments, positionalArguments);
|
|
t1.names = "";
|
|
if (namedArguments != null && namedArguments._length !== 0)
|
|
namedArguments.forEach$1(0, new A.Primitives_functionNoSuchMethod_closure(t1, namedArgumentList, $arguments));
|
|
return J.noSuchMethod$1$($function, new A.JSInvocationMirror(B.Symbol_call, 0, $arguments, namedArgumentList, 0));
|
|
},
|
|
Primitives_applyFunction($function, positionalArguments, namedArguments) {
|
|
var t1, argumentCount, jsStub;
|
|
if (Array.isArray(positionalArguments))
|
|
t1 = namedArguments == null || namedArguments._length === 0;
|
|
else
|
|
t1 = false;
|
|
if (t1) {
|
|
argumentCount = positionalArguments.length;
|
|
if (argumentCount === 0) {
|
|
if (!!$function.call$0)
|
|
return $function.call$0();
|
|
} else if (argumentCount === 1) {
|
|
if (!!$function.call$1)
|
|
return $function.call$1(positionalArguments[0]);
|
|
} else if (argumentCount === 2) {
|
|
if (!!$function.call$2)
|
|
return $function.call$2(positionalArguments[0], positionalArguments[1]);
|
|
} else if (argumentCount === 3) {
|
|
if (!!$function.call$3)
|
|
return $function.call$3(positionalArguments[0], positionalArguments[1], positionalArguments[2]);
|
|
} else if (argumentCount === 4) {
|
|
if (!!$function.call$4)
|
|
return $function.call$4(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3]);
|
|
} else if (argumentCount === 5)
|
|
if (!!$function.call$5)
|
|
return $function.call$5(positionalArguments[0], positionalArguments[1], positionalArguments[2], positionalArguments[3], positionalArguments[4]);
|
|
jsStub = $function["call" + "$" + argumentCount];
|
|
if (jsStub != null)
|
|
return jsStub.apply($function, positionalArguments);
|
|
}
|
|
return A.Primitives__generalApplyFunction($function, positionalArguments, namedArguments);
|
|
},
|
|
Primitives__generalApplyFunction($function, positionalArguments, namedArguments) {
|
|
var defaultValuesClosure, t1, defaultValues, interceptor, jsFunction, maxArguments, missingDefaults, keys, _i, defaultValue, used, key,
|
|
$arguments = Array.isArray(positionalArguments) ? positionalArguments : A.List_List$of(positionalArguments, true, type$.dynamic),
|
|
argumentCount = $arguments.length,
|
|
requiredParameterCount = $function.$requiredArgCount;
|
|
if (argumentCount < requiredParameterCount)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
defaultValuesClosure = $function.$defaultValues;
|
|
t1 = defaultValuesClosure == null;
|
|
defaultValues = !t1 ? defaultValuesClosure() : null;
|
|
interceptor = J.getInterceptor$($function);
|
|
jsFunction = interceptor["call*"];
|
|
if (typeof jsFunction == "string")
|
|
jsFunction = interceptor[jsFunction];
|
|
if (t1) {
|
|
if (namedArguments != null && namedArguments._length !== 0)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
if (argumentCount === requiredParameterCount)
|
|
return jsFunction.apply($function, $arguments);
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
}
|
|
if (Array.isArray(defaultValues)) {
|
|
if (namedArguments != null && namedArguments._length !== 0)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
maxArguments = requiredParameterCount + defaultValues.length;
|
|
if (argumentCount > maxArguments)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, null);
|
|
if (argumentCount < maxArguments) {
|
|
missingDefaults = defaultValues.slice(argumentCount - requiredParameterCount);
|
|
if ($arguments === positionalArguments)
|
|
$arguments = A.List_List$of($arguments, true, type$.dynamic);
|
|
B.JSArray_methods.addAll$1($arguments, missingDefaults);
|
|
}
|
|
return jsFunction.apply($function, $arguments);
|
|
} else {
|
|
if (argumentCount > requiredParameterCount)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
if ($arguments === positionalArguments)
|
|
$arguments = A.List_List$of($arguments, true, type$.dynamic);
|
|
keys = Object.keys(defaultValues);
|
|
if (namedArguments == null)
|
|
for (t1 = keys.length, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) {
|
|
defaultValue = defaultValues[A._asString(keys[_i])];
|
|
if (B.C__Required === defaultValue)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
B.JSArray_methods.add$1($arguments, defaultValue);
|
|
}
|
|
else {
|
|
for (t1 = keys.length, used = 0, _i = 0; _i < keys.length; keys.length === t1 || (0, A.throwConcurrentModificationError)(keys), ++_i) {
|
|
key = A._asString(keys[_i]);
|
|
if (namedArguments.containsKey$1(0, key)) {
|
|
++used;
|
|
B.JSArray_methods.add$1($arguments, namedArguments.$index(0, key));
|
|
} else {
|
|
defaultValue = defaultValues[key];
|
|
if (B.C__Required === defaultValue)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
B.JSArray_methods.add$1($arguments, defaultValue);
|
|
}
|
|
}
|
|
if (used !== namedArguments._length)
|
|
return A.Primitives_functionNoSuchMethod($function, $arguments, namedArguments);
|
|
}
|
|
return jsFunction.apply($function, $arguments);
|
|
}
|
|
},
|
|
iae(argument) {
|
|
throw A.wrapException(A.argumentErrorValue(argument));
|
|
},
|
|
ioore(receiver, index) {
|
|
if (receiver == null)
|
|
J.get$length$asx(receiver);
|
|
throw A.wrapException(A.diagnoseIndexError(receiver, index));
|
|
},
|
|
diagnoseIndexError(indexable, index) {
|
|
var $length, _s5_ = "index";
|
|
if (!A._isInt(index))
|
|
return new A.ArgumentError(true, index, _s5_, null);
|
|
$length = A._asInt(J.get$length$asx(indexable));
|
|
if (index < 0 || index >= $length)
|
|
return A.IndexError$withLength(index, $length, indexable, _s5_);
|
|
return A.RangeError$value(index, _s5_);
|
|
},
|
|
diagnoseRangeError(start, end, $length) {
|
|
if (start < 0 || start > $length)
|
|
return A.RangeError$range(start, 0, $length, "start", null);
|
|
if (end != null)
|
|
if (end < start || end > $length)
|
|
return A.RangeError$range(end, start, $length, "end", null);
|
|
return new A.ArgumentError(true, end, "end", null);
|
|
},
|
|
argumentErrorValue(object) {
|
|
return new A.ArgumentError(true, object, null, null);
|
|
},
|
|
wrapException(ex) {
|
|
var wrapper, t1;
|
|
if (ex == null)
|
|
ex = new A.NullThrownError();
|
|
wrapper = new Error();
|
|
wrapper.dartException = ex;
|
|
t1 = A.toStringWrapper;
|
|
if ("defineProperty" in Object) {
|
|
Object.defineProperty(wrapper, "message", {get: t1});
|
|
wrapper.name = "";
|
|
} else
|
|
wrapper.toString = t1;
|
|
return wrapper;
|
|
},
|
|
toStringWrapper() {
|
|
return J.toString$0$(this.dartException);
|
|
},
|
|
throwExpression(ex) {
|
|
throw A.wrapException(ex);
|
|
},
|
|
throwConcurrentModificationError(collection) {
|
|
throw A.wrapException(A.ConcurrentModificationError$(collection));
|
|
},
|
|
TypeErrorDecoder_extractPattern(message) {
|
|
var match, $arguments, argumentsExpr, expr, method, receiver;
|
|
message = A.quoteStringForRegExp(message.replace(String({}), "$receiver$"));
|
|
match = message.match(/\\\$[a-zA-Z]+\\\$/g);
|
|
if (match == null)
|
|
match = A._setArrayType([], 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 A.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(expression) {
|
|
return function($expr$) {
|
|
var $argumentsExpr$ = "$arguments$";
|
|
try {
|
|
$expr$.$method$($argumentsExpr$);
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}(expression);
|
|
},
|
|
TypeErrorDecoder_provokePropertyErrorOn(expression) {
|
|
return function($expr$) {
|
|
try {
|
|
$expr$.$method$;
|
|
} catch (e) {
|
|
return e.message;
|
|
}
|
|
}(expression);
|
|
},
|
|
JsNoSuchMethodError$(_message, match) {
|
|
var t1 = match == null,
|
|
t2 = t1 ? null : match.method;
|
|
return new A.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver);
|
|
},
|
|
unwrapException(ex) {
|
|
var t1;
|
|
if (ex == null)
|
|
return new A.NullThrownFromJavaScriptException(ex);
|
|
if (ex instanceof A.ExceptionAndStackTrace) {
|
|
t1 = ex.dartException;
|
|
return A.saveStackTrace(ex, t1 == null ? type$.Object._as(t1) : t1);
|
|
}
|
|
if (typeof ex !== "object")
|
|
return ex;
|
|
if ("dartException" in ex)
|
|
return A.saveStackTrace(ex, ex.dartException);
|
|
return A._unwrapNonDartException(ex);
|
|
},
|
|
saveStackTrace(ex, error) {
|
|
if (type$.Error._is(error))
|
|
if (error.$thrownJsError == null)
|
|
error.$thrownJsError = ex;
|
|
return error;
|
|
},
|
|
_unwrapNonDartException(ex) {
|
|
var message, number, ieErrorCode, t1, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, match, _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 ((B.JSInt_methods._shrOtherPositive$1(number, 16) & 8191) === 10)
|
|
switch (ieErrorCode) {
|
|
case 438:
|
|
return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A.S(message) + " (Error " + ieErrorCode + ")", _null));
|
|
case 445:
|
|
case 5007:
|
|
t1 = A.S(message);
|
|
return A.saveStackTrace(ex, new A.NullError(t1 + " (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 A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
|
|
else {
|
|
match = notClosure.matchTypeError$1(message);
|
|
if (match != null) {
|
|
match.method = "call";
|
|
return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
|
|
} else {
|
|
match = nullCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullProperty.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = nullLiteralCall.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefProperty.matchTypeError$1(message);
|
|
if (match == null) {
|
|
match = undefLiteralProperty.matchTypeError$1(message);
|
|
t1 = match != null;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
} else
|
|
t1 = true;
|
|
if (t1) {
|
|
A._asString(message);
|
|
return A.saveStackTrace(ex, new A.NullError(message, match == null ? _null : match.method));
|
|
}
|
|
}
|
|
}
|
|
return A.saveStackTrace(ex, new A.UnknownJsTypeError(typeof message == "string" ? message : ""));
|
|
}
|
|
if (ex instanceof RangeError) {
|
|
if (typeof message == "string" && message.indexOf("call stack") !== -1)
|
|
return new A.StackOverflowError();
|
|
message = function(ex) {
|
|
try {
|
|
return String(ex);
|
|
} catch (e) {
|
|
}
|
|
return null;
|
|
}(ex);
|
|
return A.saveStackTrace(ex, new A.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 A.StackOverflowError();
|
|
return ex;
|
|
},
|
|
getTraceFromException(exception) {
|
|
var trace;
|
|
if (exception instanceof A.ExceptionAndStackTrace)
|
|
return exception.stackTrace;
|
|
if (exception == null)
|
|
return new A._StackTrace(exception);
|
|
trace = exception.$cachedTrace;
|
|
if (trace != null)
|
|
return trace;
|
|
return exception.$cachedTrace = new A._StackTrace(exception);
|
|
},
|
|
objectHashCode(object) {
|
|
if (object == null || typeof object != "object")
|
|
return J.get$hashCode$(object);
|
|
else
|
|
return A.Primitives_objectHashCode(object);
|
|
},
|
|
fillLiteralMap(keyValuePairs, result) {
|
|
var index, index0, index1,
|
|
$length = keyValuePairs.length;
|
|
for (index = 0; index < $length; index = index1) {
|
|
index0 = index + 1;
|
|
index1 = index0 + 1;
|
|
result.$indexSet(0, keyValuePairs[index], keyValuePairs[index0]);
|
|
}
|
|
return result;
|
|
},
|
|
invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) {
|
|
type$.Function._as(closure);
|
|
switch (A._asInt(numberOfArguments)) {
|
|
case 0:
|
|
return closure.call$0();
|
|
case 1:
|
|
return closure.call$1(arg1);
|
|
case 2:
|
|
return closure.call$2(arg1, arg2);
|
|
case 3:
|
|
return closure.call$3(arg1, arg2, arg3);
|
|
case 4:
|
|
return closure.call$4(arg1, arg2, arg3, arg4);
|
|
}
|
|
throw A.wrapException(A.Exception_Exception("Unsupported number of arguments for wrapped closure"));
|
|
},
|
|
convertDartClosureToJS(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, A.invokeClosure);
|
|
closure.$identity = $function;
|
|
return $function;
|
|
},
|
|
Closure_fromTearOff(parameters) {
|
|
var $prototype, $constructor, t2, trampoline, applyTrampoline, i, stub, stub0, stubName, stubCallName,
|
|
container = parameters.co,
|
|
isStatic = parameters.iS,
|
|
isIntercepted = parameters.iI,
|
|
needsDirectAccess = parameters.nDA,
|
|
applyTrampolineIndex = parameters.aI,
|
|
funsOrNames = parameters.fs,
|
|
callNames = parameters.cs,
|
|
$name = funsOrNames[0],
|
|
callName = callNames[0],
|
|
$function = container[$name],
|
|
t1 = parameters.fT;
|
|
t1.toString;
|
|
$prototype = isStatic ? Object.create(new A.StaticClosure().constructor.prototype) : Object.create(new A.BoundClosure(null, null).constructor.prototype);
|
|
$prototype.$initialize = $prototype.constructor;
|
|
if (isStatic)
|
|
$constructor = function static_tear_off() {
|
|
this.$initialize();
|
|
};
|
|
else
|
|
$constructor = function tear_off(a, b) {
|
|
this.$initialize(a, b);
|
|
};
|
|
$prototype.constructor = $constructor;
|
|
$constructor.prototype = $prototype;
|
|
$prototype.$_name = $name;
|
|
$prototype.$_target = $function;
|
|
t2 = !isStatic;
|
|
if (t2)
|
|
trampoline = A.Closure_forwardCallTo($name, $function, isIntercepted, needsDirectAccess);
|
|
else {
|
|
$prototype.$static_name = $name;
|
|
trampoline = $function;
|
|
}
|
|
$prototype.$signature = A.Closure__computeSignatureFunctionNewRti(t1, isStatic, isIntercepted);
|
|
$prototype[callName] = trampoline;
|
|
for (applyTrampoline = trampoline, i = 1; i < funsOrNames.length; ++i) {
|
|
stub = funsOrNames[i];
|
|
if (typeof stub == "string") {
|
|
stub0 = container[stub];
|
|
stubName = stub;
|
|
stub = stub0;
|
|
} else
|
|
stubName = "";
|
|
stubCallName = callNames[i];
|
|
if (stubCallName != null) {
|
|
if (t2)
|
|
stub = A.Closure_forwardCallTo(stubName, stub, isIntercepted, needsDirectAccess);
|
|
$prototype[stubCallName] = stub;
|
|
}
|
|
if (i === applyTrampolineIndex)
|
|
applyTrampoline = stub;
|
|
}
|
|
$prototype["call*"] = applyTrampoline;
|
|
$prototype.$requiredArgCount = parameters.rC;
|
|
$prototype.$defaultValues = parameters.dV;
|
|
return $constructor;
|
|
},
|
|
Closure__computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted) {
|
|
if (typeof functionType == "number")
|
|
return functionType;
|
|
if (typeof functionType == "string") {
|
|
if (isStatic)
|
|
throw A.wrapException("Cannot compute signature for static tearoff.");
|
|
return function(recipe, evalOnReceiver) {
|
|
return function() {
|
|
return evalOnReceiver(this, recipe);
|
|
};
|
|
}(functionType, A.BoundClosure_evalRecipe);
|
|
}
|
|
throw A.wrapException("Error in functionType of tearoff");
|
|
},
|
|
Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function) {
|
|
var getReceiver = A.BoundClosure_receiverOf;
|
|
switch (needsDirectAccess ? -1 : arity) {
|
|
case 0:
|
|
return function(entry, receiverOf) {
|
|
return function() {
|
|
return receiverOf(this)[entry]();
|
|
};
|
|
}(stubName, getReceiver);
|
|
case 1:
|
|
return function(entry, receiverOf) {
|
|
return function(a) {
|
|
return receiverOf(this)[entry](a);
|
|
};
|
|
}(stubName, getReceiver);
|
|
case 2:
|
|
return function(entry, receiverOf) {
|
|
return function(a, b) {
|
|
return receiverOf(this)[entry](a, b);
|
|
};
|
|
}(stubName, getReceiver);
|
|
case 3:
|
|
return function(entry, receiverOf) {
|
|
return function(a, b, c) {
|
|
return receiverOf(this)[entry](a, b, c);
|
|
};
|
|
}(stubName, getReceiver);
|
|
case 4:
|
|
return function(entry, receiverOf) {
|
|
return function(a, b, c, d) {
|
|
return receiverOf(this)[entry](a, b, c, d);
|
|
};
|
|
}(stubName, getReceiver);
|
|
case 5:
|
|
return function(entry, receiverOf) {
|
|
return function(a, b, c, d, e) {
|
|
return receiverOf(this)[entry](a, b, c, d, e);
|
|
};
|
|
}(stubName, getReceiver);
|
|
default:
|
|
return function(f, receiverOf) {
|
|
return function() {
|
|
return f.apply(receiverOf(this), arguments);
|
|
};
|
|
}($function, getReceiver);
|
|
}
|
|
},
|
|
Closure_forwardCallTo(stubName, $function, isIntercepted, needsDirectAccess) {
|
|
var arity, t1;
|
|
if (isIntercepted)
|
|
return A.Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess);
|
|
arity = $function.length;
|
|
t1 = A.Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function);
|
|
return t1;
|
|
},
|
|
Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function) {
|
|
var getReceiver = A.BoundClosure_receiverOf,
|
|
getInterceptor = A.BoundClosure_interceptorOf;
|
|
switch (needsDirectAccess ? -1 : arity) {
|
|
case 0:
|
|
throw A.wrapException(new A.RuntimeError("Intercepted function with no arguments."));
|
|
case 1:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function() {
|
|
return interceptorOf(this)[entry](receiverOf(this));
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
case 2:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function(a) {
|
|
return interceptorOf(this)[entry](receiverOf(this), a);
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
case 3:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function(a, b) {
|
|
return interceptorOf(this)[entry](receiverOf(this), a, b);
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
case 4:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function(a, b, c) {
|
|
return interceptorOf(this)[entry](receiverOf(this), a, b, c);
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
case 5:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function(a, b, c, d) {
|
|
return interceptorOf(this)[entry](receiverOf(this), a, b, c, d);
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
case 6:
|
|
return function(entry, interceptorOf, receiverOf) {
|
|
return function(a, b, c, d, e) {
|
|
return interceptorOf(this)[entry](receiverOf(this), a, b, c, d, e);
|
|
};
|
|
}(stubName, getInterceptor, getReceiver);
|
|
default:
|
|
return function(f, interceptorOf, receiverOf) {
|
|
return function() {
|
|
var a = [receiverOf(this)];
|
|
Array.prototype.push.apply(a, arguments);
|
|
return f.apply(interceptorOf(this), a);
|
|
};
|
|
}($function, getInterceptor, getReceiver);
|
|
}
|
|
},
|
|
Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess) {
|
|
var arity, t1;
|
|
if ($.BoundClosure__interceptorFieldNameCache == null)
|
|
$.BoundClosure__interceptorFieldNameCache = A.BoundClosure__computeFieldNamed("interceptor");
|
|
if ($.BoundClosure__receiverFieldNameCache == null)
|
|
$.BoundClosure__receiverFieldNameCache = A.BoundClosure__computeFieldNamed("receiver");
|
|
arity = $function.length;
|
|
t1 = A.Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function);
|
|
return t1;
|
|
},
|
|
closureFromTearOff(parameters) {
|
|
return A.Closure_fromTearOff(parameters);
|
|
},
|
|
BoundClosure_evalRecipe(closure, recipe) {
|
|
return A._Universe_evalInEnvironment(init.typeUniverse, A.instanceType(closure._receiver), recipe);
|
|
},
|
|
BoundClosure_receiverOf(closure) {
|
|
return closure._receiver;
|
|
},
|
|
BoundClosure_interceptorOf(closure) {
|
|
return closure._interceptor;
|
|
},
|
|
BoundClosure__computeFieldNamed(fieldName) {
|
|
var t1, i, $name,
|
|
template = new A.BoundClosure("receiver", "interceptor"),
|
|
names = J.JSArray_markFixedList(Object.getOwnPropertyNames(template), type$.nullable_Object);
|
|
for (t1 = names.length, i = 0; i < t1; ++i) {
|
|
$name = names[i];
|
|
if (template[$name] === fieldName)
|
|
return $name;
|
|
}
|
|
throw A.wrapException(A.ArgumentError$("Field name " + fieldName + " not found.", null));
|
|
},
|
|
boolConversionCheck(value) {
|
|
if (value == null)
|
|
A.assertThrow("boolean expression must not be null");
|
|
return value;
|
|
},
|
|
assertThrow(message) {
|
|
throw A.wrapException(new A._AssertionError(message));
|
|
},
|
|
throwCyclicInit(staticName) {
|
|
throw A.wrapException(new A.CyclicInitializationError(staticName));
|
|
},
|
|
getIsolateAffinityTag($name) {
|
|
return init.getIsolateTag($name);
|
|
},
|
|
defineProperty(obj, property, value) {
|
|
Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true});
|
|
},
|
|
lookupAndCacheInterceptor(obj) {
|
|
var interceptor, interceptorClass, altTag, mark, t1,
|
|
tag = A._asString($.getTagFunction.call$1(obj)),
|
|
record = $.dispatchRecordsForInstanceTags[tag];
|
|
if (record != null) {
|
|
Object.defineProperty(obj, init.dispatchPropertyName, {value: record, enumerable: false, writable: true, configurable: true});
|
|
return record.i;
|
|
}
|
|
interceptor = $.interceptorsForUncacheableTags[tag];
|
|
if (interceptor != null)
|
|
return interceptor;
|
|
interceptorClass = init.interceptorsByTag[tag];
|
|
if (interceptorClass == null) {
|
|
altTag = A._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 = A.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 = A.makeLeafDispatchRecord(interceptor);
|
|
Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true});
|
|
return t1.i;
|
|
}
|
|
if (mark === "+")
|
|
return A.patchInteriorProto(obj, interceptor);
|
|
if (mark === "*")
|
|
throw A.wrapException(A.UnimplementedError$(tag));
|
|
if (init.leafTags[tag] === true) {
|
|
t1 = A.makeLeafDispatchRecord(interceptor);
|
|
Object.defineProperty(Object.getPrototypeOf(obj), init.dispatchPropertyName, {value: t1, enumerable: false, writable: true, configurable: true});
|
|
return t1.i;
|
|
} else
|
|
return A.patchInteriorProto(obj, interceptor);
|
|
},
|
|
patchInteriorProto(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(interceptor) {
|
|
return J.makeDispatchRecord(interceptor, false, null, !!interceptor.$isJavaScriptIndexingBehavior);
|
|
},
|
|
makeDefaultDispatchRecord(tag, interceptorClass, proto) {
|
|
var interceptor = interceptorClass.prototype;
|
|
if (init.leafTags[tag] === true)
|
|
return A.makeLeafDispatchRecord(interceptor);
|
|
else
|
|
return J.makeDispatchRecord(interceptor, proto, null, null);
|
|
},
|
|
initNativeDispatch() {
|
|
if (true === $.initNativeDispatchFlag)
|
|
return;
|
|
$.initNativeDispatchFlag = true;
|
|
A.initNativeDispatchContinue();
|
|
},
|
|
initNativeDispatchContinue() {
|
|
var map, tags, fun, i, tag, proto, record, interceptorClass;
|
|
$.dispatchRecordsForInstanceTags = Object.create(null);
|
|
$.interceptorsForUncacheableTags = Object.create(null);
|
|
A.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 = A.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() {
|
|
var transformers, i, transformer, getTag, getUnknownTag, prototypeForTag,
|
|
hooks = B.C_JS_CONST0();
|
|
hooks = A.applyHooksTransformer(B.C_JS_CONST1, A.applyHooksTransformer(B.C_JS_CONST2, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST3, A.applyHooksTransformer(B.C_JS_CONST4, A.applyHooksTransformer(B.C_JS_CONST5, A.applyHooksTransformer(B.C_JS_CONST6(B.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 A.initHooks_closure(getTag);
|
|
$.alternateTagFunction = new A.initHooks_closure0(getUnknownTag);
|
|
$.prototypeForTagFunction = new A.initHooks_closure1(prototypeForTag);
|
|
},
|
|
applyHooksTransformer(transformer, hooks) {
|
|
return transformer(hooks) || hooks;
|
|
},
|
|
quoteStringForRegExp(string) {
|
|
if (/[[\]{}()*+?.\\^$|]/.test(string))
|
|
return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
|
|
return string;
|
|
},
|
|
ConstantMapView: function ConstantMapView(t0, t1) {
|
|
this._collection$_map = t0;
|
|
this.$ti = t1;
|
|
},
|
|
ConstantMap: function ConstantMap() {
|
|
},
|
|
ConstantStringMap: function ConstantStringMap(t0, t1, t2, t3) {
|
|
var _ = this;
|
|
_._length = t0;
|
|
_._jsObject = t1;
|
|
_.__js_helper$_keys = t2;
|
|
_.$ti = t3;
|
|
},
|
|
_ConstantMapKeyIterable: function _ConstantMapKeyIterable(t0, t1) {
|
|
this._map = t0;
|
|
this.$ti = t1;
|
|
},
|
|
JSInvocationMirror: function JSInvocationMirror(t0, t1, t2, t3, t4) {
|
|
var _ = this;
|
|
_._memberName = t0;
|
|
_.__js_helper$_kind = t1;
|
|
_._arguments = t2;
|
|
_._namedArgumentNames = t3;
|
|
_._typeArgumentCount = t4;
|
|
},
|
|
Primitives_functionNoSuchMethod_closure: function Primitives_functionNoSuchMethod_closure(t0, t1, t2) {
|
|
this._box_0 = t0;
|
|
this.namedArgumentList = t1;
|
|
this.$arguments = t2;
|
|
},
|
|
TypeErrorDecoder: function TypeErrorDecoder(t0, t1, t2, t3, t4, t5) {
|
|
var _ = this;
|
|
_._pattern = t0;
|
|
_._arguments = t1;
|
|
_._argumentsExpr = t2;
|
|
_._expr = t3;
|
|
_._method = t4;
|
|
_._receiver = t5;
|
|
},
|
|
NullError: function NullError(t0, t1) {
|
|
this.__js_helper$_message = t0;
|
|
this._method = t1;
|
|
},
|
|
JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) {
|
|
this.__js_helper$_message = t0;
|
|
this._method = t1;
|
|
this._receiver = t2;
|
|
},
|
|
UnknownJsTypeError: function UnknownJsTypeError(t0) {
|
|
this.__js_helper$_message = t0;
|
|
},
|
|
NullThrownFromJavaScriptException: function NullThrownFromJavaScriptException(t0) {
|
|
this._irritant = t0;
|
|
},
|
|
ExceptionAndStackTrace: function ExceptionAndStackTrace(t0, t1) {
|
|
this.dartException = t0;
|
|
this.stackTrace = t1;
|
|
},
|
|
_StackTrace: function _StackTrace(t0) {
|
|
this._exception = t0;
|
|
this._trace = null;
|
|
},
|
|
Closure: function Closure() {
|
|
},
|
|
Closure0Args: function Closure0Args() {
|
|
},
|
|
Closure2Args: function Closure2Args() {
|
|
},
|
|
TearOffClosure: function TearOffClosure() {
|
|
},
|
|
StaticClosure: function StaticClosure() {
|
|
},
|
|
BoundClosure: function BoundClosure(t0, t1) {
|
|
this._receiver = t0;
|
|
this._interceptor = t1;
|
|
},
|
|
RuntimeError: function RuntimeError(t0) {
|
|
this.message = t0;
|
|
},
|
|
_AssertionError: function _AssertionError(t0) {
|
|
this.message = t0;
|
|
},
|
|
_Required: function _Required() {
|
|
},
|
|
JsLinkedHashMap: function JsLinkedHashMap(t0) {
|
|
var _ = this;
|
|
_._length = 0;
|
|
_._last = _._first = _.__js_helper$_rest = _._nums = _._strings = null;
|
|
_._modifications = 0;
|
|
_.$ti = t0;
|
|
},
|
|
LinkedHashMapCell: function LinkedHashMapCell(t0, t1) {
|
|
this.hashMapCellKey = t0;
|
|
this.hashMapCellValue = t1;
|
|
this._next = null;
|
|
},
|
|
LinkedHashMapKeyIterable: function LinkedHashMapKeyIterable(t0, t1) {
|
|
this._map = t0;
|
|
this.$ti = t1;
|
|
},
|
|
LinkedHashMapKeyIterator: function LinkedHashMapKeyIterator(t0, t1, t2) {
|
|
var _ = this;
|
|
_._map = t0;
|
|
_._modifications = t1;
|
|
_.__js_helper$_current = _._cell = null;
|
|
_.$ti = t2;
|
|
},
|
|
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;
|
|
},
|
|
_ensureNativeList(list) {
|
|
var t1, result, i;
|
|
if (type$.JSIndexable_dynamic._is(list))
|
|
return list;
|
|
t1 = J.getInterceptor$asx(list);
|
|
result = A.List_List$filled(t1.get$length(list), null, false, type$.dynamic);
|
|
for (i = 0; i < t1.get$length(list); ++i)
|
|
B.JSArray_methods.$indexSet(result, i, t1.$index(list, i));
|
|
return result;
|
|
},
|
|
NativeByteData_NativeByteData($length) {
|
|
return new DataView(new ArrayBuffer($length));
|
|
},
|
|
NativeUint8List_NativeUint8List($length) {
|
|
return new Uint8Array($length);
|
|
},
|
|
NativeUint8List_NativeUint8List$fromList(elements) {
|
|
return new Uint8Array(A._ensureNativeList(elements));
|
|
},
|
|
NativeUint8List_NativeUint8List$view(buffer, offsetInBytes, $length) {
|
|
return $length == null ? new Uint8Array(buffer, offsetInBytes) : new Uint8Array(buffer, offsetInBytes, $length);
|
|
},
|
|
_checkValidIndex(index, list, $length) {
|
|
if (index >>> 0 !== index || index >= $length)
|
|
throw A.wrapException(A.diagnoseIndexError(list, index));
|
|
},
|
|
_checkValidRange(start, end, $length) {
|
|
var t1;
|
|
if (!(start >>> 0 !== start))
|
|
if (end == null)
|
|
t1 = start > $length;
|
|
else
|
|
t1 = end >>> 0 !== end || start > end || end > $length;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
throw A.wrapException(A.diagnoseRangeError(start, end, $length));
|
|
if (end == null)
|
|
return $length;
|
|
return end;
|
|
},
|
|
NativeByteBuffer: function NativeByteBuffer() {
|
|
},
|
|
NativeTypedData: function NativeTypedData() {
|
|
},
|
|
NativeByteData: function NativeByteData() {
|
|
},
|
|
NativeTypedArray: function NativeTypedArray() {
|
|
},
|
|
NativeTypedArrayOfDouble: function NativeTypedArrayOfDouble() {
|
|
},
|
|
NativeTypedArrayOfInt: function NativeTypedArrayOfInt() {
|
|
},
|
|
NativeInt16List: function NativeInt16List() {
|
|
},
|
|
NativeInt32List: function NativeInt32List() {
|
|
},
|
|
NativeInt8List: function NativeInt8List() {
|
|
},
|
|
NativeUint16List: function NativeUint16List() {
|
|
},
|
|
NativeUint32List: function NativeUint32List() {
|
|
},
|
|
NativeUint8ClampedList: function NativeUint8ClampedList() {
|
|
},
|
|
NativeUint8List: function NativeUint8List() {
|
|
},
|
|
_NativeTypedArrayOfDouble_NativeTypedArray_ListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin() {
|
|
},
|
|
_NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfDouble_NativeTypedArray_ListMixin_FixedLengthListMixin() {
|
|
},
|
|
_NativeTypedArrayOfInt_NativeTypedArray_ListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin() {
|
|
},
|
|
_NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin: function _NativeTypedArrayOfInt_NativeTypedArray_ListMixin_FixedLengthListMixin() {
|
|
},
|
|
Rti__getQuestionFromStar(universe, rti) {
|
|
var question = rti._precomputed1;
|
|
return question == null ? rti._precomputed1 = A._Universe__lookupQuestionRti(universe, rti._primary, true) : question;
|
|
},
|
|
Rti__getFutureFromFutureOr(universe, rti) {
|
|
var future = rti._precomputed1;
|
|
return future == null ? rti._precomputed1 = A._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future;
|
|
},
|
|
Rti__isUnionOfFunctionType(rti) {
|
|
var kind = rti._kind;
|
|
if (kind === 6 || kind === 7 || kind === 8)
|
|
return A.Rti__isUnionOfFunctionType(rti._primary);
|
|
return kind === 12 || kind === 13;
|
|
},
|
|
Rti__getCanonicalRecipe(rti) {
|
|
return rti._canonicalRecipe;
|
|
},
|
|
findType(recipe) {
|
|
return A._Universe_eval(init.typeUniverse, recipe, false);
|
|
},
|
|
_substitute(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 = A._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return A._Universe__lookupStarRti(universe, substitutedBaseType, true);
|
|
case 7:
|
|
baseType = rti._primary;
|
|
substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return A._Universe__lookupQuestionRti(universe, substitutedBaseType, true);
|
|
case 8:
|
|
baseType = rti._primary;
|
|
substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
|
|
if (substitutedBaseType === baseType)
|
|
return rti;
|
|
return A._Universe__lookupFutureOrRti(universe, substitutedBaseType, true);
|
|
case 9:
|
|
interfaceTypeArguments = rti._rest;
|
|
substitutedInterfaceTypeArguments = A._substituteArray(universe, interfaceTypeArguments, typeArguments, depth);
|
|
if (substitutedInterfaceTypeArguments === interfaceTypeArguments)
|
|
return rti;
|
|
return A._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments);
|
|
case 10:
|
|
base = rti._primary;
|
|
substitutedBase = A._substitute(universe, base, typeArguments, depth);
|
|
$arguments = rti._rest;
|
|
substitutedArguments = A._substituteArray(universe, $arguments, typeArguments, depth);
|
|
if (substitutedBase === base && substitutedArguments === $arguments)
|
|
return rti;
|
|
return A._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments);
|
|
case 12:
|
|
returnType = rti._primary;
|
|
substitutedReturnType = A._substitute(universe, returnType, typeArguments, depth);
|
|
functionParameters = rti._rest;
|
|
substitutedFunctionParameters = A._substituteFunctionParameters(universe, functionParameters, typeArguments, depth);
|
|
if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters)
|
|
return rti;
|
|
return A._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters);
|
|
case 13:
|
|
bounds = rti._rest;
|
|
depth += bounds.length;
|
|
substitutedBounds = A._substituteArray(universe, bounds, typeArguments, depth);
|
|
base = rti._primary;
|
|
substitutedBase = A._substitute(universe, base, typeArguments, depth);
|
|
if (substitutedBounds === bounds && substitutedBase === base)
|
|
return rti;
|
|
return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true);
|
|
case 14:
|
|
index = rti._primary;
|
|
if (index < depth)
|
|
return rti;
|
|
argument = typeArguments[index - depth];
|
|
if (argument == null)
|
|
return rti;
|
|
return argument;
|
|
default:
|
|
throw A.wrapException(A.AssertionError$("Attempted to substitute unexpected RTI kind " + kind));
|
|
}
|
|
},
|
|
_substituteArray(universe, rtiArray, typeArguments, depth) {
|
|
var changed, i, rti, substitutedRti,
|
|
$length = rtiArray.length,
|
|
result = A._Utils_newArrayOrEmpty($length);
|
|
for (changed = false, i = 0; i < $length; ++i) {
|
|
rti = rtiArray[i];
|
|
substitutedRti = A._substitute(universe, rti, typeArguments, depth);
|
|
if (substitutedRti !== rti)
|
|
changed = true;
|
|
result[i] = substitutedRti;
|
|
}
|
|
return changed ? result : rtiArray;
|
|
},
|
|
_substituteNamed(universe, namedArray, typeArguments, depth) {
|
|
var changed, i, t1, t2, rti, substitutedRti,
|
|
$length = namedArray.length,
|
|
result = A._Utils_newArrayOrEmpty($length);
|
|
for (changed = false, i = 0; i < $length; i += 3) {
|
|
t1 = namedArray[i];
|
|
t2 = namedArray[i + 1];
|
|
rti = namedArray[i + 2];
|
|
substitutedRti = A._substitute(universe, rti, typeArguments, depth);
|
|
if (substitutedRti !== rti)
|
|
changed = true;
|
|
result.splice(i, 3, t1, t2, substitutedRti);
|
|
}
|
|
return changed ? result : namedArray;
|
|
},
|
|
_substituteFunctionParameters(universe, functionParameters, typeArguments, depth) {
|
|
var result,
|
|
requiredPositional = functionParameters._requiredPositional,
|
|
substitutedRequiredPositional = A._substituteArray(universe, requiredPositional, typeArguments, depth),
|
|
optionalPositional = functionParameters._optionalPositional,
|
|
substitutedOptionalPositional = A._substituteArray(universe, optionalPositional, typeArguments, depth),
|
|
named = functionParameters._named,
|
|
substitutedNamed = A._substituteNamed(universe, named, typeArguments, depth);
|
|
if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named)
|
|
return functionParameters;
|
|
result = new A._FunctionParameters();
|
|
result._requiredPositional = substitutedRequiredPositional;
|
|
result._optionalPositional = substitutedOptionalPositional;
|
|
result._named = substitutedNamed;
|
|
return result;
|
|
},
|
|
_setArrayType(target, rti) {
|
|
target[init.arrayRti] = rti;
|
|
return target;
|
|
},
|
|
closureFunctionType(closure) {
|
|
var t1,
|
|
signature = closure.$signature;
|
|
if (signature != null) {
|
|
if (typeof signature == "number")
|
|
return A.getTypeFromTypesTable(signature);
|
|
t1 = closure.$signature();
|
|
return t1;
|
|
}
|
|
return null;
|
|
},
|
|
instanceOrFunctionType(object, testRti) {
|
|
var rti;
|
|
if (A.Rti__isUnionOfFunctionType(testRti))
|
|
if (object instanceof A.Closure) {
|
|
rti = A.closureFunctionType(object);
|
|
if (rti != null)
|
|
return rti;
|
|
}
|
|
return A.instanceType(object);
|
|
},
|
|
instanceType(object) {
|
|
var rti;
|
|
if (object instanceof A.Object) {
|
|
rti = object.$ti;
|
|
return rti != null ? rti : A._instanceTypeFromConstructor(object);
|
|
}
|
|
if (Array.isArray(object))
|
|
return A._arrayInstanceType(object);
|
|
return A._instanceTypeFromConstructor(J.getInterceptor$(object));
|
|
},
|
|
_arrayInstanceType(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(object) {
|
|
var rti = object.$ti;
|
|
return rti != null ? rti : A._instanceTypeFromConstructor(object);
|
|
},
|
|
_instanceTypeFromConstructor(instance) {
|
|
var $constructor = instance.constructor,
|
|
probe = $constructor.$ccache;
|
|
if (probe != null)
|
|
return probe;
|
|
return A._instanceTypeFromConstructorMiss(instance, $constructor);
|
|
},
|
|
_instanceTypeFromConstructorMiss(instance, $constructor) {
|
|
var effectiveConstructor = instance instanceof A.Closure ? instance.__proto__.__proto__.constructor : $constructor,
|
|
rti = A._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name);
|
|
$constructor.$ccache = rti;
|
|
return rti;
|
|
},
|
|
getTypeFromTypesTable(index) {
|
|
var rti,
|
|
table = init.types,
|
|
type = table[index];
|
|
if (typeof type == "string") {
|
|
rti = A._Universe_eval(init.typeUniverse, type, false);
|
|
table[index] = rti;
|
|
return rti;
|
|
}
|
|
return type;
|
|
},
|
|
createRuntimeType(rti) {
|
|
var s, starErasedRecipe, starErasedRti,
|
|
type = rti._cachedRuntimeType;
|
|
if (type != null)
|
|
return type;
|
|
s = rti._canonicalRecipe;
|
|
starErasedRecipe = s.replace(/\*/g, "");
|
|
if (starErasedRecipe === s)
|
|
return rti._cachedRuntimeType = new A._Type(rti);
|
|
starErasedRti = A._Universe_eval(init.typeUniverse, starErasedRecipe, true);
|
|
type = starErasedRti._cachedRuntimeType;
|
|
return rti._cachedRuntimeType = type == null ? starErasedRti._cachedRuntimeType = new A._Type(starErasedRti) : type;
|
|
},
|
|
typeLiteral(recipe) {
|
|
return A.createRuntimeType(A._Universe_eval(init.typeUniverse, recipe, false));
|
|
},
|
|
_installSpecializedIsTest(object) {
|
|
var t1, unstarred, isFn, $name, testRti = this;
|
|
if (testRti === type$.Object)
|
|
return A._finishIsFn(testRti, object, A._isObject);
|
|
if (!A.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return A._finishIsFn(testRti, object, A._isTop);
|
|
t1 = testRti._kind;
|
|
unstarred = t1 === 6 ? testRti._primary : testRti;
|
|
if (unstarred === type$.int)
|
|
isFn = A._isInt;
|
|
else if (unstarred === type$.double || unstarred === type$.num)
|
|
isFn = A._isNum;
|
|
else if (unstarred === type$.String)
|
|
isFn = A._isString;
|
|
else
|
|
isFn = unstarred === type$.bool ? A._isBool : null;
|
|
if (isFn != null)
|
|
return A._finishIsFn(testRti, object, isFn);
|
|
if (unstarred._kind === 9) {
|
|
$name = unstarred._primary;
|
|
if (unstarred._rest.every(A.isTopType)) {
|
|
testRti._specializedTestResource = "$is" + $name;
|
|
if ($name === "List")
|
|
return A._finishIsFn(testRti, object, A._isListTestViaProperty);
|
|
return A._finishIsFn(testRti, object, A._isTestViaProperty);
|
|
}
|
|
} else if (t1 === 7)
|
|
return A._finishIsFn(testRti, object, A._generalNullableIsTestImplementation);
|
|
return A._finishIsFn(testRti, object, A._generalIsTestImplementation);
|
|
},
|
|
_finishIsFn(testRti, object, isFn) {
|
|
testRti._is = isFn;
|
|
return testRti._is(object);
|
|
},
|
|
_installSpecializedAsCheck(object) {
|
|
var t1, testRti = this,
|
|
asFn = A._generalAsCheckImplementation;
|
|
if (!A.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
asFn = A._asTop;
|
|
else if (testRti === type$.Object)
|
|
asFn = A._asObject;
|
|
else {
|
|
t1 = A.isNullable(testRti);
|
|
if (t1)
|
|
asFn = A._generalNullableAsCheckImplementation;
|
|
}
|
|
testRti._as = asFn;
|
|
return testRti._as(object);
|
|
},
|
|
_nullIs(testRti) {
|
|
var t1,
|
|
kind = testRti._kind;
|
|
if (!A.isStrongTopType(testRti))
|
|
if (!(testRti === type$.legacy_Object))
|
|
if (!(testRti === type$.legacy_Never))
|
|
if (kind !== 7)
|
|
if (!(kind === 6 && A._nullIs(testRti._primary)))
|
|
t1 = kind === 8 && A._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
return t1;
|
|
},
|
|
_generalIsTestImplementation(object) {
|
|
var testRti = this;
|
|
if (object == null)
|
|
return A._nullIs(testRti);
|
|
return A._isSubtype(init.typeUniverse, A.instanceOrFunctionType(object, testRti), null, testRti, null);
|
|
},
|
|
_generalNullableIsTestImplementation(object) {
|
|
if (object == null)
|
|
return true;
|
|
return this._primary._is(object);
|
|
},
|
|
_isTestViaProperty(object) {
|
|
var tag, testRti = this;
|
|
if (object == null)
|
|
return A._nullIs(testRti);
|
|
tag = testRti._specializedTestResource;
|
|
if (object instanceof A.Object)
|
|
return !!object[tag];
|
|
return !!J.getInterceptor$(object)[tag];
|
|
},
|
|
_isListTestViaProperty(object) {
|
|
var tag, testRti = this;
|
|
if (object == null)
|
|
return A._nullIs(testRti);
|
|
if (typeof object != "object")
|
|
return false;
|
|
if (Array.isArray(object))
|
|
return true;
|
|
tag = testRti._specializedTestResource;
|
|
if (object instanceof A.Object)
|
|
return !!object[tag];
|
|
return !!J.getInterceptor$(object)[tag];
|
|
},
|
|
_generalAsCheckImplementation(object) {
|
|
var t1, testRti = this;
|
|
if (object == null) {
|
|
t1 = A.isNullable(testRti);
|
|
if (t1)
|
|
return object;
|
|
} else if (testRti._is(object))
|
|
return object;
|
|
A._failedAsCheck(object, testRti);
|
|
},
|
|
_generalNullableAsCheckImplementation(object) {
|
|
var testRti = this;
|
|
if (object == null)
|
|
return object;
|
|
else if (testRti._is(object))
|
|
return object;
|
|
A._failedAsCheck(object, testRti);
|
|
},
|
|
_failedAsCheck(object, testRti) {
|
|
throw A.wrapException(A._TypeError$fromMessage(A._Error_compose(object, A.instanceOrFunctionType(object, testRti), A._rtiToString(testRti, null))));
|
|
},
|
|
_Error_compose(object, objectRti, checkedTypeDescription) {
|
|
var objectDescription = A.Error_safeToString(object);
|
|
return objectDescription + ": type '" + A._rtiToString(objectRti == null ? A.instanceType(object) : objectRti, null) + "' is not a subtype of type '" + checkedTypeDescription + "'";
|
|
},
|
|
_TypeError$fromMessage(message) {
|
|
return new A._TypeError("TypeError: " + message);
|
|
},
|
|
_TypeError__TypeError$forType(object, type) {
|
|
return new A._TypeError("TypeError: " + A._Error_compose(object, null, type));
|
|
},
|
|
_isObject(object) {
|
|
return object != null;
|
|
},
|
|
_asObject(object) {
|
|
if (object != null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "Object"));
|
|
},
|
|
_isTop(object) {
|
|
return true;
|
|
},
|
|
_asTop(object) {
|
|
return object;
|
|
},
|
|
_isBool(object) {
|
|
return true === object || false === object;
|
|
},
|
|
_asBool(object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
|
|
},
|
|
_asBoolS(object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
|
|
},
|
|
_asBoolQ(object) {
|
|
if (true === object)
|
|
return true;
|
|
if (false === object)
|
|
return false;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "bool?"));
|
|
},
|
|
_asDouble(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
|
|
},
|
|
_asDoubleS(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
|
|
},
|
|
_asDoubleQ(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "double?"));
|
|
},
|
|
_isInt(object) {
|
|
return typeof object == "number" && Math.floor(object) === object;
|
|
},
|
|
_asInt(object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
|
|
},
|
|
_asIntS(object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
|
|
},
|
|
_asIntQ(object) {
|
|
if (typeof object == "number" && Math.floor(object) === object)
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "int?"));
|
|
},
|
|
_isNum(object) {
|
|
return typeof object == "number";
|
|
},
|
|
_asNum(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
|
|
},
|
|
_asNumS(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
|
|
},
|
|
_asNumQ(object) {
|
|
if (typeof object == "number")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "num?"));
|
|
},
|
|
_isString(object) {
|
|
return typeof object == "string";
|
|
},
|
|
_asString(object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
|
|
},
|
|
_asStringS(object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
|
|
},
|
|
_asStringQ(object) {
|
|
if (typeof object == "string")
|
|
return object;
|
|
if (object == null)
|
|
return object;
|
|
throw A.wrapException(A._TypeError__TypeError$forType(object, "String?"));
|
|
},
|
|
_rtiArrayToString(array, genericContext) {
|
|
var s, sep, i;
|
|
for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ")
|
|
s += sep + A._rtiToString(array[i], genericContext);
|
|
return s;
|
|
},
|
|
_recordRtiToString(recordType, genericContext) {
|
|
var fieldCount, names, namesIndex, s, comma, i,
|
|
partialShape = recordType._primary,
|
|
fields = recordType._rest;
|
|
if ("" === partialShape)
|
|
return "(" + A._rtiArrayToString(fields, genericContext) + ")";
|
|
fieldCount = fields.length;
|
|
names = partialShape.split(",");
|
|
namesIndex = names.length - fieldCount;
|
|
for (s = "(", comma = "", i = 0; i < fieldCount; ++i, comma = ", ") {
|
|
s += comma;
|
|
if (namesIndex === 0)
|
|
s += "{";
|
|
s += A._rtiToString(fields[i], genericContext);
|
|
if (namesIndex >= 0)
|
|
s += " " + names[namesIndex];
|
|
++namesIndex;
|
|
}
|
|
return s + "})";
|
|
},
|
|
_functionRtiToString(functionType, genericContext, bounds) {
|
|
var boundsLength, outerContextLength, offset, i, t1, t2, typeParametersText, typeSep, t3, t4, boundRti, kind, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ";
|
|
if (bounds != null) {
|
|
boundsLength = bounds.length;
|
|
if (genericContext == null) {
|
|
genericContext = A._setArrayType([], type$.JSArray_String);
|
|
outerContextLength = null;
|
|
} else
|
|
outerContextLength = genericContext.length;
|
|
offset = genericContext.length;
|
|
for (i = boundsLength; i > 0; --i)
|
|
B.JSArray_methods.add$1(genericContext, "T" + (offset + i));
|
|
for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) {
|
|
t3 = genericContext.length;
|
|
t4 = t3 - 1 - i;
|
|
if (!(t4 >= 0))
|
|
return A.ioore(genericContext, t4);
|
|
typeParametersText = B.JSString_methods.$add(typeParametersText + typeSep, genericContext[t4]);
|
|
boundRti = bounds[i];
|
|
kind = boundRti._kind;
|
|
if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1))
|
|
if (!(boundRti === t2))
|
|
t3 = false;
|
|
else
|
|
t3 = true;
|
|
else
|
|
t3 = true;
|
|
if (!t3)
|
|
typeParametersText += " extends " + A._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 = A._rtiToString(t1, genericContext);
|
|
for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_)
|
|
argumentsText += sep + A._rtiToString(requiredPositional[i], genericContext);
|
|
if (optionalPositionalLength > 0) {
|
|
argumentsText += sep + "[";
|
|
for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_)
|
|
argumentsText += sep + A._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 += A._rtiToString(named[i + 2], genericContext) + " " + named[i];
|
|
}
|
|
argumentsText += "}";
|
|
}
|
|
if (outerContextLength != null) {
|
|
genericContext.toString;
|
|
genericContext.length = outerContextLength;
|
|
}
|
|
return typeParametersText + "(" + argumentsText + ") => " + returnTypeText;
|
|
},
|
|
_rtiToString(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 = A._rtiToString(rti._primary, genericContext);
|
|
return s;
|
|
}
|
|
if (kind === 7) {
|
|
questionArgument = rti._primary;
|
|
s = A._rtiToString(questionArgument, genericContext);
|
|
argumentKind = questionArgument._kind;
|
|
return (argumentKind === 12 || argumentKind === 13 ? "(" + s + ")" : s) + "?";
|
|
}
|
|
if (kind === 8)
|
|
return "FutureOr<" + A._rtiToString(rti._primary, genericContext) + ">";
|
|
if (kind === 9) {
|
|
$name = A._unminifyOrTag(rti._primary);
|
|
$arguments = rti._rest;
|
|
return $arguments.length > 0 ? $name + ("<" + A._rtiArrayToString($arguments, genericContext) + ">") : $name;
|
|
}
|
|
if (kind === 11)
|
|
return A._recordRtiToString(rti, genericContext);
|
|
if (kind === 12)
|
|
return A._functionRtiToString(rti, genericContext, null);
|
|
if (kind === 13)
|
|
return A._functionRtiToString(rti._primary, genericContext, rti._rest);
|
|
if (kind === 14) {
|
|
t1 = rti._primary;
|
|
t2 = genericContext.length;
|
|
t1 = t2 - 1 - t1;
|
|
if (!(t1 >= 0 && t1 < t2))
|
|
return A.ioore(genericContext, t1);
|
|
return genericContext[t1];
|
|
}
|
|
return "?";
|
|
},
|
|
_unminifyOrTag(rawClassName) {
|
|
var preserved = init.mangledGlobalNames[rawClassName];
|
|
if (preserved != null)
|
|
return preserved;
|
|
return rawClassName;
|
|
},
|
|
_Universe_findRule(universe, targetType) {
|
|
var rule = universe.tR[targetType];
|
|
for (; typeof rule == "string";)
|
|
rule = universe.tR[rule];
|
|
return rule;
|
|
},
|
|
_Universe_findErasedType(universe, cls) {
|
|
var $length, erased, $arguments, i, $interface,
|
|
t1 = universe.eT,
|
|
probe = t1[cls];
|
|
if (probe == null)
|
|
return A._Universe_eval(universe, cls, false);
|
|
else if (typeof probe == "number") {
|
|
$length = probe;
|
|
erased = A._Universe__lookupTerminalRti(universe, 5, "#");
|
|
$arguments = A._Utils_newArrayOrEmpty($length);
|
|
for (i = 0; i < $length; ++i)
|
|
$arguments[i] = erased;
|
|
$interface = A._Universe__lookupInterfaceRti(universe, cls, $arguments);
|
|
t1[cls] = $interface;
|
|
return $interface;
|
|
} else
|
|
return probe;
|
|
},
|
|
_Universe_addRules(universe, rules) {
|
|
return A._Utils_objectAssign(universe.tR, rules);
|
|
},
|
|
_Universe_addErasedTypes(universe, types) {
|
|
return A._Utils_objectAssign(universe.eT, types);
|
|
},
|
|
_Universe_eval(universe, recipe, normalize) {
|
|
var rti,
|
|
t1 = universe.eC,
|
|
probe = t1.get(recipe);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = A._Parser_parse(A._Parser_create(universe, null, recipe, normalize));
|
|
t1.set(recipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe_evalInEnvironment(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 = A._Parser_parse(A._Parser_create(universe, environment, recipe, true));
|
|
cache.set(recipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe_bind(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 = A._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]);
|
|
cache.set(argumentsRecipe, rti);
|
|
return rti;
|
|
},
|
|
_Universe__installTypeTests(universe, rti) {
|
|
rti._as = A._installSpecializedAsCheck;
|
|
rti._is = A._installSpecializedIsTest;
|
|
return rti;
|
|
},
|
|
_Universe__lookupTerminalRti(universe, kind, key) {
|
|
var rti, t1,
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = kind;
|
|
rti._canonicalRecipe = key;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupStarRti(universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "*",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = A._Universe__createStarRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createStarRti(universe, baseType, key, normalize) {
|
|
var baseKind, t1, rti;
|
|
if (normalize) {
|
|
baseKind = baseType._kind;
|
|
if (!A.isStrongTopType(baseType))
|
|
t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return baseType;
|
|
}
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 6;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return A._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupQuestionRti(universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "?",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = A._Universe__createQuestionRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createQuestionRti(universe, baseType, key, normalize) {
|
|
var baseKind, t1, starArgument, rti;
|
|
if (normalize) {
|
|
baseKind = baseType._kind;
|
|
if (!A.isStrongTopType(baseType))
|
|
if (!(baseType === type$.Null || baseType === type$.JSNull))
|
|
if (baseKind !== 7)
|
|
t1 = baseKind === 8 && A.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 && A.isNullable(starArgument._primary))
|
|
return starArgument;
|
|
else
|
|
return A.Rti__getQuestionFromStar(universe, baseType);
|
|
}
|
|
}
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 7;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return A._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupFutureOrRti(universe, baseType, normalize) {
|
|
var t1,
|
|
key = baseType._canonicalRecipe + "/",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = A._Universe__createFutureOrRti(universe, baseType, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createFutureOrRti(universe, baseType, key, normalize) {
|
|
var t1, t2, rti;
|
|
if (normalize) {
|
|
t1 = baseType._kind;
|
|
if (!A.isStrongTopType(baseType))
|
|
if (!(baseType === type$.legacy_Object))
|
|
t2 = false;
|
|
else
|
|
t2 = true;
|
|
else
|
|
t2 = true;
|
|
if (t2 || baseType === type$.Object)
|
|
return baseType;
|
|
else if (t1 === 1)
|
|
return A._Universe__lookupInterfaceRti(universe, "Future", [baseType]);
|
|
else if (baseType === type$.Null || baseType === type$.JSNull)
|
|
return type$.nullable_Future_Null;
|
|
}
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 8;
|
|
rti._primary = baseType;
|
|
rti._canonicalRecipe = key;
|
|
return A._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Universe__lookupGenericFunctionParameterRti(universe, index) {
|
|
var rti, t1,
|
|
key = "" + index + "^",
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 14;
|
|
rti._primary = index;
|
|
rti._canonicalRecipe = key;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__canonicalRecipeJoin($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($arguments) {
|
|
var s, sep, i, t1, nameSep,
|
|
$length = $arguments.length;
|
|
for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") {
|
|
t1 = $arguments[i];
|
|
nameSep = $arguments[i + 1] ? "!" : ":";
|
|
s += sep + t1 + nameSep + $arguments[i + 2]._canonicalRecipe;
|
|
}
|
|
return s;
|
|
},
|
|
_Universe__lookupInterfaceRti(universe, $name, $arguments) {
|
|
var probe, rti, t1,
|
|
s = $name;
|
|
if ($arguments.length > 0)
|
|
s += "<" + A._Universe__canonicalRecipeJoin($arguments) + ">";
|
|
probe = universe.eC.get(s);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 9;
|
|
rti._primary = $name;
|
|
rti._rest = $arguments;
|
|
if ($arguments.length > 0)
|
|
rti._precomputed1 = $arguments[0];
|
|
rti._canonicalRecipe = s;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(s, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupBindingRti(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 + (";<" + A._Universe__canonicalRecipeJoin(newArguments) + ">");
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 10;
|
|
rti._primary = newBase;
|
|
rti._rest = newArguments;
|
|
rti._canonicalRecipe = key;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupRecordRti(universe, partialShapeTag, fields) {
|
|
var rti, t1,
|
|
key = "+" + (partialShapeTag + "(" + A._Universe__canonicalRecipeJoin(fields) + ")"),
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 11;
|
|
rti._primary = partialShapeTag;
|
|
rti._rest = fields;
|
|
rti._canonicalRecipe = key;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupFunctionRti(universe, returnType, parameters) {
|
|
var sep, key, probe, rti, t1,
|
|
s = returnType._canonicalRecipe,
|
|
requiredPositional = parameters._requiredPositional,
|
|
requiredPositionalLength = requiredPositional.length,
|
|
optionalPositional = parameters._optionalPositional,
|
|
optionalPositionalLength = optionalPositional.length,
|
|
named = parameters._named,
|
|
namedLength = named.length,
|
|
recipe = "(" + A._Universe__canonicalRecipeJoin(requiredPositional);
|
|
if (optionalPositionalLength > 0) {
|
|
sep = requiredPositionalLength > 0 ? "," : "";
|
|
recipe += sep + "[" + A._Universe__canonicalRecipeJoin(optionalPositional) + "]";
|
|
}
|
|
if (namedLength > 0) {
|
|
sep = requiredPositionalLength > 0 ? "," : "";
|
|
recipe += sep + "{" + A._Universe__canonicalRecipeJoinNamed(named) + "}";
|
|
}
|
|
key = s + (recipe + ")");
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 12;
|
|
rti._primary = returnType;
|
|
rti._rest = parameters;
|
|
rti._canonicalRecipe = key;
|
|
t1 = A._Universe__installTypeTests(universe, rti);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__lookupGenericFunctionRti(universe, baseFunctionType, bounds, normalize) {
|
|
var t1,
|
|
key = baseFunctionType._canonicalRecipe + ("<" + A._Universe__canonicalRecipeJoin(bounds) + ">"),
|
|
probe = universe.eC.get(key);
|
|
if (probe != null)
|
|
return probe;
|
|
t1 = A._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize);
|
|
universe.eC.set(key, t1);
|
|
return t1;
|
|
},
|
|
_Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize) {
|
|
var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti;
|
|
if (normalize) {
|
|
$length = bounds.length;
|
|
typeArguments = A._Utils_newArrayOrEmpty($length);
|
|
for (count = 0, i = 0; i < $length; ++i) {
|
|
bound = bounds[i];
|
|
if (bound._kind === 1) {
|
|
typeArguments[i] = bound;
|
|
++count;
|
|
}
|
|
}
|
|
if (count > 0) {
|
|
substitutedBase = A._substitute(universe, baseFunctionType, typeArguments, 0);
|
|
substitutedBounds = A._substituteArray(universe, bounds, typeArguments, 0);
|
|
return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds);
|
|
}
|
|
}
|
|
rti = new A.Rti(null, null);
|
|
rti._kind = 13;
|
|
rti._primary = baseFunctionType;
|
|
rti._rest = bounds;
|
|
rti._canonicalRecipe = key;
|
|
return A._Universe__installTypeTests(universe, rti);
|
|
},
|
|
_Parser_create(universe, environment, recipe, normalize) {
|
|
return {u: universe, e: environment, r: recipe, s: [], p: 0, n: normalize};
|
|
},
|
|
_Parser_parse(parser) {
|
|
var t2, i, ch, t3, array, head, base, end, item,
|
|
source = parser.r,
|
|
t1 = parser.s;
|
|
for (t2 = source.length, i = 0; i < t2;) {
|
|
ch = source.charCodeAt(i);
|
|
if (ch >= 48 && ch <= 57)
|
|
i = A._Parser_handleDigit(i + 1, ch, source, t1);
|
|
else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124)
|
|
i = A._Parser_handleIdentifier(parser, i, source, t1, false);
|
|
else if (ch === 46)
|
|
i = A._Parser_handleIdentifier(parser, i, source, t1, true);
|
|
else {
|
|
++i;
|
|
switch (ch) {
|
|
case 44:
|
|
break;
|
|
case 58:
|
|
t1.push(false);
|
|
break;
|
|
case 33:
|
|
t1.push(true);
|
|
break;
|
|
case 59:
|
|
t1.push(A._Parser_toType(parser.u, parser.e, t1.pop()));
|
|
break;
|
|
case 94:
|
|
t1.push(A._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop()));
|
|
break;
|
|
case 35:
|
|
t1.push(A._Universe__lookupTerminalRti(parser.u, 5, "#"));
|
|
break;
|
|
case 64:
|
|
t1.push(A._Universe__lookupTerminalRti(parser.u, 2, "@"));
|
|
break;
|
|
case 126:
|
|
t1.push(A._Universe__lookupTerminalRti(parser.u, 3, "~"));
|
|
break;
|
|
case 60:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 62:
|
|
t3 = parser.u;
|
|
array = t1.splice(parser.p);
|
|
A._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
head = t1.pop();
|
|
if (typeof head == "string")
|
|
t1.push(A._Universe__lookupInterfaceRti(t3, head, array));
|
|
else {
|
|
base = A._Parser_toType(t3, parser.e, head);
|
|
switch (base._kind) {
|
|
case 12:
|
|
t1.push(A._Universe__lookupGenericFunctionRti(t3, base, array, parser.n));
|
|
break;
|
|
default:
|
|
t1.push(A._Universe__lookupBindingRti(t3, base, array));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 38:
|
|
A._Parser_handleExtendedOperations(parser, t1);
|
|
break;
|
|
case 42:
|
|
t3 = parser.u;
|
|
t1.push(A._Universe__lookupStarRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 63:
|
|
t3 = parser.u;
|
|
t1.push(A._Universe__lookupQuestionRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 47:
|
|
t3 = parser.u;
|
|
t1.push(A._Universe__lookupFutureOrRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
|
|
break;
|
|
case 40:
|
|
t1.push(-3);
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 41:
|
|
A._Parser_handleArguments(parser, t1);
|
|
break;
|
|
case 91:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 93:
|
|
array = t1.splice(parser.p);
|
|
A._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
t1.push(array);
|
|
t1.push(-1);
|
|
break;
|
|
case 123:
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
break;
|
|
case 125:
|
|
array = t1.splice(parser.p);
|
|
A._Parser_toTypesNamed(parser.u, parser.e, array);
|
|
parser.p = t1.pop();
|
|
t1.push(array);
|
|
t1.push(-2);
|
|
break;
|
|
case 43:
|
|
end = source.indexOf("(", i);
|
|
t1.push(source.substring(i, end));
|
|
t1.push(-4);
|
|
t1.push(parser.p);
|
|
parser.p = t1.length;
|
|
i = end + 1;
|
|
break;
|
|
default:
|
|
throw "Bad character " + ch;
|
|
}
|
|
}
|
|
}
|
|
item = t1.pop();
|
|
return A._Parser_toType(parser.u, parser.e, item);
|
|
},
|
|
_Parser_handleDigit(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(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 || ch === 124))
|
|
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 = A._Universe_findRule(t1, environment._primary)[string];
|
|
if (recipe == null)
|
|
A.throwExpression('No "' + string + '" in "' + A.Rti__getCanonicalRecipe(environment) + '"');
|
|
stack.push(A._Universe_evalInEnvironment(t1, environment, recipe));
|
|
} else
|
|
stack.push(string);
|
|
return i;
|
|
},
|
|
_Parser_handleArguments(parser, stack) {
|
|
var optionalPositional, named, requiredPositional, returnType, parameters, _null = null,
|
|
t1 = parser.u,
|
|
head = stack.pop();
|
|
if (typeof head == "number")
|
|
switch (head) {
|
|
case -1:
|
|
optionalPositional = stack.pop();
|
|
named = _null;
|
|
break;
|
|
case -2:
|
|
named = stack.pop();
|
|
optionalPositional = _null;
|
|
break;
|
|
default:
|
|
stack.push(head);
|
|
named = _null;
|
|
optionalPositional = named;
|
|
break;
|
|
}
|
|
else {
|
|
stack.push(head);
|
|
named = _null;
|
|
optionalPositional = named;
|
|
}
|
|
requiredPositional = A._Parser_collectArray(parser, stack);
|
|
head = stack.pop();
|
|
switch (head) {
|
|
case -3:
|
|
head = stack.pop();
|
|
if (optionalPositional == null)
|
|
optionalPositional = t1.sEA;
|
|
if (named == null)
|
|
named = t1.sEA;
|
|
returnType = A._Parser_toType(t1, parser.e, head);
|
|
parameters = new A._FunctionParameters();
|
|
parameters._requiredPositional = requiredPositional;
|
|
parameters._optionalPositional = optionalPositional;
|
|
parameters._named = named;
|
|
stack.push(A._Universe__lookupFunctionRti(t1, returnType, parameters));
|
|
return;
|
|
case -4:
|
|
stack.push(A._Universe__lookupRecordRti(t1, stack.pop(), requiredPositional));
|
|
return;
|
|
default:
|
|
throw A.wrapException(A.AssertionError$("Unexpected state under `()`: " + A.S(head)));
|
|
}
|
|
},
|
|
_Parser_handleExtendedOperations(parser, stack) {
|
|
var $top = stack.pop();
|
|
if (0 === $top) {
|
|
stack.push(A._Universe__lookupTerminalRti(parser.u, 1, "0&"));
|
|
return;
|
|
}
|
|
if (1 === $top) {
|
|
stack.push(A._Universe__lookupTerminalRti(parser.u, 4, "1&"));
|
|
return;
|
|
}
|
|
throw A.wrapException(A.AssertionError$("Unexpected extended operation " + A.S($top)));
|
|
},
|
|
_Parser_collectArray(parser, stack) {
|
|
var array = stack.splice(parser.p);
|
|
A._Parser_toTypes(parser.u, parser.e, array);
|
|
parser.p = stack.pop();
|
|
return array;
|
|
},
|
|
_Parser_toType(universe, environment, item) {
|
|
if (typeof item == "string")
|
|
return A._Universe__lookupInterfaceRti(universe, item, universe.sEA);
|
|
else if (typeof item == "number") {
|
|
environment.toString;
|
|
return A._Parser_indexToType(universe, environment, item);
|
|
} else
|
|
return item;
|
|
},
|
|
_Parser_toTypes(universe, environment, items) {
|
|
var i,
|
|
$length = items.length;
|
|
for (i = 0; i < $length; ++i)
|
|
items[i] = A._Parser_toType(universe, environment, items[i]);
|
|
},
|
|
_Parser_toTypesNamed(universe, environment, items) {
|
|
var i,
|
|
$length = items.length;
|
|
for (i = 2; i < $length; i += 3)
|
|
items[i] = A._Parser_toType(universe, environment, items[i]);
|
|
},
|
|
_Parser_indexToType(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 A.wrapException(A.AssertionError$("Indexed base must be an interface type"));
|
|
typeArguments = environment._rest;
|
|
if (index <= typeArguments.length)
|
|
return typeArguments[index - 1];
|
|
throw A.wrapException(A.AssertionError$("Bad index " + index + " for " + environment.toString$0(0)));
|
|
},
|
|
_isSubtype(universe, s, sEnv, t, tEnv) {
|
|
var t1, sKind, leftTypeVariable, tKind, sBounds, tBounds, sLength, i, sBound, tBound;
|
|
if (s === t)
|
|
return true;
|
|
if (!A.isStrongTopType(t))
|
|
if (!(t === type$.legacy_Object))
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return true;
|
|
sKind = s._kind;
|
|
if (sKind === 4)
|
|
return true;
|
|
if (A.isStrongTopType(s))
|
|
return false;
|
|
if (s._kind !== 1)
|
|
t1 = false;
|
|
else
|
|
t1 = true;
|
|
if (t1)
|
|
return true;
|
|
leftTypeVariable = sKind === 14;
|
|
if (leftTypeVariable)
|
|
if (A._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv))
|
|
return true;
|
|
tKind = t._kind;
|
|
t1 = s === type$.Null || s === type$.JSNull;
|
|
if (t1) {
|
|
if (tKind === 8)
|
|
return A._isSubtype(universe, s, sEnv, t._primary, tEnv);
|
|
return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6;
|
|
}
|
|
if (t === type$.Object) {
|
|
if (sKind === 8)
|
|
return A._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
if (sKind === 6)
|
|
return A._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
return sKind !== 7;
|
|
}
|
|
if (sKind === 6)
|
|
return A._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
if (tKind === 6) {
|
|
t1 = A.Rti__getQuestionFromStar(universe, t);
|
|
return A._isSubtype(universe, s, sEnv, t1, tEnv);
|
|
}
|
|
if (sKind === 8) {
|
|
if (!A._isSubtype(universe, s._primary, sEnv, t, tEnv))
|
|
return false;
|
|
return A._isSubtype(universe, A.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv);
|
|
}
|
|
if (sKind === 7) {
|
|
t1 = A._isSubtype(universe, type$.Null, sEnv, t, tEnv);
|
|
return t1 && A._isSubtype(universe, s._primary, sEnv, t, tEnv);
|
|
}
|
|
if (tKind === 8) {
|
|
if (A._isSubtype(universe, s, sEnv, t._primary, tEnv))
|
|
return true;
|
|
return A._isSubtype(universe, s, sEnv, A.Rti__getFutureFromFutureOr(universe, t), tEnv);
|
|
}
|
|
if (tKind === 7) {
|
|
t1 = A._isSubtype(universe, s, sEnv, type$.Null, tEnv);
|
|
return t1 || A._isSubtype(universe, s, sEnv, t._primary, tEnv);
|
|
}
|
|
if (leftTypeVariable)
|
|
return false;
|
|
t1 = sKind !== 12;
|
|
if ((!t1 || sKind === 13) && t === type$.Function)
|
|
return true;
|
|
if (tKind === 13) {
|
|
if (s === type$.JavaScriptFunction)
|
|
return true;
|
|
if (sKind !== 13)
|
|
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 (!A._isSubtype(universe, sBound, sEnv, tBound, tEnv) || !A._isSubtype(universe, tBound, tEnv, sBound, sEnv))
|
|
return false;
|
|
}
|
|
return A._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv);
|
|
}
|
|
if (tKind === 12) {
|
|
if (s === type$.JavaScriptFunction)
|
|
return true;
|
|
if (t1)
|
|
return false;
|
|
return A._isFunctionSubtype(universe, s, sEnv, t, tEnv);
|
|
}
|
|
if (sKind === 9) {
|
|
if (tKind !== 9)
|
|
return false;
|
|
return A._isInterfaceSubtype(universe, s, sEnv, t, tEnv);
|
|
}
|
|
t1 = sKind === 11;
|
|
if (t1 && t === type$.Record)
|
|
return true;
|
|
if (t1 && tKind === 11)
|
|
return A._isRecordSubtype(universe, s, sEnv, t, tEnv);
|
|
return false;
|
|
},
|
|
_isFunctionSubtype(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 (!A._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 + |