First commit

hGameTest/node_modules/openfl/lib/_gen/js/Boot.js

@@ -0,0 +1,266 @@
+// Class: js.Boot
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function js__$Boot_HaxeError() {return require("./../js/_Boot/HaxeError");}
+function Std() {return require("./../Std");}
+
+// Constructor
+
+var Boot = function(){}
+
+// Meta
+
+Boot.__name__ = ["js","Boot"];
+Boot.prototype = {
+	
+};
+Boot.prototype.__class__ = $hxClasses["js.Boot"] = Boot;
+
+// Init
+
+
+
+// Statics
+
+Boot.__unhtml = function(s) {
+	return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
+}
+Boot.__trace = function(v,i) {
+	var msg = i != null ? i.fileName + ":" + i.lineNumber + ": " : "";
+	msg += Boot.__string_rec(v,"");
+	if(i != null && i.customParams != null) {
+		var _g = 0;
+		var _g1 = i.customParams;
+		while(_g < _g1.length) {
+			var v1 = _g1[_g];
+			++_g;
+			msg += "," + Boot.__string_rec(v1,"");
+		}
+	}
+	var d;
+	var tmp;
+	if(typeof(document) != "undefined") {
+		d = document.getElementById("haxe:trace");
+		tmp = d != null;
+	} else {
+		tmp = false;
+	}
+	if(tmp) {
+		d.innerHTML += Boot.__unhtml(msg) + "<br/>";
+	} else if(typeof console != "undefined" && console.log != null) {
+		console.log(msg);
+	}
+}
+Boot.isClass = function(o) {
+	return o.__name__;
+}
+Boot.isEnum = function(e) {
+	return e.__ename__;
+}
+Boot.getClass = function(o) {
+	if((o instanceof Array) && o.__enum__ == null) {
+		return Array
+	} else {
+		var cl = o.__class__;
+		if(cl != null) {
+			return cl;
+		}
+		var name = Boot.__nativeClassName(o);
+		if(name != null) {
+			return Boot.__resolveNativeClass(name);
+		}
+		return null;
+	}
+}
+Boot.__string_rec = function(o,s) {
+	if(o == null) {
+		return "null";
+	}
+	if(s.length >= 5) {
+		return "<...>";
+	}
+	var t = typeof(o);
+	if(t == "function" && (Boot.isClass(o) || Boot.isEnum(o))) {
+		t = "object";
+	}
+	switch(t) {
+	case "function":
+		return "<function>";
+	case "object":
+		if(o instanceof Array) {
+			if(o.__enum__) {
+				if(o.length == 2) {
+					return o[0];
+				}
+				var str = o[0] + "(";
+				s += "\t";
+				var _g1 = 2;
+				var _g = o.length;
+				while(_g1 < _g) {
+					var i = _g1++;
+					if(i != 2) {
+						str += "," + Boot.__string_rec(o[i],s);
+					} else {
+						str += Boot.__string_rec(o[i],s);
+					}
+				}
+				return str + ")";
+			}
+			var l = o.length;
+			var i1;
+			var str1 = "[";
+			s += "\t";
+			var _g11 = 0;
+			var _g2 = l;
+			while(_g11 < _g2) {
+				var i2 = _g11++;
+				str1 += (i2 > 0 ? "," : "") + Boot.__string_rec(o[i2],s);
+			}
+			str1 += "]";
+			return str1;
+		}
+		var tostr;
+		try {
+			tostr = o.toString;
+		} catch( e ) {
+			return "???";
+		}
+		if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
+			var s2 = o.toString();
+			if(s2 != "[object Object]") {
+				return s2;
+			}
+		}
+		var k = null;
+		var str2 = "{\n";
+		s += "\t";
+		var hasp = o.hasOwnProperty != null;
+		for( var k in o ) {
+		if(hasp && !o.hasOwnProperty(k)) {
+			continue;
+		}
+		if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
+			continue;
+		}
+		if(str2.length != 2) {
+			str2 += ", \n";
+		}
+		str2 += s + k + " : " + Boot.__string_rec(o[k],s);
+		}
+		s = s.substring(1);
+		str2 += "\n" + s + "}";
+		return str2;
+	case "string":
+		return o;
+	default:
+		return String(o);
+	}
+}
+Boot.__interfLoop = function(cc,cl) {
+	if(cc == null) {
+		return false;
+	}
+	if(cc == cl) {
+		return true;
+	}
+	var intf = cc.__interfaces__;
+	if(intf != null) {
+		var _g1 = 0;
+		var _g = intf.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			var i1 = intf[i];
+			if(i1 == cl || Boot.__interfLoop(i1,cl)) {
+				return true;
+			}
+		}
+	}
+	return Boot.__interfLoop(cc.__super__,cl);
+}
+Boot.__instanceof = function(o,cl) {
+	if(cl == null) {
+		return false;
+	}
+	switch(cl) {
+	case Array:
+		if((o instanceof Array)) {
+			return o.__enum__ == null;
+		} else {
+			return false;
+		}
+		break;
+	case $hxClasses["Bool"]:
+		return typeof(o) == "boolean";
+	case $hxClasses["Dynamic"]:
+		return true;
+	case $hxClasses["Float"]:
+		return typeof(o) == "number";
+	case $hxClasses["Int"]:
+		if(typeof(o) == "number") {
+			return (o|0) === o;
+		} else {
+			return false;
+		}
+		break;
+	case String:
+		return typeof(o) == "string";
+	default:
+		if(o != null) {
+			if(typeof(cl) == "function") {
+				if(o instanceof cl) {
+					return true;
+				}
+				if(Boot.__interfLoop(Boot.getClass(o),cl)) {
+					return true;
+				}
+			} else if(typeof(cl) == "object" && Boot.__isNativeObj(cl)) {
+				if(o instanceof cl) {
+					return true;
+				}
+			}
+		} else {
+			return false;
+		}
+		if(cl == $hxClasses["Class"] ? o.__name__ != null : false) {
+			return true;
+		}
+		if(cl == $hxClasses["Enum"] ? o.__ename__ != null : false) {
+			return true;
+		}
+		return o.__enum__ == cl;
+	}
+}
+Boot.__cast = function(o,t) {
+	if(Boot.__instanceof(o,t)) {
+		return o;
+	} else {
+		throw new (js__$Boot_HaxeError().default)("Cannot cast " + (Std().default).string(o) + " to " + (Std().default).string(t));
+	}
+}
+Boot.__nativeClassName = function(o) {
+	var name = Boot.__toStr.call(o).slice(8,-1);
+	if(name == "Object" || name == "Function" || name == "Math" || name == "JSON") {
+		return null;
+	}
+	return name;
+}
+Boot.__isNativeObj = function(o) {
+	return Boot.__nativeClassName(o) != null;
+}
+Boot.__resolveNativeClass = function(name) {
+	return $global[name];
+}
+Boot.__toStr = ({ }).toString
+
+// Export
+
+exports.default = Boot;

hGameTest/node_modules/openfl/lib/_gen/js/Browser.js

@@ -0,0 +1,86 @@
+// Class: js.Browser
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function js__$Boot_HaxeError() {return require("./../js/_Boot/HaxeError");}
+function js_Boot() {return require("./../js/Boot");}
+
+// Constructor
+
+var Browser = function(){}
+
+// Meta
+
+Browser.__name__ = ["js","Browser"];
+Browser.prototype = {
+	
+};
+Browser.prototype.__class__ = $hxClasses["js.Browser"] = Browser;
+
+// Init
+
+
+
+// Statics
+
+Browser.get_window = function() {
+	return window;
+}
+Browser.get_document = function() {
+	return window.document;
+}
+Browser.get_location = function() {
+	return window.location;
+}
+Browser.get_navigator = function() {
+	return window.navigator;
+}
+Browser.get_console = function() {
+	return window.console;
+}
+Browser.get_supported = function() {
+	return typeof window != "undefined";
+}
+Browser.getLocalStorage = function() {
+	try {
+		var s = Browser.get_window().localStorage;
+		s.getItem("");
+		return s;
+	} catch( e ) {
+		return null;
+	}
+}
+Browser.getSessionStorage = function() {
+	try {
+		var s = Browser.get_window().sessionStorage;
+		s.getItem("");
+		return s;
+	} catch( e ) {
+		return null;
+	}
+}
+Browser.createXMLHttpRequest = function() {
+	if(typeof XMLHttpRequest != "undefined") {
+		return new XMLHttpRequest();
+	}
+	if(typeof ActiveXObject != "undefined") {
+		return new ActiveXObject("Microsoft.XMLHTTP");
+	}
+	throw new (js__$Boot_HaxeError().default)("Unable to create XMLHttpRequest object.");
+}
+Browser.alert = function(v) {
+	Browser.get_window().alert((js_Boot().default).__string_rec(v,""));
+}
+
+
+// Export
+
+exports.default = Browser;

hGameTest/node_modules/openfl/lib/_gen/js/Lib.js

@@ -0,0 +1,41 @@
+// Class: js.Lib
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+
+// Constructor
+
+var Lib = function(){}
+
+// Meta
+
+Lib.__name__ = ["js","Lib"];
+Lib.prototype = {
+	
+};
+Lib.prototype.__class__ = $hxClasses["js.Lib"] = Lib;
+
+// Init
+
+
+
+// Statics
+
+Lib.eval = function(code) {
+	return eval(code);
+}
+Lib.get_undefined = function() {
+	return undefined;
+}
+
+
+// Export
+
+exports.default = Lib;

hGameTest/node_modules/openfl/lib/_gen/js/_Boot/HaxeError.js

@@ -0,0 +1,52 @@
+// Class: js._Boot.HaxeError
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+var $extend = require("./../../extend_stub").default;
+
+// Constructor
+
+var HaxeError = function(val) {
+	Error.call(this);
+	this.val = val;
+	this.message = String(val);
+	if(Error.captureStackTrace) {
+		Error.captureStackTrace(this,HaxeError);
+	}
+}
+
+// Meta
+
+HaxeError.__name__ = ["js","_Boot","HaxeError"];
+HaxeError.__super__ = Error;
+HaxeError.prototype = $extend(Error.prototype, {
+	
+});
+HaxeError.prototype.__class__ = $hxClasses["js._Boot.HaxeError"] = HaxeError;
+
+// Init
+
+
+
+// Statics
+
+HaxeError.wrap = function(val) {
+	if((val instanceof Error)) {
+		return val;
+	} else {
+		return new HaxeError(val);
+	}
+}
+
+
+// Export
+
+exports.default = HaxeError;

hGameTest/node_modules/openfl/lib/_gen/js/html/_CanvasElement/CanvasUtil.js

@@ -0,0 +1,48 @@
+// Class: js.html._CanvasElement.CanvasUtil
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var CanvasUtil = function(){}
+
+// Meta
+
+CanvasUtil.__name__ = ["js","html","_CanvasElement","CanvasUtil"];
+CanvasUtil.prototype = {
+	
+};
+CanvasUtil.prototype.__class__ = $hxClasses["js.html._CanvasElement.CanvasUtil"] = CanvasUtil;
+
+// Init
+
+
+
+// Statics
+
+CanvasUtil.getContextWebGL = function(canvas,attribs) {
+	var _g = 0;
+	var _g1 = ["webgl","experimental-webgl"];
+	while(_g < _g1.length) {
+		var name = _g1[_g];
+		++_g;
+		var ctx = canvas.getContext(name,attribs);
+		if(ctx != null) {
+			return ctx;
+		}
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = CanvasUtil;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/ArrayBuffer.js

@@ -0,0 +1,65 @@
+// Class: js.html.compat.ArrayBuffer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+
+// Constructor
+
+var ArrayBuffer = function(a) {
+	if((a instanceof Array) && a.__enum__ == null) {
+		this.a = a;
+		this.byteLength = a.length;
+	} else {
+		var len = a;
+		this.a = [];
+		var _g1 = 0;
+		var _g = len;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this.a[i] = 0;
+		}
+		this.byteLength = len;
+	}
+}
+
+// Meta
+
+ArrayBuffer.__name__ = ["js","html","compat","ArrayBuffer"];
+ArrayBuffer.prototype = {
+	slice: function(begin,end) {
+		return new ArrayBuffer(this.a.slice(begin,end));
+	}
+};
+ArrayBuffer.prototype.__class__ = $hxClasses["js.html.compat.ArrayBuffer"] = ArrayBuffer;
+
+// Init
+
+{
+	var ArrayBuffer = $global.ArrayBuffer || ArrayBuffer
+	if(ArrayBuffer.prototype.slice == null) {
+		ArrayBuffer.prototype.slice = ArrayBuffer.sliceImpl;
+	}
+};
+
+// Statics
+
+ArrayBuffer.sliceImpl = function(begin,end) {
+	var u = new Uint8Array(this,begin,end == null ? null : end - begin);
+	var result = new ArrayBuffer(u.byteLength);
+	var resultArray = new Uint8Array(result);
+	resultArray.set(u);
+	return result;
+}
+
+
+// Export
+
+exports.default = ArrayBuffer;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/DataView.js

@@ -0,0 +1,152 @@
+// Class: js.html.compat.DataView
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+function haxe_io_Error() {return require("./../../../haxe/io/Error");}
+
+// Constructor
+
+var DataView = function(buffer,byteOffset,byteLength) {
+	this.buf = buffer;
+	this.offset = byteOffset == null ? 0 : byteOffset;
+	this.length = byteLength == null ? buffer.byteLength - this.offset : byteLength;
+	if(this.offset < 0 || this.length < 0 || this.offset + this.length > buffer.byteLength) {
+		throw new (js__$Boot_HaxeError().default)((haxe_io_Error().default).OutsideBounds);
+	}
+	this.byteLength = this.length;
+	this.byteOffset = this.offset;
+	this.buffer = this.buf;
+}
+
+// Meta
+
+DataView.__name__ = ["js","html","compat","DataView"];
+DataView.prototype = {
+	getInt8: function(byteOffset) {
+		var v = this.buf.a[this.offset + byteOffset];
+		if(v >= 128) {
+			return v - 256;
+		} else {
+			return v;
+		}
+	},
+	getUint8: function(byteOffset) {
+		return this.buf.a[this.offset + byteOffset];
+	},
+	getInt16: function(byteOffset,littleEndian) {
+		var v = this.getUint16(byteOffset,littleEndian);
+		if(v >= 32768) {
+			return v - 65536;
+		} else {
+			return v;
+		}
+	},
+	getUint16: function(byteOffset,littleEndian) {
+		if(littleEndian) {
+			return this.buf.a[this.offset + byteOffset] | this.buf.a[this.offset + byteOffset + 1] << 8;
+		} else {
+			return this.buf.a[this.offset + byteOffset] << 8 | this.buf.a[this.offset + byteOffset + 1];
+		}
+	},
+	getInt32: function(byteOffset,littleEndian) {
+		var p = this.offset + byteOffset;
+		var a = this.buf.a[p++];
+		var b = this.buf.a[p++];
+		var c = this.buf.a[p++];
+		var d = this.buf.a[p++];
+		if(littleEndian) {
+			return a | b << 8 | c << 16 | d << 24;
+		} else {
+			return d | c << 8 | b << 16 | a << 24;
+		}
+	},
+	getUint32: function(byteOffset,littleEndian) {
+		var v = this.getInt32(byteOffset,littleEndian);
+		if(v < 0) {
+			return v + 4294967296.;
+		} else {
+			return v;
+		}
+	},
+	getFloat32: function(byteOffset,littleEndian) {
+		return (haxe_io_FPHelper().default).i32ToFloat(this.getInt32(byteOffset,littleEndian));
+	},
+	getFloat64: function(byteOffset,littleEndian) {
+		var a = this.getInt32(byteOffset,littleEndian);
+		var b = this.getInt32(byteOffset + 4,littleEndian);
+		return (haxe_io_FPHelper().default).i64ToDouble(littleEndian ? a : b,littleEndian ? b : a);
+	},
+	setInt8: function(byteOffset,value) {
+		this.buf.a[byteOffset + this.offset] = value < 0 ? value + 128 & 255 : value & 255;
+	},
+	setUint8: function(byteOffset,value) {
+		this.buf.a[byteOffset + this.offset] = value & 255;
+	},
+	setInt16: function(byteOffset,value,littleEndian) {
+		this.setUint16(byteOffset,value < 0 ? value + 65536 : value,littleEndian);
+	},
+	setUint16: function(byteOffset,value,littleEndian) {
+		var p = byteOffset + this.offset;
+		if(littleEndian) {
+			this.buf.a[p] = value & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+		} else {
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p] = value & 255;
+		}
+	},
+	setInt32: function(byteOffset,value,littleEndian) {
+		this.setUint32(byteOffset,value,littleEndian);
+	},
+	setUint32: function(byteOffset,value,littleEndian) {
+		var p = byteOffset + this.offset;
+		if(littleEndian) {
+			this.buf.a[p++] = value & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p++] = value >> 16 & 255;
+			this.buf.a[p++] = value >>> 24;
+		} else {
+			this.buf.a[p++] = value >>> 24;
+			this.buf.a[p++] = value >> 16 & 255;
+			this.buf.a[p++] = value >> 8 & 255;
+			this.buf.a[p++] = value & 255;
+		}
+	},
+	setFloat32: function(byteOffset,value,littleEndian) {
+		this.setUint32(byteOffset,(haxe_io_FPHelper().default).floatToI32(value),littleEndian);
+	},
+	setFloat64: function(byteOffset,value,littleEndian) {
+		var i64 = (haxe_io_FPHelper().default).doubleToI64(value);
+		if(littleEndian) {
+			this.setUint32(byteOffset,i64.low);
+			this.setUint32(byteOffset,i64.high);
+		} else {
+			this.setUint32(byteOffset,i64.high);
+			this.setUint32(byteOffset,i64.low);
+		}
+	}
+};
+DataView.prototype.__class__ = $hxClasses["js.html.compat.DataView"] = DataView;
+
+// Init
+
+var DataView = $global.DataView || DataView;
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = DataView;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Float32Array.js

@@ -0,0 +1,134 @@
+// Class: js.html.compat.Float32Array
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function js_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Float32Array = function(){}
+
+// Meta
+
+Float32Array.__name__ = ["js","html","compat","Float32Array"];
+Float32Array.prototype = {
+	
+};
+Float32Array.prototype.__class__ = $hxClasses["js.html.compat.Float32Array"] = Float32Array;
+
+// Init
+
+var Float32Array = $global.Float32Array || Float32Array._new;
+
+// Statics
+
+Float32Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = 0;
+		var _g2 = [];
+		var _g21 = 0;
+		var _g11 = arr.length << 2;
+		while(_g21 < _g11) {
+			var i1 = _g21++;
+			_g2.push(0);
+		}
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(_g2);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset >> 2;
+		}
+		arr = [];
+		var _g12 = 0;
+		var _g3 = length;
+		while(_g12 < _g3) {
+			var i2 = _g12++;
+			var val = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			arr.push((haxe_io_FPHelper().default).i32ToFloat(val));
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		var buffer1 = [];
+		var _g4 = 0;
+		while(_g4 < arr.length) {
+			var f = arr[_g4];
+			++_g4;
+			var i3 = (haxe_io_FPHelper().default).floatToI32(f);
+			buffer1.push(i3 & 255);
+			buffer1.push(i3 >> 8 & 255);
+			buffer1.push(i3 >> 16 & 255);
+			buffer1.push(i3 >>> 24);
+		}
+		arr.byteLength = arr.length << 2;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(buffer1);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Float32Array._subarray;
+	arr.set = Float32Array._set;
+	return arr;
+}
+Float32Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Float32Array._subarray = function(start,end) {
+	var a = Float32Array._new(this.slice(start,end));
+	a.byteOffset = start * 4;
+	return a;
+}
+Float32Array.BYTES_PER_ELEMENT = 4
+
+// Export
+
+exports.default = Float32Array;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Float64Array.js

@@ -0,0 +1,141 @@
+// Class: js.html.compat.Float64Array
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function js_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function haxe_io_FPHelper() {return require("./../../../haxe/io/FPHelper");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Float64Array = function(){}
+
+// Meta
+
+Float64Array.__name__ = ["js","html","compat","Float64Array"];
+Float64Array.prototype = {
+	
+};
+Float64Array.prototype.__class__ = $hxClasses["js.html.compat.Float64Array"] = Float64Array;
+
+// Init
+
+var Float64Array = $global.Float64Array || ($global.Float32Array ? "notsupported" : null) || Float64Array._new;
+
+// Statics
+
+Float64Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = 0;
+		var _g2 = [];
+		var _g21 = 0;
+		var _g11 = arr.length << 3;
+		while(_g21 < _g11) {
+			var i1 = _g21++;
+			_g2.push(0);
+		}
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(_g2);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset >> 3;
+		}
+		arr = [];
+		var _g12 = 0;
+		var _g3 = length;
+		while(_g12 < _g3) {
+			var i2 = _g12++;
+			var val1 = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			var val2 = buffer.a[offset++] | buffer.a[offset++] << 8 | buffer.a[offset++] << 16 | buffer.a[offset++] << 24;
+			arr.push((haxe_io_FPHelper().default).i64ToDouble(val1,val2));
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		var buffer1 = [];
+		var _g4 = 0;
+		while(_g4 < arr.length) {
+			var f = arr[_g4];
+			++_g4;
+			var v = (haxe_io_FPHelper().default).doubleToI64(f);
+			var i3 = v.low;
+			buffer1.push(i3 & 255);
+			buffer1.push(i3 >> 8 & 255);
+			buffer1.push(i3 >> 16 & 255);
+			buffer1.push(i3 >>> 24);
+			var i4 = v.high;
+			buffer1.push(i4 & 255);
+			buffer1.push(i4 >> 8 & 255);
+			buffer1.push(i4 >> 16 & 255);
+			buffer1.push(i4 >>> 24);
+		}
+		arr.byteLength = arr.length << 3;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(buffer1);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Float64Array._subarray;
+	arr.set = Float64Array._set;
+	return arr;
+}
+Float64Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Float64Array._subarray = function(start,end) {
+	var a = Float64Array._new(this.slice(start,end));
+	a.byteOffset = start * 8;
+	return a;
+}
+Float64Array.BYTES_PER_ELEMENT = 8
+
+// Export
+
+exports.default = Float64Array;

hGameTest/node_modules/openfl/lib/_gen/js/html/compat/Uint8Array.js

@@ -0,0 +1,112 @@
+// Class: js.html.compat.Uint8Array
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function js_html_compat_ArrayBuffer() {return require("./../../../js/html/compat/ArrayBuffer");}
+function Std() {return require("./../../../Std");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Uint8Array = function(){}
+
+// Meta
+
+Uint8Array.__name__ = ["js","html","compat","Uint8Array"];
+Uint8Array.prototype = {
+	
+};
+Uint8Array.prototype.__class__ = $hxClasses["js.html.compat.Uint8Array"] = Uint8Array;
+
+// Init
+
+var Uint8Array = $global.Uint8Array || Uint8Array._new;
+
+// Statics
+
+Uint8Array._new = function(arg1,offset,length) {
+	var arr;
+	if(typeof(arg1) == "number") {
+		arr = [];
+		var _g1 = 0;
+		var _g = arg1;
+		while(_g1 < _g) {
+			var i = _g1++;
+			arr[i] = 0;
+		}
+		arr.byteLength = arr.length;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(arr);
+	} else if((Std().default)["is"](arg1,(js_html_compat_ArrayBuffer().default))) {
+		var buffer = arg1;
+		if(offset == null) {
+			offset = 0;
+		}
+		if(length == null) {
+			length = buffer.byteLength - offset;
+		}
+		if(offset == 0) {
+			arr = buffer.a;
+		} else {
+			arr = buffer.a.slice(offset,offset + length);
+		}
+		arr.byteLength = arr.length;
+		arr.byteOffset = offset;
+		arr.buffer = buffer;
+	} else if((arg1 instanceof Array) && arg1.__enum__ == null) {
+		arr = arg1.slice();
+		arr.byteLength = arr.length;
+		arr.byteOffset = 0;
+		arr.buffer = new (js_html_compat_ArrayBuffer().default)(arr);
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO " + (Std().default).string(arg1));
+	}
+	arr.subarray = Uint8Array._subarray;
+	arr.set = Uint8Array._set;
+	return arr;
+}
+Uint8Array._set = function(arg,offset) {
+	if((Std().default)["is"](arg.buffer,(js_html_compat_ArrayBuffer().default))) {
+		var a = arg;
+		if(arg.byteLength + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g1 = 0;
+		var _g = arg.byteLength;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this[i + offset] = a[i];
+		}
+	} else if((arg instanceof Array) && arg.__enum__ == null) {
+		var a1 = arg;
+		if(a1.length + offset > this.byteLength) {
+			throw new (js__$Boot_HaxeError().default)("set() outside of range");
+		}
+		var _g11 = 0;
+		var _g2 = a1.length;
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			this[i1 + offset] = a1[i1];
+		}
+	} else {
+		throw new (js__$Boot_HaxeError().default)("TODO");
+	}
+}
+Uint8Array._subarray = function(start,end) {
+	var a = Uint8Array._new(this.slice(start,end));
+	a.byteOffset = start;
+	return a;
+}
+Uint8Array.BYTES_PER_ELEMENT = 1
+
+// Export
+
+exports.default = Uint8Array;