/* Scala.js runtime support
* Copyright 2013 LAMP/EPFL
* Author: Sébastien Doeraene
*/
/* ---------------------------------- *
* The top-level Scala.js environment *
* ---------------------------------- */
var ScalaJS = {};
// Get the environment info
ScalaJS.env = (typeof __ScalaJSEnv === "object" && __ScalaJSEnv) ? __ScalaJSEnv : {};
// Global scope
ScalaJS.g =
(typeof ScalaJS.env["global"] === "object" && ScalaJS.env["global"])
? ScalaJS.env["global"]
: ((typeof global === "object" && global && global["Object"] === Object) ? global : this);
ScalaJS.env["global"] = ScalaJS.g;
// Where to send exports
ScalaJS.e =
(typeof ScalaJS.env["exportsNamespace"] === "object" && ScalaJS.env["exportsNamespace"])
? ScalaJS.env["exportsNamespace"] : ScalaJS.g;
ScalaJS.env["exportsNamespace"] = ScalaJS.e;
// Freeze the environment info
ScalaJS.g["Object"]["freeze"](ScalaJS.env);
// Other fields
ScalaJS.d = {}; // Data for types
ScalaJS.c = {}; // Scala.js constructors
ScalaJS.h = {}; // Inheritable constructors (without initialization code)
ScalaJS.i = {}; // Implementation class modules
ScalaJS.n = {}; // Module instances
ScalaJS.m = {}; // Module accessors
ScalaJS.is = {}; // isInstanceOf methods
ScalaJS.isArrayOf = {}; // isInstanceOfArrayOf methods
//!if asInstanceOfs != Unchecked
ScalaJS.as = {}; // asInstanceOf methods
ScalaJS.asArrayOf = {}; // asInstanceOfArrayOf methods
//!endif
ScalaJS.lastIDHash = 0; // last value attributed to an id hash code
// Core mechanism
ScalaJS.makeIsArrayOfPrimitive = function(primitiveData) {
return function(obj, depth) {
return !!(obj && obj.$classData &&
(obj.$classData.arrayDepth === depth) &&
(obj.$classData.arrayBase === primitiveData));
}
};
//!if asInstanceOfs != Unchecked
ScalaJS.makeAsArrayOfPrimitive = function(isInstanceOfFunction, arrayEncodedName) {
return function(obj, depth) {
if (isInstanceOfFunction(obj, depth) || (obj === null))
return obj;
else
ScalaJS.throwArrayCastException(obj, arrayEncodedName, depth);
}
};
//!endif
/** Encode a property name for runtime manipulation
* Usage:
* env.propertyName({someProp:0})
* Returns:
* "someProp"
* Useful when the property is renamed by a global optimizer (like Closure)
* but we must still get hold of a string of that name for runtime
* reflection.
*/
ScalaJS.propertyName = function(obj) {
var result;
for (var prop in obj)
result = prop;
return result;
};
// Runtime functions
ScalaJS.isScalaJSObject = function(obj) {
return !!(obj && obj.$classData);
};
//!if asInstanceOfs != Unchecked
ScalaJS.throwClassCastException = function(instance, classFullName) {
//!if asInstanceOfs == Compliant
throw new ScalaJS.c.jl_ClassCastException().init___T(
instance + " is not an instance of " + classFullName);
//!else
throw new ScalaJS.c.sjsr_UndefinedBehaviorError().init___jl_Throwable(
new ScalaJS.c.jl_ClassCastException().init___T(
instance + " is not an instance of " + classFullName));
//!endif
};
ScalaJS.throwArrayCastException = function(instance, classArrayEncodedName, depth) {
for (; depth; --depth)
classArrayEncodedName = "[" + classArrayEncodedName;
ScalaJS.throwClassCastException(instance, classArrayEncodedName);
};
//!endif
ScalaJS.makeNativeArrayWrapper = function(arrayClassData, nativeArray) {
return new arrayClassData.constr(nativeArray);
};
ScalaJS.newArrayObject = function(arrayClassData, lengths) {
return ScalaJS.newArrayObjectInternal(arrayClassData, lengths, 0);
};
ScalaJS.newArrayObjectInternal = function(arrayClassData, lengths, lengthIndex) {
var result = new arrayClassData.constr(lengths[lengthIndex]);
if (lengthIndex < lengths.length-1) {
var subArrayClassData = arrayClassData.componentData;
var subLengthIndex = lengthIndex+1;
var underlying = result.u;
for (var i = 0; i < underlying.length; i++) {
underlying[i] = ScalaJS.newArrayObjectInternal(
subArrayClassData, lengths, subLengthIndex);
}
}
return result;
};
ScalaJS.checkNonNull = function(obj) {
return obj !== null ? obj : ScalaJS.throwNullPointerException();
};
ScalaJS.throwNullPointerException = function() {
throw new ScalaJS.c.jl_NullPointerException().init___();
};
ScalaJS.objectToString = function(instance) {
if (instance === void 0)
return "undefined";
else
return instance.toString();
};
ScalaJS.objectGetClass = function(instance) {
switch (typeof instance) {
case "string":
return ScalaJS.d.T.getClassOf();
case "number":
var v = instance | 0;
if (v === instance) { // is the value integral?
if (ScalaJS.isByte(v))
return ScalaJS.d.jl_Byte.getClassOf();
else if (ScalaJS.isShort(v))
return ScalaJS.d.jl_Short.getClassOf();
else
return ScalaJS.d.jl_Integer.getClassOf();
} else {
if (ScalaJS.isFloat(instance))
return ScalaJS.d.jl_Float.getClassOf();
else
return ScalaJS.d.jl_Double.getClassOf();
}
case "boolean":
return ScalaJS.d.jl_Boolean.getClassOf();
case "undefined":
return ScalaJS.d.sr_BoxedUnit.getClassOf();
default:
if (instance === null)
ScalaJS.throwNullPointerException();
else if (ScalaJS.is.sjsr_RuntimeLong(instance))
return ScalaJS.d.jl_Long.getClassOf();
else if (ScalaJS.isScalaJSObject(instance))
return instance.$classData.getClassOf();
else
return null; // Exception?
}
};
ScalaJS.objectClone = function(instance) {
if (ScalaJS.isScalaJSObject(instance) || (instance === null))
return instance.clone__O();
else
throw new ScalaJS.c.jl_CloneNotSupportedException().init___();
};
ScalaJS.objectNotify = function(instance) {
// final and no-op in java.lang.Object
if (instance === null)
instance.notify__V();
};
ScalaJS.objectNotifyAll = function(instance) {
// final and no-op in java.lang.Object
if (instance === null)
instance.notifyAll__V();
};
ScalaJS.objectFinalize = function(instance) {
if (ScalaJS.isScalaJSObject(instance) || (instance === null))
instance.finalize__V();
// else no-op
};
ScalaJS.objectEquals = function(instance, rhs) {
if (ScalaJS.isScalaJSObject(instance) || (instance === null))
return instance.equals__O__Z(rhs);
else if (typeof instance === "number")
return typeof rhs === "number" && ScalaJS.numberEquals(instance, rhs);
else
return instance === rhs;
};
ScalaJS.numberEquals = function(lhs, rhs) {
return (
lhs === rhs // 0.0 === -0.0 to prioritize the Int case over the Double case
) || (
// are they both NaN?
(lhs !== lhs) && (rhs !== rhs)
);
};
ScalaJS.objectHashCode = function(instance) {
switch (typeof instance) {
case "string":
return ScalaJS.m.sjsr_RuntimeString().hashCode__T__I(instance);
case "number":
return ScalaJS.m.sjsr_Bits().numberHashCode__D__I(instance);
case "boolean":
return instance ? 1231 : 1237;
case "undefined":
return 0;
default:
if (ScalaJS.isScalaJSObject(instance) || instance === null)
return instance.hashCode__I();
else
return 42; // TODO?
}
};
ScalaJS.comparableCompareTo = function(instance, rhs) {
switch (typeof instance) {
case "string":
//!if asInstanceOfs != Unchecked
ScalaJS.as.T(rhs);
//!endif
return instance === rhs ? 0 : (instance < rhs ? -1 : 1);
case "number":
//!if asInstanceOfs != Unchecked
ScalaJS.as.jl_Number(rhs);
//!endif
return ScalaJS.numberEquals(instance, rhs) ? 0 : (instance < rhs ? -1 : 1);
case "boolean":
//!if asInstanceOfs != Unchecked
ScalaJS.asBoolean(rhs);
//!endif
return instance - rhs; // yes, this gives the right result
default:
return instance.compareTo__O__I(rhs);
}
};
ScalaJS.charSequenceLength = function(instance) {
if (typeof(instance) === "string")
//!if asInstanceOfs != Unchecked
return ScalaJS.uI(instance["length"]);
//!else
return instance["length"] | 0;
//!endif
else
return instance.length__I();
};
ScalaJS.charSequenceCharAt = function(instance, index) {
if (typeof(instance) === "string")
//!if asInstanceOfs != Unchecked
return ScalaJS.uI(instance["charCodeAt"](index)) & 0xffff;
//!else
return instance["charCodeAt"](index) & 0xffff;
//!endif
else
return instance.charAt__I__C(index);
};
ScalaJS.charSequenceSubSequence = function(instance, start, end) {
if (typeof(instance) === "string")
//!if asInstanceOfs != Unchecked
return ScalaJS.as.T(instance["substring"](start, end));
//!else
return instance["substring"](start, end);
//!endif
else
return instance.subSequence__I__I__jl_CharSequence(start, end);
};
ScalaJS.booleanBooleanValue = function(instance) {
if (typeof instance === "boolean") return instance;
else return instance.booleanValue__Z();
};
ScalaJS.numberByteValue = function(instance) {
if (typeof instance === "number") return (instance << 24) >> 24;
else return instance.byteValue__B();
};
ScalaJS.numberShortValue = function(instance) {
if (typeof instance === "number") return (instance << 16) >> 16;
else return instance.shortValue__S();
};
ScalaJS.numberIntValue = function(instance) {
if (typeof instance === "number") return instance | 0;
else return instance.intValue__I();
};
ScalaJS.numberLongValue = function(instance) {
if (typeof instance === "number")
return ScalaJS.m.sjsr_RuntimeLong().fromDouble__D__sjsr_RuntimeLong(instance);
else
return instance.longValue__J();
};
ScalaJS.numberFloatValue = function(instance) {
if (typeof instance === "number") return ScalaJS.fround(instance);
else return instance.floatValue__F();
};
ScalaJS.numberDoubleValue = function(instance) {
if (typeof instance === "number") return instance;
else return instance.doubleValue__D();
};
ScalaJS.isNaN = function(instance) {
return instance !== instance;
};
ScalaJS.isInfinite = function(instance) {
return !ScalaJS.g["isFinite"](instance) && !ScalaJS.isNaN(instance);
};
ScalaJS.propertiesOf = function(obj) {
var result = [];
for (var prop in obj)
result["push"](prop);
return result;
};
ScalaJS.systemArraycopy = function(src, srcPos, dest, destPos, length) {
var srcu = src.u;
var destu = dest.u;
if (srcu !== destu || destPos < srcPos || srcPos + length < destPos) {
for (var i = 0; i < length; i++)
destu[destPos+i] = srcu[srcPos+i];
} else {
for (var i = length-1; i >= 0; i--)
destu[destPos+i] = srcu[srcPos+i];
}
};
ScalaJS.systemIdentityHashCode = function(obj) {
if (ScalaJS.isScalaJSObject(obj)) {
var hash = obj["$idHashCode$0"];
if (hash !== void 0) {
return hash;
} else {
hash = (ScalaJS.lastIDHash + 1) | 0;
ScalaJS.lastIDHash = hash;
obj["$idHashCode$0"] = hash;
return hash;
}
} else if (obj === null) {
return 0;
} else {
return ScalaJS.objectHashCode(obj);
}
};
// is/as for hijacked boxed classes (the non-trivial ones)
ScalaJS.isByte = function(v) {
return (v << 24 >> 24) === v;
};
ScalaJS.isShort = function(v) {
return (v << 16 >> 16) === v;
};
ScalaJS.isInt = function(v) {
return (v | 0) === v;
};
ScalaJS.isFloat = function(v) {
return v !== v || ScalaJS.fround(v) === v;
};
//!if asInstanceOfs != Unchecked
ScalaJS.asUnit = function(v) {
if (v === void 0)
return v;
else
ScalaJS.throwClassCastException(v, "scala.runtime.BoxedUnit");
};
ScalaJS.asBoolean = function(v) {
if (typeof v === "boolean" || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Boolean");
};
ScalaJS.asByte = function(v) {
if (ScalaJS.isByte(v) || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Byte");
};
ScalaJS.asShort = function(v) {
if (ScalaJS.isShort(v) || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Short");
};
ScalaJS.asInt = function(v) {
if (ScalaJS.isInt(v) || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Integer");
};
ScalaJS.asFloat = function(v) {
if (ScalaJS.isFloat(v) || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Float");
};
ScalaJS.asDouble = function(v) {
if (typeof v === "number" || v === null)
return v;
else
ScalaJS.throwClassCastException(v, "java.lang.Double");
};
//!endif
// Unboxes
//!if asInstanceOfs != Unchecked
ScalaJS.uZ = function(value) {
return !!ScalaJS.asBoolean(value);
};
ScalaJS.uB = function(value) {
return ScalaJS.asByte(value) | 0;
};
ScalaJS.uS = function(value) {
return ScalaJS.asShort(value) | 0;
};
ScalaJS.uI = function(value) {
return ScalaJS.asInt(value) | 0;
};
ScalaJS.uJ = function(value) {
return null === value ? ScalaJS.m.sjsr_RuntimeLong().Zero$1
: ScalaJS.as.sjsr_RuntimeLong(value);
};
ScalaJS.uF = function(value) {
/* Here, it is fine to use + instead of fround, because asFloat already
* ensures that the result is either null or a float.
*/
return +ScalaJS.asFloat(value);
};
ScalaJS.uD = function(value) {
return +ScalaJS.asDouble(value);
};
//!else
ScalaJS.uJ = function(value) {
return null === value ? ScalaJS.m.sjsr_RuntimeLong().Zero$1 : value;
};
//!endif
// TypeArray conversions
ScalaJS.byteArray2TypedArray = function(value) { return new Int8Array(value.u); };
ScalaJS.shortArray2TypedArray = function(value) { return new Int16Array(value.u); };
ScalaJS.charArray2TypedArray = function(value) { return new Uint16Array(value.u); };
ScalaJS.intArray2TypedArray = function(value) { return new Int32Array(value.u); };
ScalaJS.floatArray2TypedArray = function(value) { return new Float32Array(value.u); };
ScalaJS.doubleArray2TypedArray = function(value) { return new Float64Array(value.u); };
ScalaJS.typedArray2ByteArray = function(value) {
var arrayClassData = ScalaJS.d.B.getArrayOf();
return new arrayClassData.constr(new Int8Array(value));
};
ScalaJS.typedArray2ShortArray = function(value) {
var arrayClassData = ScalaJS.d.S.getArrayOf();
return new arrayClassData.constr(new Int16Array(value));
};
ScalaJS.typedArray2CharArray = function(value) {
var arrayClassData = ScalaJS.d.C.getArrayOf();
return new arrayClassData.constr(new Uint16Array(value));
};
ScalaJS.typedArray2IntArray = function(value) {
var arrayClassData = ScalaJS.d.I.getArrayOf();
return new arrayClassData.constr(new Int32Array(value));
};
ScalaJS.typedArray2FloatArray = function(value) {
var arrayClassData = ScalaJS.d.F.getArrayOf();
return new arrayClassData.constr(new Float32Array(value));
};
ScalaJS.typedArray2DoubleArray = function(value) {
var arrayClassData = ScalaJS.d.D.getArrayOf();
return new arrayClassData.constr(new Float64Array(value));
};
/* We have to force a non-elidable *read* of ScalaJS.e, otherwise Closure will
* eliminate it altogether, along with all the exports, which is ... er ...
* plain wrong.
*/
this["__ScalaJSExportsNamespace"] = ScalaJS.e;
// Type data constructors
/** @constructor */
ScalaJS.PrimitiveTypeData = function(zero, arrayEncodedName, displayName) {
// Runtime support
this.constr = undefined;
this.parentData = undefined;
this.ancestors = {};
this.componentData = null;
this.zero = zero;
this.arrayEncodedName = arrayEncodedName;
this._classOf = undefined;
this._arrayOf = undefined;
this.isArrayOf = function(obj, depth) { return false; };
// java.lang.Class support
this["name"] = displayName;
this["isPrimitive"] = true;
this["isInterface"] = false;
this["isArrayClass"] = false;
this["isInstance"] = function(obj) { return false; };
};
/** @constructor */
ScalaJS.ClassTypeData = function(internalNameObj, isInterface, fullName,
parentData, ancestors, isInstance, isArrayOf) {
var internalName = ScalaJS.propertyName(internalNameObj);
isInstance = isInstance || function(obj) {
return !!(obj && obj.$classData && obj.$classData.ancestors[internalName]);
};
isArrayOf = isArrayOf || function(obj, depth) {
return !!(obj && obj.$classData && (obj.$classData.arrayDepth === depth)
&& obj.$classData.arrayBase.ancestors[internalName])
};
// Runtime support
this.constr = undefined;
this.parentData = parentData;
this.ancestors = ancestors;
this.componentData = null;
this.zero = null;
this.arrayEncodedName = "L"+fullName+";";
this._classOf = undefined;
this._arrayOf = undefined;
this.isArrayOf = isArrayOf;
// java.lang.Class support
this["name"] = fullName;
this["isPrimitive"] = false;
this["isInterface"] = isInterface;
this["isArrayClass"] = false;
this["isInstance"] = isInstance;
};
/** @constructor */
ScalaJS.ArrayTypeData = function(componentData) {
// The constructor
var componentZero = componentData.zero;
// The zero for the Long runtime representation
// is a special case here, since the class has not
// been defined yet, when this file is read
if (componentZero == "longZero")
componentZero = ScalaJS.m.sjsr_RuntimeLong().Zero$1;
/** @constructor */
var ArrayClass = function(arg) {
if (typeof(arg) === "number") {
// arg is the length of the array
this.u = new Array(arg);
for (var i = 0; i < arg; i++)
this.u[i] = componentZero;
} else {
// arg is a native array that we wrap
this.u = arg;
}
}
ArrayClass.prototype = new ScalaJS.h.O;
ArrayClass.prototype.constructor = ArrayClass;
ArrayClass.prototype.$classData = this;
ArrayClass.prototype.clone__O = function() {
if (this.u instanceof Array)
return new ArrayClass(this.u["slice"](0));
else
// The underlying Array is a TypedArray
return new ArrayClass(this.u.constructor(this.u));
};
// Don't generate reflective call proxies. The compiler special cases
// reflective calls to methods on scala.Array
// The data
var encodedName = "[" + componentData.arrayEncodedName;
var componentBase = componentData.arrayBase || componentData;
var componentDepth = componentData.arrayDepth || 0;
var arrayDepth = componentDepth + 1;
var isInstance = function(obj) {
return componentBase.isArrayOf(obj, arrayDepth);
}
// Runtime support
this.constr = ArrayClass;
this.parentData = ScalaJS.d.O;
this.ancestors = {O: 1};
this.componentData = componentData;
this.arrayBase = componentBase;
this.arrayDepth = arrayDepth;
this.zero = null;
this.arrayEncodedName = encodedName;
this._classOf = undefined;
this._arrayOf = undefined;
this.isArrayOf = undefined;
// java.lang.Class support
this["name"] = encodedName;
this["isPrimitive"] = false;
this["isInterface"] = false;
this["isArrayClass"] = true;
this["isInstance"] = isInstance;
};
ScalaJS.ClassTypeData.prototype.getClassOf = function() {
if (!this._classOf)
this._classOf = new ScalaJS.c.jl_Class().init___jl_ScalaJSClassData(this);
return this._classOf;
};
ScalaJS.ClassTypeData.prototype.getArrayOf = function() {
if (!this._arrayOf)
this._arrayOf = new ScalaJS.ArrayTypeData(this);
return this._arrayOf;
};
// java.lang.Class support
ScalaJS.ClassTypeData.prototype["getFakeInstance"] = function() {
if (this === ScalaJS.d.T)
return "some string";
else if (this === ScalaJS.d.jl_Boolean)
return false;
else if (this === ScalaJS.d.jl_Byte ||
this === ScalaJS.d.jl_Short ||
this === ScalaJS.d.jl_Integer ||
this === ScalaJS.d.jl_Float ||
this === ScalaJS.d.jl_Double)
return 0;
else if (this === ScalaJS.d.jl_Long)
return ScalaJS.m.sjsr_RuntimeLong().Zero$1;
else if (this === ScalaJS.d.sr_BoxedUnit)
return void 0;
else
return {$classData: this};
};
ScalaJS.ClassTypeData.prototype["getSuperclass"] = function() {
return this.parentData ? this.parentData.getClassOf() : null;
};
ScalaJS.ClassTypeData.prototype["getComponentType"] = function() {
return this.componentData ? this.componentData.getClassOf() : null;
};
ScalaJS.ClassTypeData.prototype["newArrayOfThisClass"] = function(lengths) {
var arrayClassData = this;
for (var i = 0; i < lengths.length; i++)
arrayClassData = arrayClassData.getArrayOf();
return ScalaJS.newArrayObject(arrayClassData, lengths);
};
ScalaJS.PrimitiveTypeData.prototype = ScalaJS.ClassTypeData.prototype;
ScalaJS.ArrayTypeData.prototype = ScalaJS.ClassTypeData.prototype;
// Create primitive types
ScalaJS.d.V = new ScalaJS.PrimitiveTypeData(undefined, "V", "void");
ScalaJS.d.Z = new ScalaJS.PrimitiveTypeData(false, "Z", "boolean");
ScalaJS.d.C = new ScalaJS.PrimitiveTypeData(0, "C", "char");
ScalaJS.d.B = new ScalaJS.PrimitiveTypeData(0, "B", "byte");
ScalaJS.d.S = new ScalaJS.PrimitiveTypeData(0, "S", "short");
ScalaJS.d.I = new ScalaJS.PrimitiveTypeData(0, "I", "int");
ScalaJS.d.J = new ScalaJS.PrimitiveTypeData("longZero", "J", "long");
ScalaJS.d.F = new ScalaJS.PrimitiveTypeData(0.0, "F", "float");
ScalaJS.d.D = new ScalaJS.PrimitiveTypeData(0.0, "D", "double");
// Instance tests for array of primitives
ScalaJS.isArrayOf.Z = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.Z);
ScalaJS.d.Z.isArrayOf = ScalaJS.isArrayOf.Z;
ScalaJS.isArrayOf.C = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.C);
ScalaJS.d.C.isArrayOf = ScalaJS.isArrayOf.C;
ScalaJS.isArrayOf.B = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.B);
ScalaJS.d.B.isArrayOf = ScalaJS.isArrayOf.B;
ScalaJS.isArrayOf.S = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.S);
ScalaJS.d.S.isArrayOf = ScalaJS.isArrayOf.S;
ScalaJS.isArrayOf.I = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.I);
ScalaJS.d.I.isArrayOf = ScalaJS.isArrayOf.I;
ScalaJS.isArrayOf.J = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.J);
ScalaJS.d.J.isArrayOf = ScalaJS.isArrayOf.J;
ScalaJS.isArrayOf.F = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.F);
ScalaJS.d.F.isArrayOf = ScalaJS.isArrayOf.F;
ScalaJS.isArrayOf.D = ScalaJS.makeIsArrayOfPrimitive(ScalaJS.d.D);
ScalaJS.d.D.isArrayOf = ScalaJS.isArrayOf.D;
//!if asInstanceOfs != Unchecked
// asInstanceOfs for array of primitives
ScalaJS.asArrayOf.Z = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.Z, "Z");
ScalaJS.asArrayOf.C = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.C, "C");
ScalaJS.asArrayOf.B = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.B, "B");
ScalaJS.asArrayOf.S = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.S, "S");
ScalaJS.asArrayOf.I = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.I, "I");
ScalaJS.asArrayOf.J = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.J, "J");
ScalaJS.asArrayOf.F = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.F, "F");
ScalaJS.asArrayOf.D = ScalaJS.makeAsArrayOfPrimitive(ScalaJS.isArrayOf.D, "D");
//!endif
// Polyfills
ScalaJS.imul = ScalaJS.g["Math"]["imul"] || (function(a, b) {
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
var ah = (a >>> 16) & 0xffff;
var al = a & 0xffff;
var bh = (b >>> 16) & 0xffff;
var bl = b & 0xffff;
// the shift by 0 fixes the sign on the high part
// the final |0 converts the unsigned value into a signed value
return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0);
});
ScalaJS.fround = ScalaJS.g["Math"]["fround"] ||
//!if floats == Strict
(ScalaJS.g["Float32Array"] ? (function(v) {
var array = new ScalaJS.g["Float32Array"](1);
array[0] = v;
return array[0];
}) : (function(v) {
return ScalaJS.m.sjsr_package().froundPolyfill__D__D(+v);
}));
//!else
(function(v) {
return +v;
});
//!endif