First commit

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/GameDeviceData.js

@@ -0,0 +1,40 @@
+// Class: lime._backend.html5.GameDeviceData
+
+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 GameDeviceData = function() {
+	this.connected = true;
+	this.buttons = [];
+	this.axes = [];
+}
+
+// Meta
+
+GameDeviceData.__name__ = ["lime","_backend","html5","GameDeviceData"];
+GameDeviceData.prototype = {
+	
+};
+GameDeviceData.prototype.__class__ = $hxClasses["lime._backend.html5.GameDeviceData"] = GameDeviceData;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = GameDeviceData;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5Application.js

@@ -0,0 +1,478 @@
+// Class: lime._backend.html5.HTML5Application
+
+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 $bind = require("./../../../bind_stub").default;
+function js_Browser() {return require("./../../../js/Browser");}
+function Std() {return require("./../../../Std");}
+function lime_ui_Joystick() {return require("./../../../lime/ui/Joystick");}
+function lime__$backend_html5_GameDeviceData() {return require("./../../../lime/_backend/html5/GameDeviceData");}
+function lime_ui_Gamepad() {return require("./../../../lime/ui/Gamepad");}
+function haxe_ds_IntMap() {return require("./../../../haxe/ds/IntMap");}
+function lime_media_AudioManager() {return require("./../../../lime/media/AudioManager");}
+
+// Constructor
+
+var HTML5Application = function(parent) {
+	this.gameDeviceCache = new (haxe_ds_IntMap().default)();
+	this.parent = parent;
+	this.currentUpdate = 0;
+	this.lastUpdate = 0;
+	this.nextUpdate = 0;
+	this.framePeriod = -1;
+	(lime_media_AudioManager().default).init();
+}
+
+// Meta
+
+HTML5Application.__name__ = ["lime","_backend","html5","HTML5Application"];
+HTML5Application.prototype = {
+	convertKeyCode: function(keyCode) {
+		if(keyCode >= 65 && keyCode <= 90) {
+			return keyCode + 32;
+		}
+		switch(keyCode) {
+		case 16:
+			return 1073742049;
+		case 17:
+			return 1073742048;
+		case 18:
+			return 1073742050;
+		case 20:
+			return 1073741881;
+		case 33:
+			return 1073741899;
+		case 34:
+			return 1073741902;
+		case 35:
+			return 1073741901;
+		case 36:
+			return 1073741898;
+		case 37:
+			return 1073741904;
+		case 38:
+			return 1073741906;
+		case 39:
+			return 1073741903;
+		case 40:
+			return 1073741905;
+		case 45:
+			return 1073741897;
+		case 46:
+			return 127;
+		case 96:
+			return 1073741922;
+		case 97:
+			return 1073741913;
+		case 98:
+			return 1073741914;
+		case 99:
+			return 1073741915;
+		case 100:
+			return 1073741916;
+		case 101:
+			return 1073741917;
+		case 102:
+			return 1073741918;
+		case 103:
+			return 1073741919;
+		case 104:
+			return 1073741920;
+		case 105:
+			return 1073741921;
+		case 106:
+			return 1073741909;
+		case 107:
+			return 1073741911;
+		case 109:
+			return 1073741910;
+		case 110:
+			return 1073741923;
+		case 111:
+			return 1073741908;
+		case 112:
+			return 1073741882;
+		case 113:
+			return 1073741883;
+		case 114:
+			return 1073741884;
+		case 115:
+			return 1073741885;
+		case 116:
+			return 1073741886;
+		case 117:
+			return 1073741887;
+		case 118:
+			return 1073741888;
+		case 119:
+			return 1073741889;
+		case 120:
+			return 1073741890;
+		case 121:
+			return 1073741891;
+		case 122:
+			return 1073741892;
+		case 123:
+			return 1073741893;
+		case 124:
+			return 1073741928;
+		case 125:
+			return 1073741929;
+		case 126:
+			return 1073741930;
+		case 144:
+			return 1073741907;
+		case 186:
+			return 59;
+		case 187:
+			return 61;
+		case 188:
+			return 44;
+		case 189:
+			return 45;
+		case 190:
+			return 46;
+		case 191:
+			return 47;
+		case 192:
+			return 96;
+		case 219:
+			return 91;
+		case 220:
+			return 92;
+		case 221:
+			return 93;
+		case 222:
+			return 39;
+		}
+		return keyCode;
+	},
+	create: function(config) {
+	},
+	exec: function() {
+		(js_Browser().default).get_window().addEventListener("keydown",$bind(this,this.handleKeyEvent),false);
+		(js_Browser().default).get_window().addEventListener("keyup",$bind(this,this.handleKeyEvent),false);
+		(js_Browser().default).get_window().addEventListener("focus",$bind(this,this.handleWindowEvent),false);
+		(js_Browser().default).get_window().addEventListener("blur",$bind(this,this.handleWindowEvent),false);
+		(js_Browser().default).get_window().addEventListener("resize",$bind(this,this.handleWindowEvent),false);
+		(js_Browser().default).get_window().addEventListener("beforeunload",$bind(this,this.handleWindowEvent),false);
+		
+				if (!CanvasRenderingContext2D.prototype.isPointInStroke) {
+					CanvasRenderingContext2D.prototype.isPointInStroke = function (path, x, y) {
+						return false;
+					};
+				}
+				if (!CanvasRenderingContext2D.prototype.isPointInPath) {
+					CanvasRenderingContext2D.prototype.isPointInPath = function (path, x, y) {
+						return false;
+					};
+				}
+				
+				if ('performance' in window == false) {
+					window.performance = {};
+				}
+				
+				if ('now' in window.performance == false) {
+					var offset = Date.now();
+					if (performance.timing && performance.timing.navigationStart) {
+						offset = performance.timing.navigationStart
+					}
+					window.performance.now = function now() {
+						return Date.now() - offset;
+					}
+				}
+				
+				var lastTime = 0;
+				var vendors = ['ms', 'moz', 'webkit', 'o'];
+				for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
+					window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
+					window.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame'] || window[vendors[x]+'CancelRequestAnimationFrame'];
+				}
+				
+				if (!window.requestAnimationFrame)
+					window.requestAnimationFrame = function(callback, element) {
+						var currTime = new Date().getTime();
+						var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+						var id = window.setTimeout(function() { callback(currTime + timeToCall); }, 
+						  timeToCall);
+						lastTime = currTime + timeToCall;
+						return id;
+					};
+				
+				if (!window.cancelAnimationFrame)
+					window.cancelAnimationFrame = function(id) {
+						clearTimeout(id);
+					};
+				
+				window.requestAnimFrame = window.requestAnimationFrame;
+			;
+		this.lastUpdate = new Date().getTime();
+		this.handleApplicationEvent();
+		return 0;
+	},
+	exit: function() {
+	},
+	getFrameRate: function() {
+		if(this.framePeriod < 0) {
+			return 60;
+		} else if(this.framePeriod == 1000) {
+			return 0;
+		} else {
+			return 1000 / this.framePeriod;
+		}
+	},
+	handleApplicationEvent: function(__) {
+		if(this.parent.get_window() != null) {
+			this.parent.get_window().backend.updateSize();
+		}
+		this.updateGameDevices();
+		this.currentUpdate = new Date().getTime();
+		if(this.currentUpdate >= this.nextUpdate) {
+			this.deltaTime = this.currentUpdate - this.lastUpdate;
+			this.parent.onUpdate.dispatch((Std().default)["int"](this.deltaTime));
+			if(this.parent.get_renderer() != null && this.parent.get_renderer().context != null) {
+				this.parent.get_renderer().render();
+				this.parent.get_renderer().onRender.dispatch();
+				if(!this.parent.get_renderer().onRender.canceled) {
+					this.parent.get_renderer().flip();
+				}
+			}
+			if(this.framePeriod < 0) {
+				this.nextUpdate = this.currentUpdate;
+				this.nextUpdate = this.currentUpdate;
+			} else {
+				this.nextUpdate = this.currentUpdate + this.framePeriod;
+			}
+			this.lastUpdate = this.currentUpdate;
+		}
+		(js_Browser().default).get_window().requestAnimationFrame($bind(this,this.handleApplicationEvent));
+	},
+	handleKeyEvent: function(event) {
+		if(this.parent.get_window() != null) {
+			var keyCode = this.convertKeyCode(event.keyCode != null ? event.keyCode : event.which);
+			var modifier = (event.shiftKey ? 3 : 0) | (event.ctrlKey ? 192 : 0) | (event.altKey ? 768 : 0) | (event.metaKey ? 3072 : 0);
+			if(event.type == "keydown") {
+				this.parent.get_window().onKeyDown.dispatch(keyCode,modifier);
+				if(this.parent.get_window().onKeyDown.canceled) {
+					event.preventDefault();
+				}
+			} else {
+				this.parent.get_window().onKeyUp.dispatch(keyCode,modifier);
+				if(this.parent.get_window().onKeyUp.canceled) {
+					event.preventDefault();
+				}
+			}
+		}
+	},
+	handleWindowEvent: function(event) {
+		if(this.parent.get_window() != null) {
+			var _g = event.type;
+			switch(_g) {
+			case "beforeunload":
+				if(!event.defaultPrevented) {
+					this.parent.get_window().onClose.dispatch();
+					if(this.parent.get_window() != null && this.parent.get_window().onClose.canceled) {
+						event.preventDefault();
+					}
+				}
+				break;
+			case "blur":
+				this.parent.get_window().onFocusOut.dispatch();
+				this.parent.get_window().onDeactivate.dispatch();
+				break;
+			case "focus":
+				this.parent.get_window().onFocusIn.dispatch();
+				this.parent.get_window().onActivate.dispatch();
+				break;
+			case "resize":
+				this.parent.get_window().backend.handleResizeEvent(event);
+				break;
+			}
+		}
+	},
+	setFrameRate: function(value) {
+		if(value >= 60) {
+			this.framePeriod = -1;
+		} else if(value > 0) {
+			this.framePeriod = 1000 / value;
+		} else {
+			this.framePeriod = 1000;
+		}
+		return value;
+	},
+	updateGameDevices: function() {
+		var devices = (lime_ui_Joystick().default).__getDeviceData();
+		if(devices == null) {
+			return;
+		}
+		var id;
+		var gamepad;
+		var joystick;
+		var data;
+		var cache;
+		var _g1 = 0;
+		var _g = devices.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			id = i;
+			data = devices[id];
+			if(data == null) {
+				continue;
+			}
+			if(!this.gameDeviceCache.exists(id)) {
+				cache = new (lime__$backend_html5_GameDeviceData().default)();
+				cache.id = id;
+				cache.connected = data.connected;
+				var _g3 = 0;
+				var _g2 = data.buttons.length;
+				while(_g3 < _g2) {
+					var i1 = _g3++;
+					cache.buttons.push(data.buttons[i1].value);
+				}
+				var _g31 = 0;
+				var _g21 = data.axes.length;
+				while(_g31 < _g21) {
+					var i2 = _g31++;
+					cache.axes.push(data.axes[i2]);
+				}
+				if(data.mapping == "standard") {
+					cache.isGamepad = true;
+				}
+				this.gameDeviceCache.set(id,cache);
+				if(data.connected) {
+					(lime_ui_Joystick().default).__connect(id);
+					if(cache.isGamepad) {
+						(lime_ui_Gamepad().default).__connect(id);
+					}
+				}
+			}
+			cache = this.gameDeviceCache.get(id);
+			joystick = (lime_ui_Joystick().default).devices.get(id);
+			gamepad = (lime_ui_Gamepad().default).devices.get(id);
+			if(data.connected) {
+				var button;
+				var value;
+				var _g32 = 0;
+				var _g22 = data.buttons.length;
+				while(_g32 < _g22) {
+					var i3 = _g32++;
+					value = data.buttons[i3].value;
+					if(value != cache.buttons[i3]) {
+						if(i3 == 6) {
+							joystick.onAxisMove.dispatch(data.axes.length,value);
+							if(gamepad != null) {
+								gamepad.onAxisMove.dispatch(4,value);
+							}
+						} else if(i3 == 7) {
+							joystick.onAxisMove.dispatch(data.axes.length + 1,value);
+							if(gamepad != null) {
+								gamepad.onAxisMove.dispatch(5,value);
+							}
+						} else {
+							if(value > 0) {
+								joystick.onButtonDown.dispatch(i3);
+							} else {
+								joystick.onButtonUp.dispatch(i3);
+							}
+							if(gamepad != null) {
+								switch(i3) {
+								case 0:
+									button = 0;
+									break;
+								case 1:
+									button = 1;
+									break;
+								case 2:
+									button = 2;
+									break;
+								case 3:
+									button = 3;
+									break;
+								case 4:
+									button = 9;
+									break;
+								case 5:
+									button = 10;
+									break;
+								case 8:
+									button = 4;
+									break;
+								case 9:
+									button = 6;
+									break;
+								case 10:
+									button = 7;
+									break;
+								case 11:
+									button = 8;
+									break;
+								case 12:
+									button = 11;
+									break;
+								case 13:
+									button = 12;
+									break;
+								case 14:
+									button = 13;
+									break;
+								case 15:
+									button = 14;
+									break;
+								case 16:
+									button = 5;
+									break;
+								default:
+									continue;
+								}
+								if(value > 0) {
+									gamepad.onButtonDown.dispatch(button);
+								} else {
+									gamepad.onButtonUp.dispatch(button);
+								}
+							}
+						}
+						cache.buttons[i3] = value;
+					}
+				}
+				var _g33 = 0;
+				var _g23 = data.axes.length;
+				while(_g33 < _g23) {
+					var i4 = _g33++;
+					if(data.axes[i4] != cache.axes[i4]) {
+						joystick.onAxisMove.dispatch(i4,data.axes[i4]);
+						if(gamepad != null) {
+							gamepad.onAxisMove.dispatch(i4,data.axes[i4]);
+						}
+						cache.axes[i4] = data.axes[i4];
+					}
+				}
+			} else if(cache.connected) {
+				cache.connected = false;
+				(lime_ui_Joystick().default).__disconnect(id);
+				(lime_ui_Gamepad().default).__disconnect(id);
+			}
+		}
+	}
+};
+HTML5Application.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5Application"] = HTML5Application;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = HTML5Application;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5AudioSource.js

@@ -0,0 +1,150 @@
+// Class: lime._backend.html5.HTML5AudioSource
+
+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 $bind = require("./../../../bind_stub").default;
+var $import = require("./../../../import_stub").default;
+function Std() {return require("./../../../Std");}
+function lime_math_Vector4() {return require("./../../../lime/math/Vector4");}
+
+// Constructor
+
+var HTML5AudioSource = function(parent) {
+	this.parent = parent;
+	this.id = -1;
+	this.gain = 1;
+	this.position = new (lime_math_Vector4().default)();
+}
+
+// Meta
+
+HTML5AudioSource.__name__ = ["lime","_backend","html5","HTML5AudioSource"];
+HTML5AudioSource.prototype = {
+	dispose: function() {
+	},
+	init: function() {
+	},
+	play: function() {
+		if(this.playing || this.parent.buffer == null) {
+			return;
+		}
+		this.playing = true;
+		var time = this.getCurrentTime();
+		this.completed = false;
+		var cacheVolume = this.parent.buffer.__srcHowl._volume;
+		this.parent.buffer.__srcHowl._volume = this.parent.get_gain();
+		this.id = this.parent.buffer.__srcHowl.play();
+		this.parent.buffer.__srcHowl._volume = cacheVolume;
+		this.setPosition(this.parent.get_position());
+		this.parent.buffer.__srcHowl.on("end",$bind(this,this.howl_onEnd),this.id);
+		this.setCurrentTime(time);
+	},
+	pause: function() {
+		this.playing = false;
+		if(this.parent.buffer != null) {
+			this.parent.buffer.__srcHowl.pause(this.id);
+		}
+	},
+	stop: function() {
+		this.playing = false;
+		if(this.parent.buffer != null) {
+			this.parent.buffer.__srcHowl.stop(this.id);
+		}
+	},
+	howl_onEnd: function() {
+		this.playing = false;
+		if(this.loops > 0) {
+			this.loops--;
+			this.stop();
+			this.play();
+			return;
+		} else {
+			this.parent.buffer.__srcHowl.stop(this.id);
+		}
+		this.completed = true;
+		this.parent.onComplete.dispatch();
+	},
+	getCurrentTime: function() {
+		if(this.id == -1) {
+			return 0;
+		}
+		if(this.completed) {
+			return this.getLength();
+		} else if(this.parent.buffer != null) {
+			var time = (Std().default)["int"](this.parent.buffer.__srcHowl.seek(this.id) * 1000) - this.parent.offset;
+			if(time < 0) {
+				return 0;
+			}
+			return time;
+		}
+		return 0;
+	},
+	setCurrentTime: function(value) {
+		if(this.parent.buffer != null) {
+			var pos = (value + this.parent.offset) / 1000;
+			if(pos < 0) {
+				pos = 0;
+			}
+			this.parent.buffer.__srcHowl.seek(pos,this.id);
+		}
+		return value;
+	},
+	getGain: function() {
+		return this.gain;
+	},
+	setGain: function(value) {
+		if(this.parent.buffer != null && this.id != -1) {
+			this.parent.buffer.__srcHowl.volume(value,this.id);
+		}
+		return this.gain = value;
+	},
+	getLength: function() {
+		if(this.length != 0) {
+			return this.length;
+		}
+		if(this.parent.buffer != null) {
+			return (Std().default)["int"](this.parent.buffer.__srcHowl.duration() * 1000);
+		}
+		return 0;
+	},
+	setLength: function(value) {
+		return this.length = value;
+	},
+	getLoops: function() {
+		return this.loops;
+	},
+	setLoops: function(value) {
+		return this.loops = value;
+	},
+	getPosition: function() {
+		return this.position;
+	},
+	setPosition: function(value) {
+		this.position.x = value.x;
+		this.position.y = value.y;
+		this.position.z = value.z;
+		this.position.w = value.w;
+		return this.position;
+	}
+};
+HTML5AudioSource.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5AudioSource"] = HTML5AudioSource;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = HTML5AudioSource;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5HTTPRequest.js

@@ -0,0 +1,356 @@
+// Class: lime._backend.html5.HTML5HTTPRequest
+
+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 StringTools() {return require("./../../../StringTools");}
+function Std() {return require("./../../../Std");}
+function lime_app_Promise() {return require("./../../../lime/app/Promise");}
+function HxOverrides() {return require("./../../../HxOverrides");}
+function lime_net_HTTPRequestHeader() {return require("./../../../lime/net/HTTPRequestHeader");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function List() {return require("./../../../List");}
+function js_Browser() {return require("./../../../js/Browser");}
+function lime_graphics_ImageBuffer() {return require("./../../../lime/graphics/ImageBuffer");}
+function lime_graphics_Image() {return require("./../../../lime/graphics/Image");}
+function EReg() {return require("./../../../EReg");}
+
+// Constructor
+
+var HTML5HTTPRequest = function() {
+	this.validStatus0 = new (EReg().default)("Tizen","gi").match((js_Browser().default).get_window().navigator.userAgent);
+}
+
+// Meta
+
+HTML5HTTPRequest.__name__ = ["lime","_backend","html5","HTML5HTTPRequest"];
+HTML5HTTPRequest.prototype = {
+	cancel: function() {
+		if(this.request != null) {
+			this.request.abort();
+		}
+	},
+	init: function(parent) {
+		this.parent = parent;
+	},
+	load: function(uri,progress,readyStateChange) {
+		this.request = new XMLHttpRequest();
+		if(this.parent.method == "POST") {
+			this.request.upload.addEventListener("progress",progress,false);
+		} else {
+			this.request.addEventListener("progress",progress,false);
+		}
+		this.request.onreadystatechange = readyStateChange;
+		var query = "";
+		if(this.parent.data == null) {
+			var key = this.parent.formData.keys();
+			while(key.hasNext()) {
+				var key1 = key.next();
+				if(query.length > 0) {
+					query += "&";
+				}
+				query += (StringTools().default).urlEncode(key1) + "=" + (StringTools().default).urlEncode((Std().default).string(this.parent.formData.get(key1)));
+			}
+			if(this.parent.method == "GET" && query != "") {
+				if(uri.indexOf("?") > -1) {
+					uri += "&" + query;
+				} else {
+					uri += "?" + query;
+				}
+				query = "";
+			}
+		}
+		this.request.open((Std().default).string(this.parent.method),uri,true);
+		if(this.parent.timeout > 0) {
+			this.request.timeout = this.parent.timeout;
+		}
+		if(this.binary) {
+			this.request.responseType = "arraybuffer";
+		}
+		var contentType = null;
+		var _g = 0;
+		var _g1 = this.parent.headers;
+		while(_g < _g1.length) {
+			var header = _g1[_g];
+			++_g;
+			if(header.name == "Content-Type") {
+				contentType = header.value;
+			} else {
+				this.request.setRequestHeader(header.name,header.value);
+			}
+		}
+		if(this.parent.contentType != null) {
+			contentType = this.parent.contentType;
+		}
+		if(contentType == null) {
+			if(this.parent.data != null) {
+				contentType = "application/octet-stream";
+			} else if(query != "") {
+				contentType = "application/x-www-form-urlencoded";
+			}
+		}
+		if(contentType != null) {
+			this.request.setRequestHeader("Content-Type",contentType);
+		}
+		if(this.parent.withCredentials) {
+			this.request.withCredentials = true;
+		}
+		if(this.parent.data != null) {
+			this.request.send(this.parent.data.getData());
+		} else {
+			this.request.send(query);
+		}
+	},
+	loadData: function(uri) {
+		var promise = new (lime_app_Promise().default)();
+		if(HTML5HTTPRequest.activeRequests < HTML5HTTPRequest.requestLimit) {
+			HTML5HTTPRequest.activeRequests++;
+			this.__loadData(uri,promise);
+		} else {
+			HTML5HTTPRequest.requestQueue.add({ instance : this, uri : uri, promise : promise, type : "BINARY"});
+		}
+		return promise.future;
+	},
+	loadText: function(uri) {
+		var promise = new (lime_app_Promise().default)();
+		if(HTML5HTTPRequest.activeRequests < HTML5HTTPRequest.requestLimit) {
+			HTML5HTTPRequest.activeRequests++;
+			this.__loadText(uri,promise);
+		} else {
+			HTML5HTTPRequest.requestQueue.add({ instance : this, uri : uri, promise : promise, type : "TEXT"});
+		}
+		return promise.future;
+	},
+	processResponse: function() {
+		if(this.parent.enableResponseHeaders) {
+			this.parent.responseHeaders = [];
+			var name;
+			var value;
+			var _g = 0;
+			var _g1 = this.request.getAllResponseHeaders().split("\n");
+			while(_g < _g1.length) {
+				var line = _g1[_g];
+				++_g;
+				name = (StringTools().default).trim((HxOverrides().default).substr(line,0,line.indexOf(":")));
+				value = (StringTools().default).trim((HxOverrides().default).substr(line,line.indexOf(":") + 1,null));
+				if(name != "") {
+					this.parent.responseHeaders.push(new (lime_net_HTTPRequestHeader().default)(name,value));
+				}
+			}
+		}
+		this.parent.responseStatus = this.request.status;
+	},
+	__loadData: function(uri,promise) {
+		var _gthis = this;
+		var progress = function(event) {
+			promise.progress(event.loaded,event.total);
+		};
+		var readyStateChange = function(event1) {
+			if(_gthis.request.readyState != 4) {
+				return;
+			}
+			if(_gthis.request.status != null && (_gthis.request.status >= 200 && _gthis.request.status < 400 || _gthis.validStatus0 && _gthis.request.status == 0)) {
+				var bytes = null;
+				if(_gthis.request.responseType == "") {
+					if(_gthis.request.responseText != null) {
+						bytes = (haxe_io_Bytes().default).ofString(_gthis.request.responseText);
+					}
+				} else if(_gthis.request.response != null) {
+					bytes = (haxe_io_Bytes().default).ofData(_gthis.request.response);
+				}
+				_gthis.processResponse();
+				promise.complete(bytes);
+			} else {
+				_gthis.processResponse();
+				promise.error(_gthis.request.status);
+			}
+			_gthis.request = null;
+			HTML5HTTPRequest.activeRequests--;
+			HTML5HTTPRequest.processQueue();
+		};
+		this.binary = true;
+		this.load(uri,progress,readyStateChange);
+	},
+	__loadText: function(uri,promise) {
+		var _gthis = this;
+		var progress = function(event) {
+			promise.progress(event.loaded,event.total);
+		};
+		var readyStateChange = function(event1) {
+			if(_gthis.request.readyState != 4) {
+				return;
+			}
+			if(_gthis.request.status != null && (_gthis.request.status >= 200 && _gthis.request.status <= 400 || _gthis.validStatus0 && _gthis.request.status == 0)) {
+				_gthis.processResponse();
+				promise.complete(_gthis.request.responseText);
+			} else {
+				_gthis.processResponse();
+				promise.error(_gthis.request.status);
+			}
+			_gthis.request = null;
+			HTML5HTTPRequest.activeRequests--;
+			HTML5HTTPRequest.processQueue();
+		};
+		this.binary = false;
+		this.load(uri,progress,readyStateChange);
+	}
+};
+HTML5HTTPRequest.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5HTTPRequest"] = HTML5HTTPRequest;
+
+// Init
+
+
+
+// Statics
+
+HTML5HTTPRequest.loadImage = function(uri) {
+	var promise = new (lime_app_Promise().default)();
+	if(HTML5HTTPRequest.activeRequests < HTML5HTTPRequest.requestLimit) {
+		HTML5HTTPRequest.activeRequests++;
+		HTML5HTTPRequest.__loadImage(uri,promise);
+	} else {
+		HTML5HTTPRequest.requestQueue.add({ instance : null, uri : uri, promise : promise, type : "IMAGE"});
+	}
+	return promise.future;
+}
+HTML5HTTPRequest.processQueue = function() {
+	if(HTML5HTTPRequest.activeRequests < HTML5HTTPRequest.requestLimit && HTML5HTTPRequest.requestQueue.length > 0) {
+		HTML5HTTPRequest.activeRequests++;
+		var queueItem = HTML5HTTPRequest.requestQueue.pop();
+		var _g = queueItem.type;
+		switch(_g) {
+		case "BINARY":
+			queueItem.instance.__loadData(queueItem.uri,queueItem.promise);
+			break;
+		case "IMAGE":
+			HTML5HTTPRequest.__loadImage(queueItem.uri,queueItem.promise);
+			break;
+		case "TEXT":
+			queueItem.instance.__loadText(queueItem.uri,queueItem.promise);
+			break;
+		default:
+			HTML5HTTPRequest.activeRequests--;
+		}
+	}
+}
+HTML5HTTPRequest.__fixHostname = function(hostname) {
+	if(hostname == null) {
+		return "";
+	} else {
+		return hostname;
+	}
+}
+HTML5HTTPRequest.__fixPort = function(port,protocol) {
+	if(port == null || port == "") {
+		switch(protocol) {
+		case "ftp:":
+			return "21";
+		case "gopher:":
+			return "70";
+		case "http:":
+			return "80";
+		case "https:":
+			return "443";
+		case "ws:":
+			return "80";
+		case "wss:":
+			return "443";
+		default:
+			return "";
+		}
+	}
+	return port;
+}
+HTML5HTTPRequest.__fixProtocol = function(protocol) {
+	if(protocol == null || protocol == "") {
+		return "http:";
+	} else {
+		return protocol;
+	}
+}
+HTML5HTTPRequest.__isSameOrigin = function(path) {
+	if(HTML5HTTPRequest.originElement == null) {
+		HTML5HTTPRequest.originElement = (js_Browser().default).get_document().createElement("a");
+		HTML5HTTPRequest.originHostname = HTML5HTTPRequest.__fixHostname((js_Browser().default).get_location().hostname);
+		HTML5HTTPRequest.originProtocol = HTML5HTTPRequest.__fixProtocol((js_Browser().default).get_location().protocol);
+		HTML5HTTPRequest.originPort = HTML5HTTPRequest.__fixPort((js_Browser().default).get_location().port,HTML5HTTPRequest.originProtocol);
+	}
+	var a = HTML5HTTPRequest.originElement;
+	a.href = path;
+	if(a.hostname == "") {
+		a.href = a.href;
+	}
+	var hostname = HTML5HTTPRequest.__fixHostname(a.hostname);
+	var protocol = HTML5HTTPRequest.__fixProtocol(a.protocol);
+	var port = HTML5HTTPRequest.__fixPort(a.port,protocol);
+	var sameHost = hostname == "" || hostname == HTML5HTTPRequest.originHostname;
+	var samePort = port == "" || port == HTML5HTTPRequest.originPort;
+	if(protocol != "file:" && sameHost) {
+		return samePort;
+	} else {
+		return false;
+	}
+}
+HTML5HTTPRequest.__loadImage = function(uri,promise) {
+	var image = new Image();
+	if(!HTML5HTTPRequest.__isSameOrigin(uri)) {
+		image.crossOrigin = "Anonymous";
+	}
+	if(HTML5HTTPRequest.supportsImageProgress == null) {
+		HTML5HTTPRequest.supportsImageProgress = 'onprogress' in image;
+	}
+	if(HTML5HTTPRequest.supportsImageProgress || (StringTools().default).startsWith(uri,"data:")) {
+		image.addEventListener("load",function(event) {
+			var buffer = new (lime_graphics_ImageBuffer().default)(null,image.width,image.height);
+			buffer.__srcImage = image;
+			HTML5HTTPRequest.activeRequests--;
+			HTML5HTTPRequest.processQueue();
+			promise.complete(new (lime_graphics_Image().default)(buffer));
+		},false);
+		image.addEventListener("progress",function(event1) {
+			promise.progress(event1.loaded,event1.total);
+		},false);
+		image.addEventListener("error",function(event2) {
+			HTML5HTTPRequest.activeRequests--;
+			HTML5HTTPRequest.processQueue();
+			promise.error(event2.detail);
+		},false);
+		image.src = uri;
+	} else {
+		var request = new XMLHttpRequest();
+		request.onload = function(_) {
+			HTML5HTTPRequest.activeRequests--;
+			HTML5HTTPRequest.processQueue();
+			var img = new (lime_graphics_Image().default)();
+			img.__fromBytes((haxe_io_Bytes().default).ofData(request.response),function(img1) {
+				promise.complete(img1);
+			});
+		};
+		request.onerror = function(event3) {
+			promise.error(event3.message);
+		};
+		request.onprogress = function(event4) {
+			if(event4.lengthComputable) {
+				promise.progress(event4.loaded,event4.total);
+			}
+		};
+		request.open("GET",uri,true);
+		request.responseType = "arraybuffer";
+		request.overrideMimeType("text/plain; charset=x-user-defined");
+		request.send(null);
+	}
+}
+HTML5HTTPRequest.activeRequests = 0
+HTML5HTTPRequest.requestLimit = 4
+HTML5HTTPRequest.requestQueue = new (List().default)()
+
+// Export
+
+exports.default = HTML5HTTPRequest;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5Mouse.js

@@ -0,0 +1,126 @@
+// Class: lime._backend.html5.HTML5Mouse
+
+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 lime_app_Application() {return require("./../../../lime/app/Application");}
+function lime_ui_MouseCursor() {return require("./../../../lime/ui/MouseCursor");}
+function Type() {return require("./../../../Type");}
+
+// Constructor
+
+var HTML5Mouse = function(){}
+
+// Meta
+
+HTML5Mouse.__name__ = ["lime","_backend","html5","HTML5Mouse"];
+HTML5Mouse.prototype = {
+	
+};
+HTML5Mouse.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5Mouse"] = HTML5Mouse;
+
+// Init
+
+
+
+// Statics
+
+HTML5Mouse.hide = function() {
+	if(!HTML5Mouse.__hidden) {
+		HTML5Mouse.__hidden = true;
+		var _g = 0;
+		var _g1 = (lime_app_Application().default).current.get_windows();
+		while(_g < _g1.length) {
+			var $window = _g1[_g];
+			++_g;
+			$window.backend.element.style.cursor = "none";
+		}
+	}
+}
+HTML5Mouse.show = function() {
+	if(HTML5Mouse.__hidden) {
+		HTML5Mouse.__hidden = false;
+		var cacheValue = HTML5Mouse.__cursor;
+		HTML5Mouse.__cursor = null;
+		HTML5Mouse.set_cursor(cacheValue);
+	}
+}
+HTML5Mouse.warp = function(x,y,window) {
+}
+HTML5Mouse.get_cursor = function() {
+	if(HTML5Mouse.__cursor == null) {
+		return (lime_ui_MouseCursor().default).DEFAULT;
+	}
+	return HTML5Mouse.__cursor;
+}
+HTML5Mouse.set_cursor = function(value) {
+	if(HTML5Mouse.__cursor != value) {
+		if(!HTML5Mouse.__hidden) {
+			var _g = 0;
+			var _g1 = (lime_app_Application().default).current.get_windows();
+			while(_g < _g1.length) {
+				var $window = _g1[_g];
+				++_g;
+				var tmp;
+				switch((Type().default).enumIndex(value)) {
+				case 0:
+					tmp = "default";
+					break;
+				case 1:
+					tmp = "crosshair";
+					break;
+				case 3:
+					tmp = "move";
+					break;
+				case 4:
+					tmp = "pointer";
+					break;
+				case 5:
+					tmp = "nesw-resize";
+					break;
+				case 6:
+					tmp = "ns-resize";
+					break;
+				case 7:
+					tmp = "nwse-resize";
+					break;
+				case 8:
+					tmp = "ew-resize";
+					break;
+				case 9:
+					tmp = "text";
+					break;
+				case 10:
+					tmp = "wait";
+					break;
+				case 11:
+					tmp = "wait";
+					break;
+				default:
+					tmp = "auto";
+				}
+				$window.backend.element.style.cursor = tmp;
+			}
+		}
+		HTML5Mouse.__cursor = value;
+	}
+	return HTML5Mouse.__cursor;
+}
+HTML5Mouse.get_lock = function() {
+	return false;
+}
+HTML5Mouse.set_lock = function(value) {
+	return value;
+}
+
+
+// Export
+
+exports.default = HTML5Mouse;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5Renderer.js

@@ -0,0 +1,135 @@
+// Class: lime._backend.html5.HTML5Renderer
+
+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 $bind = require("./../../../bind_stub").default;
+function Type() {return require("./../../../Type");}
+function lime_graphics_RenderContext() {return require("./../../../lime/graphics/RenderContext");}
+function lime_graphics_RendererType() {return require("./../../../lime/graphics/RendererType");}
+function Reflect() {return require("./../../../Reflect");}
+function lime_graphics_opengl_GL() {return require("./../../../lime/graphics/opengl/GL");}
+function lime__$backend_html5_HTML5GLRenderContext() {return require("./../../../lime/_backend/html5/HTML5GLRenderContext");}
+function lime_math_Rectangle() {return require("./../../../lime/math/Rectangle");}
+function js_Browser() {return require("./../../../js/Browser");}
+function Std() {return require("./../../../Std");}
+function lime_graphics_Image() {return require("./../../../lime/graphics/Image");}
+
+// Constructor
+
+var HTML5Renderer = function(parent) {
+	this.parent = parent;
+}
+
+// Meta
+
+HTML5Renderer.__name__ = ["lime","_backend","html5","HTML5Renderer"];
+HTML5Renderer.prototype = {
+	create: function() {
+		this.createContext();
+		var _g = this.parent.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			this.parent.window.backend.canvas.addEventListener("webglcontextlost",$bind(this,this.handleEvent),false);
+			this.parent.window.backend.canvas.addEventListener("webglcontextrestored",$bind(this,this.handleEvent),false);
+		}
+	},
+	createContext: function() {
+		if(this.parent.window.backend.div != null) {
+			this.parent.context = (lime_graphics_RenderContext().default).DOM(this.parent.window.backend.div);
+			this.parent.type = (lime_graphics_RendererType().default).DOM;
+		} else if(this.parent.window.backend.canvas != null) {
+			var webgl = null;
+			var renderType = this.parent.window.backend.renderType;
+			var forceCanvas = renderType == "canvas";
+			var forceWebGL = renderType == "opengl" || renderType == "webgl" || renderType == "webgl1" || renderType == "webgl2";
+			var allowWebGL2 = renderType != "webgl1";
+			if(forceWebGL || !forceCanvas && (!(Reflect().default).hasField(this.parent.window.config,"hardware") || this.parent.window.config.hardware)) {
+				var transparentBackground = (Reflect().default).hasField(this.parent.window.config,"background") && this.parent.window.config.background == null;
+				var colorDepth = (Reflect().default).hasField(this.parent.window.config,"colorDepth") ? this.parent.window.config.colorDepth : 16;
+				var options = { alpha : transparentBackground || colorDepth > 16, antialias : (Reflect().default).hasField(this.parent.window.config,"antialiasing") && this.parent.window.config.antialiasing > 0, depth : (Reflect().default).hasField(this.parent.window.config,"depthBuffer") ? this.parent.window.config.depthBuffer : true, premultipliedAlpha : true, stencil : (Reflect().default).hasField(this.parent.window.config,"stencilBuffer") && this.parent.window.config.stencilBuffer, preserveDrawingBuffer : false};
+				var glContextType = ["webgl","experimental-webgl"];
+				if(allowWebGL2) {
+					glContextType.unshift("webgl2");
+				}
+				var _g = 0;
+				while(_g < glContextType.length) {
+					var name = glContextType[_g];
+					++_g;
+					webgl = this.parent.window.backend.canvas.getContext(name,options);
+					if(webgl != null) {
+						break;
+					}
+				}
+			}
+			if(webgl == null) {
+				this.parent.context = (lime_graphics_RenderContext().default).CANVAS(this.parent.window.backend.canvas.getContext("2d"));
+				this.parent.type = (lime_graphics_RendererType().default).CANVAS;
+			} else {
+				(lime_graphics_opengl_GL().default).context = new (lime__$backend_html5_HTML5GLRenderContext().default)(webgl);
+				this.parent.context = (lime_graphics_RenderContext().default).OPENGL((lime_graphics_opengl_GL().default).context);
+				this.parent.type = (lime_graphics_RendererType().default).OPENGL;
+			}
+		}
+	},
+	flip: function() {
+	},
+	handleEvent: function(event) {
+		var _g = event.type;
+		switch(_g) {
+		case "webglcontextlost":
+			event.preventDefault();
+			if((lime_graphics_opengl_GL().default).context != null) {
+				(lime_graphics_opengl_GL().default).context.__contextLost = true;
+			}
+			this.parent.context = null;
+			this.parent.onContextLost.dispatch();
+			break;
+		case "webglcontextrestored":
+			this.createContext();
+			this.parent.onContextRestored.dispatch(this.parent.context);
+			break;
+		default:
+		}
+	},
+	readPixels: function(rect) {
+		if(this.parent.window.backend.canvas != null) {
+			if(rect == null) {
+				rect = new (lime_math_Rectangle().default)(0,0,this.parent.window.backend.canvas.width,this.parent.window.backend.canvas.height);
+			} else {
+				rect.__contract(0,0,this.parent.window.backend.canvas.width,this.parent.window.backend.canvas.height);
+			}
+			if(rect.width > 0 && rect.height > 0) {
+				var canvas = (js_Browser().default).get_document().createElement("canvas");
+				canvas.width = (Std().default)["int"](rect.width);
+				canvas.height = (Std().default)["int"](rect.height);
+				var context = canvas.getContext("2d");
+				context.drawImage(this.parent.window.backend.canvas,-rect.x,-rect.y);
+				return (lime_graphics_Image().default).fromCanvas(canvas);
+			}
+		}
+		return null;
+	},
+	render: function() {
+	}
+};
+HTML5Renderer.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5Renderer"] = HTML5Renderer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = HTML5Renderer;

hGameTest/node_modules/openfl/lib/_gen/lime/_backend/html5/HTML5Window.js

@@ -0,0 +1,639 @@
+// Class: lime._backend.html5.HTML5Window
+
+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 $bind = require("./../../../bind_stub").default;
+function js_Browser() {return require("./../../../js/Browser");}
+function Std() {return require("./../../../Std");}
+function lime_system_System() {return require("./../../../lime/system/System");}
+function lime_system_Clipboard() {return require("./../../../lime/system/Clipboard");}
+function haxe_Timer() {return require("./../../../haxe/Timer");}
+function lime_ui_Joystick() {return require("./../../../lime/ui/Joystick");}
+function lime_ui_Gamepad() {return require("./../../../lime/ui/Gamepad");}
+function StringTools() {return require("./../../../StringTools");}
+function lime_ui_Touch() {return require("./../../../lime/ui/Touch");}
+function EReg() {return require("./../../../EReg");}
+function lime_graphics_utils_ImageCanvasUtil() {return require("./../../../lime/graphics/utils/ImageCanvasUtil");}
+function List() {return require("./../../../List");}
+function haxe_ds_IntMap() {return require("./../../../haxe/ds/IntMap");}
+function Reflect() {return require("./../../../Reflect");}
+
+// Constructor
+
+var HTML5Window = function(parent) {
+	this.unusedTouchesPool = new (List().default)();
+	this.scale = 1.0;
+	this.currentTouches = new (haxe_ds_IntMap().default)();
+	this.parent = parent;
+	if(parent.config != null && (Reflect().default).hasField(parent.config,"element")) {
+		this.element = parent.config.element;
+	}
+	if(parent.config != null && (Reflect().default).hasField(parent.config,"renderer")) {
+		this.renderType = parent.config.renderer;
+	}
+	if(parent.config != null && (Reflect().default).hasField(parent.config,"allowHighDPI") && parent.config.allowHighDPI && this.renderType != "dom") {
+		this.scale = (js_Browser().default).get_window().devicePixelRatio;
+	}
+	parent.__scale = this.scale;
+	this.cacheMouseX = 0;
+	this.cacheMouseY = 0;
+}
+
+// Meta
+
+HTML5Window.__name__ = ["lime","_backend","html5","HTML5Window"];
+HTML5Window.prototype = {
+	alert: function(message,title) {
+		if(message != null) {
+			(js_Browser().default).alert(message);
+		}
+	},
+	close: function() {
+		this.parent.application.removeWindow(this.parent);
+	},
+	create: function(application) {
+		this.setWidth = this.parent.get_width();
+		this.setHeight = this.parent.get_height();
+		this.parent.id = HTML5Window.windowID++;
+		if((Std().default)["is"](this.element,HTMLCanvasElement)) {
+			this.canvas = this.element;
+		} else if(this.renderType == "dom") {
+			this.div = (js_Browser().default).get_document().createElement("div");
+		} else {
+			this.canvas = (js_Browser().default).get_document().createElement("canvas");
+		}
+		if(this.canvas != null) {
+			var style = this.canvas.style;
+			style.setProperty("-webkit-transform","translateZ(0)",null);
+			style.setProperty("transform","translateZ(0)",null);
+		} else if(this.div != null) {
+			var style1 = this.div.style;
+			style1.setProperty("-webkit-transform","translate3D(0,0,0)",null);
+			style1.setProperty("transform","translate3D(0,0,0)",null);
+			style1.position = "relative";
+			style1.overflow = "hidden";
+			style1.setProperty("-webkit-user-select","none",null);
+			style1.setProperty("-moz-user-select","none",null);
+			style1.setProperty("-ms-user-select","none",null);
+			style1.setProperty("-o-user-select","none",null);
+		}
+		if(this.parent.get_width() == 0 && this.parent.get_height() == 0) {
+			if(this.element != null) {
+				this.parent.set_width(this.element.clientWidth);
+				this.parent.set_height(this.element.clientHeight);
+			} else {
+				this.parent.set_width((js_Browser().default).get_window().innerWidth);
+				this.parent.set_height((js_Browser().default).get_window().innerHeight);
+			}
+			this.cacheElementWidth = this.parent.get_width();
+			this.cacheElementHeight = this.parent.get_height();
+			this.resizeElement = true;
+		}
+		if(this.canvas != null) {
+			var tmp = this.parent.get_width() * this.scale;
+			this.canvas.width = Math.round(tmp);
+			var tmp1 = this.parent.get_height() * this.scale;
+			this.canvas.height = Math.round(tmp1);
+			var tmp2 = this.parent.get_width();
+			this.canvas.style.width = tmp2 + "px";
+			var tmp3 = this.parent.get_height();
+			this.canvas.style.height = tmp3 + "px";
+		} else {
+			var tmp4 = this.parent.get_width();
+			this.div.style.width = tmp4 + "px";
+			var tmp5 = this.parent.get_height();
+			this.div.style.height = tmp5 + "px";
+		}
+		this.updateSize();
+		if(this.element != null) {
+			if(this.canvas != null) {
+				if(this.element != this.canvas) {
+					this.element.appendChild(this.canvas);
+				}
+			} else {
+				this.element.appendChild(this.div);
+			}
+			var events = ["mousedown","mouseenter","mouseleave","mousemove","mouseup","wheel"];
+			var _g = 0;
+			while(_g < events.length) {
+				var event = events[_g];
+				++_g;
+				this.element.addEventListener(event,$bind(this,this.handleMouseEvent),true);
+			}
+			(js_Browser().default).get_document().addEventListener("dragstart",function(e) {
+				if(e.target.nodeName.toLowerCase() == "img") {
+					e.preventDefault();
+					return false;
+				}
+				return true;
+			},false);
+			this.element.addEventListener("contextmenu",$bind(this,this.handleContextMenuEvent),true);
+			this.element.addEventListener("touchstart",$bind(this,this.handleTouchEvent),true);
+			this.element.addEventListener("touchmove",$bind(this,this.handleTouchEvent),true);
+			this.element.addEventListener("touchend",$bind(this,this.handleTouchEvent),true);
+			this.element.addEventListener("touchcancel",$bind(this,this.handleTouchEvent),true);
+			this.element.addEventListener("gamepadconnected",$bind(this,this.handleGamepadEvent),true);
+			this.element.addEventListener("gamepaddisconnected",$bind(this,this.handleGamepadEvent),true);
+		}
+	},
+	focus: function() {
+	},
+	getDisplay: function() {
+		return (lime_system_System().default).getDisplay(0);
+	},
+	getDisplayMode: function() {
+		return (lime_system_System().default).getDisplay(0).currentMode;
+	},
+	setDisplayMode: function(value) {
+		return value;
+	},
+	getEnableTextEvents: function() {
+		return this.enableTextEvents;
+	},
+	handleContextMenuEvent: function(event) {
+		if(this.parent.onMouseUp.canceled) {
+			event.preventDefault();
+		}
+	},
+	handleCutOrCopyEvent: function(event) {
+		event.clipboardData.setData("text/plain",(lime_system_Clipboard().default).get_text());
+		event.preventDefault();
+	},
+	handleFocusEvent: function(event) {
+		var _gthis = this;
+		if(this.enableTextEvents) {
+			if(event.relatedTarget == null || this.isDescendent(event.relatedTarget)) {
+				(haxe_Timer().default).delay(function() {
+					if(_gthis.enableTextEvents) {
+						HTML5Window.textInput.focus();
+					}
+				},20);
+			}
+		}
+	},
+	handleFullscreenEvent: function(event) {
+		var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
+		if(fullscreenElement != null) {
+			this.isFullscreen = true;
+			this.parent.__fullscreen = true;
+			if(this.requestedFullscreen) {
+				this.requestedFullscreen = false;
+				this.parent.onFullscreen.dispatch();
+			}
+		} else {
+			this.isFullscreen = false;
+			this.parent.__fullscreen = false;
+			var changeEvents = ["fullscreenchange","mozfullscreenchange","webkitfullscreenchange","MSFullscreenChange"];
+			var errorEvents = ["fullscreenerror","mozfullscreenerror","webkitfullscreenerror","MSFullscreenError"];
+			var _g1 = 0;
+			var _g = changeEvents.length;
+			while(_g1 < _g) {
+				var i = _g1++;
+				(js_Browser().default).get_document().removeEventListener(changeEvents[i],$bind(this,this.handleFullscreenEvent),false);
+				(js_Browser().default).get_document().removeEventListener(errorEvents[i],$bind(this,this.handleFullscreenEvent),false);
+			}
+		}
+	},
+	handleGamepadEvent: function(event) {
+		var _g = event.type;
+		switch(_g) {
+		case "gamepadconnected":
+			(lime_ui_Joystick().default).__connect(event.gamepad.index);
+			if(event.gamepad.mapping == "standard") {
+				(lime_ui_Gamepad().default).__connect(event.gamepad.index);
+			}
+			break;
+		case "gamepaddisconnected":
+			(lime_ui_Joystick().default).__disconnect(event.gamepad.index);
+			(lime_ui_Gamepad().default).__disconnect(event.gamepad.index);
+			break;
+		default:
+		}
+	},
+	handleInputEvent: function(event) {
+		if(HTML5Window.textInput.value != HTML5Window.dummyCharacter) {
+			var value = (StringTools().default).replace(HTML5Window.textInput.value,HTML5Window.dummyCharacter,"");
+			if(value.length > 0) {
+				this.parent.onTextInput.dispatch(value);
+			}
+			HTML5Window.textInput.value = HTML5Window.dummyCharacter;
+		}
+	},
+	handleMouseEvent: function(event) {
+		var x = 0.0;
+		var y = 0.0;
+		if(event.type != "wheel") {
+			if(this.element != null) {
+				if(this.canvas != null) {
+					var rect = this.canvas.getBoundingClientRect();
+					x = (event.clientX - rect.left) * (this.parent.get_width() / rect.width);
+					y = (event.clientY - rect.top) * (this.parent.get_height() / rect.height);
+				} else if(this.div != null) {
+					var rect1 = this.div.getBoundingClientRect();
+					x = event.clientX - rect1.left;
+					y = event.clientY - rect1.top;
+				} else {
+					var rect2 = this.element.getBoundingClientRect();
+					x = (event.clientX - rect2.left) * (this.parent.get_width() / rect2.width);
+					y = (event.clientY - rect2.top) * (this.parent.get_height() / rect2.height);
+				}
+			} else {
+				x = event.clientX;
+				y = event.clientY;
+			}
+			var _g = event.type;
+			switch(_g) {
+			case "mousedown":
+				this.parent.onMouseDown.dispatch(x,y,event.button);
+				if(this.parent.onMouseDown.canceled) {
+					event.preventDefault();
+				}
+				break;
+			case "mouseenter":
+				if(event.target == this.element) {
+					this.parent.onEnter.dispatch();
+					if(this.parent.onEnter.canceled) {
+						event.preventDefault();
+					}
+				}
+				break;
+			case "mouseleave":
+				if(event.target == this.element) {
+					this.parent.onLeave.dispatch();
+					if(this.parent.onLeave.canceled) {
+						event.preventDefault();
+					}
+				}
+				break;
+			case "mousemove":
+				if(x != this.cacheMouseX || y != this.cacheMouseY) {
+					this.parent.onMouseMove.dispatch(x,y);
+					this.parent.onMouseMoveRelative.dispatch(x - this.cacheMouseX,y - this.cacheMouseY);
+					if(this.parent.onMouseMove.canceled || this.parent.onMouseMoveRelative.canceled) {
+						event.preventDefault();
+					}
+				}
+				break;
+			case "mouseup":
+				this.parent.onMouseUp.dispatch(x,y,event.button);
+				if(this.parent.onMouseUp.canceled) {
+					event.preventDefault();
+				}
+				break;
+			default:
+			}
+			this.cacheMouseX = x;
+			this.cacheMouseY = y;
+		} else {
+			this.parent.onMouseWheel.dispatch(event.deltaX,-event.deltaY);
+			if(this.parent.onMouseWheel.canceled) {
+				event.preventDefault();
+			}
+		}
+	},
+	handlePasteEvent: function(event) {
+		if(event.clipboardData.types.indexOf("text/plain") > -1) {
+			var text = event.clipboardData.getData("text/plain");
+			(lime_system_Clipboard().default).set_text(text);
+			if(this.enableTextEvents) {
+				this.parent.onTextInput.dispatch(text);
+			}
+			event.preventDefault();
+		}
+	},
+	handleResizeEvent: function(event) {
+		this.primaryTouch = null;
+		this.updateSize();
+	},
+	handleTouchEvent: function(event) {
+		event.preventDefault();
+		var rect = null;
+		if(this.element != null) {
+			if(this.canvas != null) {
+				rect = this.canvas.getBoundingClientRect();
+			} else if(this.div != null) {
+				rect = this.div.getBoundingClientRect();
+			} else {
+				rect = this.element.getBoundingClientRect();
+			}
+		}
+		var windowWidth = this.setWidth;
+		var windowHeight = this.setHeight;
+		if(windowWidth == 0 || windowHeight == 0) {
+			if(rect != null) {
+				windowWidth = rect.width;
+				windowHeight = rect.height;
+			} else {
+				windowWidth = 1;
+				windowHeight = 1;
+			}
+		}
+		var touch;
+		var x;
+		var y;
+		var cacheX;
+		var cacheY;
+		var _g = 0;
+		var _g1 = event.changedTouches;
+		while(_g < _g1.length) {
+			var data = _g1[_g];
+			++_g;
+			x = 0.0;
+			y = 0.0;
+			if(rect != null) {
+				x = (data.clientX - rect.left) * (windowWidth / rect.width);
+				y = (data.clientY - rect.top) * (windowHeight / rect.height);
+			} else {
+				x = data.clientX;
+				y = data.clientY;
+			}
+			if(event.type == "touchstart") {
+				touch = this.unusedTouchesPool.pop();
+				if(touch == null) {
+					touch = new (lime_ui_Touch().default)(x / windowWidth,y / windowHeight,data.identifier,0,0,data.force,this.parent.id);
+				} else {
+					touch.x = x / windowWidth;
+					touch.y = y / windowHeight;
+					touch.id = data.identifier;
+					touch.dx = 0;
+					touch.dy = 0;
+					touch.pressure = data.force;
+					touch.device = this.parent.id;
+				}
+				this.currentTouches.set(data.identifier,touch);
+				(lime_ui_Touch().default).onStart.dispatch(touch);
+				if(this.primaryTouch == null) {
+					this.primaryTouch = touch;
+				}
+				if(touch == this.primaryTouch) {
+					this.parent.onMouseDown.dispatch(x,y,0);
+				}
+			} else {
+				touch = this.currentTouches.get(data.identifier);
+				if(touch != null) {
+					cacheX = touch.x;
+					cacheY = touch.y;
+					touch.x = x / windowWidth;
+					touch.y = y / windowHeight;
+					touch.dx = touch.x - cacheX;
+					touch.dy = touch.y - cacheY;
+					touch.pressure = data.force;
+					var _g2 = event.type;
+					switch(_g2) {
+					case "touchcancel":
+						(lime_ui_Touch().default).onCancel.dispatch(touch);
+						this.currentTouches.remove(data.identifier);
+						this.unusedTouchesPool.add(touch);
+						if(touch == this.primaryTouch) {
+							this.primaryTouch = null;
+						}
+						break;
+					case "touchend":
+						(lime_ui_Touch().default).onEnd.dispatch(touch);
+						this.currentTouches.remove(data.identifier);
+						this.unusedTouchesPool.add(touch);
+						if(touch == this.primaryTouch) {
+							this.parent.onMouseUp.dispatch(x,y,0);
+							this.primaryTouch = null;
+						}
+						break;
+					case "touchmove":
+						(lime_ui_Touch().default).onMove.dispatch(touch);
+						if(touch == this.primaryTouch) {
+							this.parent.onMouseMove.dispatch(x,y);
+						}
+						break;
+					default:
+					}
+				}
+			}
+		}
+	},
+	isDescendent: function(node) {
+		if(node == this.element) {
+			return true;
+		}
+		while(node != null) {
+			if(node.parentNode == this.element) {
+				return true;
+			}
+			node = node.parentNode;
+		}
+		return false;
+	},
+	move: function(x,y) {
+	},
+	resize: function(width,height) {
+	},
+	setBorderless: function(value) {
+		return value;
+	},
+	setClipboard: function(value) {
+		var inputEnabled = this.enableTextEvents;
+		this.setEnableTextEvents(true);
+		var cacheText = HTML5Window.textInput.value;
+		HTML5Window.textInput.value = value;
+		HTML5Window.textInput.select();
+		if((js_Browser().default).get_document().queryCommandEnabled("copy")) {
+			(js_Browser().default).get_document().execCommand("copy");
+		}
+		HTML5Window.textInput.value = cacheText;
+		this.setEnableTextEvents(inputEnabled);
+	},
+	setEnableTextEvents: function(value) {
+		if(value) {
+			if(HTML5Window.textInput == null) {
+				HTML5Window.textInput = (js_Browser().default).get_document().createElement("input");
+				HTML5Window.textInput.type = "text";
+				HTML5Window.textInput.style.position = "absolute";
+				HTML5Window.textInput.style.opacity = "0";
+				HTML5Window.textInput.style.color = "transparent";
+				HTML5Window.textInput.value = HTML5Window.dummyCharacter;
+				HTML5Window.textInput.autocapitalize = "off";
+				HTML5Window.textInput.autocorrect = "off";
+				HTML5Window.textInput.autocomplete = "off";
+				HTML5Window.textInput.style.left = "0px";
+				HTML5Window.textInput.style.top = "50%";
+				if(new (EReg().default)("(iPad|iPhone|iPod).*OS 8_","gi").match((js_Browser().default).get_window().navigator.userAgent)) {
+					HTML5Window.textInput.style.fontSize = "0px";
+					HTML5Window.textInput.style.width = "0px";
+					HTML5Window.textInput.style.height = "0px";
+				} else {
+					HTML5Window.textInput.style.width = "1px";
+					HTML5Window.textInput.style.height = "1px";
+				}
+				HTML5Window.textInput.style.pointerEvents = "none";
+				HTML5Window.textInput.style.zIndex = "-10000000";
+				(js_Browser().default).get_document().body.appendChild(HTML5Window.textInput);
+			}
+			if(!this.enableTextEvents) {
+				HTML5Window.textInput.addEventListener("input",$bind(this,this.handleInputEvent),true);
+				HTML5Window.textInput.addEventListener("blur",$bind(this,this.handleFocusEvent),true);
+				HTML5Window.textInput.addEventListener("cut",$bind(this,this.handleCutOrCopyEvent),true);
+				HTML5Window.textInput.addEventListener("copy",$bind(this,this.handleCutOrCopyEvent),true);
+				HTML5Window.textInput.addEventListener("paste",$bind(this,this.handlePasteEvent),true);
+			}
+			HTML5Window.textInput.focus();
+			HTML5Window.textInput.select();
+		} else if(HTML5Window.textInput != null) {
+			HTML5Window.textInput.removeEventListener("input",$bind(this,this.handleInputEvent),true);
+			HTML5Window.textInput.removeEventListener("blur",$bind(this,this.handleFocusEvent),true);
+			HTML5Window.textInput.removeEventListener("cut",$bind(this,this.handleCutOrCopyEvent),true);
+			HTML5Window.textInput.removeEventListener("copy",$bind(this,this.handleCutOrCopyEvent),true);
+			HTML5Window.textInput.removeEventListener("paste",$bind(this,this.handlePasteEvent),true);
+			HTML5Window.textInput.blur();
+		}
+		return this.enableTextEvents = value;
+	},
+	setFullscreen: function(value) {
+		if(value) {
+			if(!this.requestedFullscreen && !this.isFullscreen) {
+				this.requestedFullscreen = true;
+				if(($_=this.element,$bind($_,$_.requestFullscreen))) {
+					document.addEventListener("fullscreenchange",$bind(this,this.handleFullscreenEvent),false);
+					document.addEventListener("fullscreenerror",$bind(this,this.handleFullscreenEvent),false);
+					this.element.requestFullscreen();
+				} else if(this.element.mozRequestFullScreen) {
+					document.addEventListener("mozfullscreenchange",$bind(this,this.handleFullscreenEvent),false);
+					document.addEventListener("mozfullscreenerror",$bind(this,this.handleFullscreenEvent),false);
+					this.element.mozRequestFullScreen();
+				} else if(this.element.webkitRequestFullscreen) {
+					document.addEventListener("webkitfullscreenchange",$bind(this,this.handleFullscreenEvent),false);
+					document.addEventListener("webkitfullscreenerror",$bind(this,this.handleFullscreenEvent),false);
+					this.element.webkitRequestFullscreen();
+				} else if(this.element.msRequestFullscreen) {
+					document.addEventListener("MSFullscreenChange",$bind(this,this.handleFullscreenEvent),false);
+					document.addEventListener("MSFullscreenError",$bind(this,this.handleFullscreenEvent),false);
+					this.element.msRequestFullscreen();
+				}
+			}
+		} else if(this.isFullscreen) {
+			this.requestedFullscreen = false;
+			if(document.exitFullscreen) {
+				document.exitFullscreen();
+			} else if(document.mozCancelFullScreen) {
+				document.mozCancelFullScreen();
+			} else if(document.webkitExitFullscreen) {
+				document.webkitExitFullscreen();
+			} else if(document.msExitFullscreen) {
+				document.msExitFullscreen();
+			}
+		}
+		return value;
+	},
+	setIcon: function(image) {
+		(lime_graphics_utils_ImageCanvasUtil().default).convertToCanvas(image);
+		var link = (js_Browser().default).get_document().querySelector("link[rel*='icon']");
+		if(link == null) {
+			link = (js_Browser().default).get_document().createElement("link");
+		}
+		link.type = "image/x-icon";
+		link.rel = "shortcut icon";
+		link.href = image.buffer.get_src().toDataURL("image/x-icon");
+		(js_Browser().default).get_document().getElementsByTagName("head")[0].appendChild(link);
+	},
+	setMaximized: function(value) {
+		return false;
+	},
+	setMinimized: function(value) {
+		return false;
+	},
+	setResizable: function(value) {
+		return value;
+	},
+	setTitle: function(value) {
+		if(value != null) {
+			(js_Browser().default).get_document().title = value;
+		}
+		return value;
+	},
+	updateSize: function() {
+		if(!this.parent.__resizable) {
+			return;
+		}
+		var elementWidth;
+		var elementHeight;
+		if(this.element != null) {
+			elementWidth = this.element.clientWidth;
+			elementHeight = this.element.clientHeight;
+		} else {
+			elementWidth = (js_Browser().default).get_window().innerWidth;
+			elementHeight = (js_Browser().default).get_window().innerHeight;
+		}
+		if(elementWidth != this.cacheElementWidth || elementHeight != this.cacheElementHeight) {
+			this.cacheElementWidth = elementWidth;
+			this.cacheElementHeight = elementHeight;
+			var stretch = this.resizeElement || this.setWidth == 0 && this.setHeight == 0;
+			if(this.element != null && (this.div == null || this.div != null && stretch)) {
+				if(stretch) {
+					if(this.parent.get_width() != elementWidth || this.parent.get_height() != elementHeight) {
+						this.parent.set_width(elementWidth);
+						this.parent.set_height(elementHeight);
+						if(this.canvas != null) {
+							if(this.element != this.canvas) {
+								this.canvas.width = Math.round(elementWidth * this.scale);
+								this.canvas.height = Math.round(elementHeight * this.scale);
+								this.canvas.style.width = elementWidth + "px";
+								this.canvas.style.height = elementHeight + "px";
+							}
+						} else {
+							this.div.style.width = elementWidth + "px";
+							this.div.style.height = elementHeight + "px";
+						}
+						this.parent.onResize.dispatch(elementWidth,elementHeight);
+					}
+				} else {
+					var scaleX = this.setWidth != 0 ? elementWidth / this.setWidth : 1;
+					var scaleY = this.setHeight != 0 ? elementHeight / this.setHeight : 1;
+					var targetWidth = elementWidth;
+					var targetHeight = elementHeight;
+					var marginLeft = 0;
+					var marginTop = 0;
+					if(scaleX < scaleY) {
+						targetHeight = Math.floor(this.setHeight * scaleX);
+						marginTop = Math.floor((elementHeight - targetHeight) / 2);
+					} else {
+						targetWidth = Math.floor(this.setWidth * scaleY);
+						marginLeft = Math.floor((elementWidth - targetWidth) / 2);
+					}
+					if(this.canvas != null) {
+						if(this.element != this.canvas) {
+							this.canvas.style.width = targetWidth + "px";
+							this.canvas.style.height = targetHeight + "px";
+							this.canvas.style.marginLeft = marginLeft + "px";
+							this.canvas.style.marginTop = marginTop + "px";
+						}
+					} else {
+						this.div.style.width = targetWidth + "px";
+						this.div.style.height = targetHeight + "px";
+						this.div.style.marginLeft = marginLeft + "px";
+						this.div.style.marginTop = marginTop + "px";
+					}
+				}
+			}
+		}
+	}
+};
+HTML5Window.prototype.__class__ = $hxClasses["lime._backend.html5.HTML5Window"] = HTML5Window;
+
+// Init
+
+
+
+// Statics
+
+
+HTML5Window.dummyCharacter = ""
+HTML5Window.windowID = 0
+
+// Export
+
+exports.default = HTML5Window;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Application.js

@@ -0,0 +1,204 @@
+// Class: lime.app.Application
+
+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;
+function lime_app_Module() {return require("./../../lime/app/Module");}
+function Reflect() {return require("./../../Reflect");}
+function lime_ui_Window() {return require("./../../lime/ui/Window");}
+function lime_graphics_Renderer() {return require("./../../lime/graphics/Renderer");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function lime_system_System() {return require("./../../lime/system/System");}
+function lime_app__$Event_$Int_$Void() {return require("./../../lime/app/_Event_Int_Void");}
+function haxe_ds_IntMap() {return require("./../../haxe/ds/IntMap");}
+function lime__$backend_html5_HTML5Application() {return require("./../../lime/_backend/html5/HTML5Application");}
+
+// Constructor
+
+var Application = function() {
+	this.onUpdate = new (lime_app__$Event_$Int_$Void().default)();
+	(lime_app_Module().default).call(this);
+	if(Application.current == null) {
+		Application.current = this;
+	}
+	this.modules = [];
+	this.windowByID = new (haxe_ds_IntMap().default)();
+	this.backend = new (lime__$backend_html5_HTML5Application().default)(this);
+	this.registerModule(this);
+}
+
+// Meta
+
+Application.__name__ = ["lime","app","Application"];
+Application.__super__ = (lime_app_Module().default);
+Application.prototype = $extend((lime_app_Module().default).prototype, {
+	addModule: function(module) {
+		module.registerModule(this);
+		this.modules.push(module);
+		if(this.__renderers.length > 0) {
+			var _g = 0;
+			var _g1 = this.__renderers;
+			while(_g < _g1.length) {
+				var renderer = _g1[_g];
+				++_g;
+				module.addRenderer(renderer);
+			}
+		}
+		if(this.__windows.length > 0) {
+			var _g2 = 0;
+			var _g11 = this.__windows;
+			while(_g2 < _g11.length) {
+				var $window = _g11[_g2];
+				++_g2;
+				module.addWindow($window);
+			}
+		}
+		module.setPreloader(this.__preloader);
+	},
+	addRenderer: function(renderer) {
+		(lime_app_Module().default).prototype.addRenderer.call(this,renderer);
+		var _g = 0;
+		var _g1 = this.modules;
+		while(_g < _g1.length) {
+			var module = _g1[_g];
+			++_g;
+			module.addRenderer(renderer);
+		}
+	},
+	create: function(config) {
+		this.config = config;
+		this.backend.create(config);
+		if(config != null) {
+			if((Reflect().default).hasField(config,"fps")) {
+				this.set_frameRate(config.fps);
+			}
+			if((Reflect().default).hasField(config,"windows")) {
+				var _g = 0;
+				var _g1 = config.windows;
+				while(_g < _g1.length) {
+					var windowConfig = _g1[_g];
+					++_g;
+					var $window = new (lime_ui_Window().default)(windowConfig);
+					this.createWindow($window);
+					break;
+				}
+			}
+			if(this.__preloader == null || this.__preloader.complete) {
+				this.setPreloader(this.__preloader);
+				var _g2 = 0;
+				var _g11 = this.modules;
+				while(_g2 < _g11.length) {
+					var module = _g11[_g2];
+					++_g2;
+					this.setPreloader(this.__preloader);
+				}
+			}
+		}
+	},
+	createWindow: function(window) {
+		(lime_app_Module().default).prototype.addWindow.call(this,window);
+		var _g = 0;
+		var _g1 = this.modules;
+		while(_g < _g1.length) {
+			var module = _g1[_g];
+			++_g;
+			module.addWindow(window);
+		}
+		if(window.renderer == null) {
+			var renderer = new (lime_graphics_Renderer().default)(window);
+			this.addRenderer(renderer);
+		}
+		window.create(this);
+		this.windowByID.set(window.id,window);
+		window.onCreate.dispatch();
+	},
+	exec: function() {
+		Application.current = this;
+		return this.backend.exec();
+	},
+	onModuleExit: function(code) {
+		this.backend.exit();
+	},
+	onWindowClose: function(window) {
+		this.removeWindow(window);
+	},
+	removeModule: function(module) {
+		if(module != null) {
+			module.unregisterModule(this);
+			(HxOverrides().default).remove(this.modules,module);
+		}
+	},
+	removeWindow: function(window) {
+		if(window != null && this.windowByID.exists(window.id)) {
+			(HxOverrides().default).remove(this.__windows,window);
+			this.windowByID.remove(window.id);
+			window.close();
+			if(window.renderer != null) {
+				this.removeRenderer(window.renderer);
+			}
+			if(this.get_window() == window) {
+				this.window = null;
+			}
+			if(this.__windows.length == 0) {
+				(lime_system_System().default).exit(0);
+			}
+		}
+	},
+	setPreloader: function(preloader) {
+		(lime_app_Module().default).prototype.setPreloader.call(this,preloader);
+		var _g = 0;
+		var _g1 = this.modules;
+		while(_g < _g1.length) {
+			var module = _g1[_g];
+			++_g;
+			module.setPreloader(preloader);
+		}
+	},
+	get_frameRate: function() {
+		return this.backend.getFrameRate();
+	},
+	set_frameRate: function(value) {
+		return this.backend.setFrameRate(value);
+	},
+	get_preloader: function() {
+		return this.__preloader;
+	},
+	get_renderer: function() {
+		return this.__renderers[0];
+	},
+	get_renderers: function() {
+		return this.__renderers;
+	},
+	get_window: function() {
+		return this.__windows[0];
+	},
+	get_windows: function() {
+		return this.__windows;
+	}
+});
+Application.prototype.__class__ = $hxClasses["lime.app.Application"] = Application;
+
+// Init
+
+{
+	var init = (lime__$backend_html5_HTML5Application().default)
+	var p = Application.prototype;
+	Object.defineProperties(p,{ "frameRate" : { get : p.get_frameRate, set : p.set_frameRate}, "preloader" : { get : p.get_preloader}, "renderer" : { get : p.get_renderer}, "renderers" : { get : p.get_renderers}, "window" : { get : p.get_window}, "windows" : { get : p.get_windows}});
+};
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Application;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Event.js

@@ -0,0 +1,87 @@
+// Class: lime.app.Event
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var Event = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+Event.__name__ = ["lime","app","Event"];
+Event.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	}
+};
+Event.prototype.__class__ = $hxClasses["lime.app.Event"] = Event;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Event;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Future.js

@@ -0,0 +1,165 @@
+// Class: lime.app.Future
+
+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 $bind = require("./../../bind_stub").default;
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+function lime_app_Promise() {return require("./../../lime/app/Promise");}
+function lime_app__$Future_FutureWork() {return require("./../../lime/app/_Future/FutureWork");}
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Future = function(work,async) {
+	if(async == null) {
+		async = false;
+	}
+	if(work != null) {
+		if(async) {
+			var promise = new (lime_app_Promise().default)();
+			promise.future = this;
+			(lime_app__$Future_FutureWork().default).queue({ promise : promise, work : work});
+		} else {
+			try {
+				this.value = work();
+				this.isComplete = true;
+			} catch( e ) {
+				if (e instanceof (js__$Boot_HaxeError().default)) e = e.val;
+				this.error = e;
+				this.isError = true;
+			}
+		}
+	}
+}
+
+// Meta
+
+Future.__name__ = ["lime","app","Future"];
+Future.prototype = {
+	onComplete: function(listener) {
+		if(listener != null) {
+			if(this.isComplete) {
+				listener(this.value);
+			} else if(!this.isError) {
+				if(this.__completeListeners == null) {
+					this.__completeListeners = [];
+				}
+				this.__completeListeners.push(listener);
+			}
+		}
+		return this;
+	},
+	onError: function(listener) {
+		if(listener != null) {
+			if(this.isError) {
+				listener(this.error);
+			} else if(!this.isComplete) {
+				if(this.__errorListeners == null) {
+					this.__errorListeners = [];
+				}
+				this.__errorListeners.push(listener);
+			}
+		}
+		return this;
+	},
+	onProgress: function(listener) {
+		if(listener != null) {
+			if(this.__progressListeners == null) {
+				this.__progressListeners = [];
+			}
+			this.__progressListeners.push(listener);
+		}
+		return this;
+	},
+	ready: function(waitTime) {
+		if(waitTime == null) {
+			waitTime = -1;
+		}
+		if(this.isComplete || this.isError) {
+			return this;
+		} else {
+			(lime_utils_Log().default).warn("Cannot block thread in JavaScript",{ fileName : "Future.hx", lineNumber : 157, className : "lime.app.Future", methodName : "ready"});
+			return this;
+		}
+	},
+	result: function(waitTime) {
+		if(waitTime == null) {
+			waitTime = -1;
+		}
+		this.ready(waitTime);
+		if(this.isComplete) {
+			return this.value;
+		} else {
+			return null;
+		}
+	},
+	then: function(next) {
+		if(this.isComplete) {
+			return next(this.value);
+		} else if(this.isError) {
+			var future = new Future();
+			future.onError(this.error);
+			return future;
+		} else {
+			var promise = new (lime_app_Promise().default)();
+			this.onError($bind(promise,promise.error));
+			this.onProgress($bind(promise,promise.progress));
+			this.onComplete(function(val) {
+				var future1 = next(val);
+				future1.onError($bind(promise,promise.error));
+				future1.onComplete($bind(promise,promise.complete));
+			});
+			return promise.future;
+		}
+	}
+};
+Future.prototype.__class__ = $hxClasses["lime.app.Future"] = Future;
+
+// Init
+
+
+
+// Statics
+
+Future.ofEvents = function(onComplete,onError,onProgress) {
+	var promise = new (lime_app_Promise().default)();
+	onComplete.add(function(data) {
+		promise.complete(data);
+	},true);
+	if(onError != null) {
+		onError.add(function(error) {
+			promise.error(error);
+		},true);
+	}
+	if(onProgress != null) {
+		onProgress.add(function(progress,total) {
+			promise.progress(progress,total);
+		},true);
+	}
+	return promise.future;
+}
+Future.withError = function(error) {
+	var future = new Future();
+	future.isError = true;
+	future.error = error;
+	return future;
+}
+Future.withValue = function(value) {
+	var future = new Future();
+	future.isComplete = true;
+	future.value = value;
+	return future;
+}
+
+
+// Export
+
+exports.default = Future;

hGameTest/node_modules/openfl/lib/_gen/lime/app/IModule.js

@@ -0,0 +1,36 @@
+// Class: lime.app.IModule
+
+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 IModule = function() {}
+
+// Meta
+
+IModule.__name__ = ["lime","app","IModule"];
+IModule.prototype = {
+	
+};
+IModule.prototype.__class__ = $hxClasses["lime.app.IModule"] = IModule;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = IModule;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Module.js

@@ -0,0 +1,430 @@
+// Class: lime.app.Module
+
+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 $bind = require("./../../bind_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_app_IModule() {return require("./../../lime/app/IModule");}
+function lime_ui_Gamepad() {return require("./../../lime/ui/Gamepad");}
+function lime_ui_Joystick() {return require("./../../lime/ui/Joystick");}
+function lime_ui_Touch() {return require("./../../lime/ui/Touch");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function lime_app__$Event_$Int_$Void() {return require("./../../lime/app/_Event_Int_Void");}
+
+// Constructor
+
+var Module = function() {
+	this.onExit = new (lime_app__$Event_$Int_$Void().default)();
+	this.__renderers = [];
+	this.__windows = [];
+}
+
+// Meta
+
+Module.__name__ = ["lime","app","Module"];
+Module.__interfaces__ = [(lime_app_IModule().default)];
+Module.prototype = {
+	addRenderer: function(renderer) {
+		var f = $bind(this,this.render);
+		var a1 = renderer;
+		var tmp = function() {
+			f(a1);
+		};
+		renderer.onRender.add(tmp);
+		var f1 = $bind(this,this.onRenderContextLost);
+		var a11 = renderer;
+		var tmp1 = function() {
+			f1(a11);
+		};
+		renderer.onContextLost.add(tmp1);
+		var f2 = $bind(this,this.onRenderContextRestored);
+		var a12 = renderer;
+		var tmp2 = function(a2) {
+			f2(a12,a2);
+		};
+		renderer.onContextRestored.add(tmp2);
+		this.__renderers.push(renderer);
+	},
+	addWindow: function(window) {
+		var f = $bind(this,this.onWindowActivate);
+		var a1 = window;
+		var tmp = function() {
+			f(a1);
+		};
+		window.onActivate.add(tmp);
+		var f1 = $bind(this,this.__onWindowClose);
+		var a11 = window;
+		var tmp1 = function() {
+			f1(a11);
+		};
+		window.onClose.add(tmp1,false,-10000);
+		var f2 = $bind(this,this.onWindowCreate);
+		var a12 = window;
+		var tmp2 = function() {
+			f2(a12);
+		};
+		window.onCreate.add(tmp2);
+		var f3 = $bind(this,this.onWindowDeactivate);
+		var a13 = window;
+		var tmp3 = function() {
+			f3(a13);
+		};
+		window.onDeactivate.add(tmp3);
+		var f4 = $bind(this,this.onWindowDropFile);
+		var a14 = window;
+		var tmp4 = function(a2) {
+			f4(a14,a2);
+		};
+		window.onDropFile.add(tmp4);
+		var f5 = $bind(this,this.onWindowEnter);
+		var a15 = window;
+		var tmp5 = function() {
+			f5(a15);
+		};
+		window.onEnter.add(tmp5);
+		var f6 = $bind(this,this.onWindowFocusIn);
+		var a16 = window;
+		var tmp6 = function() {
+			f6(a16);
+		};
+		window.onFocusIn.add(tmp6);
+		var f7 = $bind(this,this.onWindowFocusOut);
+		var a17 = window;
+		var tmp7 = function() {
+			f7(a17);
+		};
+		window.onFocusOut.add(tmp7);
+		var f8 = $bind(this,this.onWindowFullscreen);
+		var a18 = window;
+		var tmp8 = function() {
+			f8(a18);
+		};
+		window.onFullscreen.add(tmp8);
+		var f9 = $bind(this,this.onKeyDown);
+		var a19 = window;
+		var tmp9 = function(a21,a3) {
+			f9(a19,a21,a3);
+		};
+		window.onKeyDown.add(tmp9);
+		var f10 = $bind(this,this.onKeyUp);
+		var a110 = window;
+		var tmp10 = function(a22,a31) {
+			f10(a110,a22,a31);
+		};
+		window.onKeyUp.add(tmp10);
+		var f11 = $bind(this,this.onWindowLeave);
+		var a111 = window;
+		var tmp11 = function() {
+			f11(a111);
+		};
+		window.onLeave.add(tmp11);
+		var f12 = $bind(this,this.onWindowMinimize);
+		var a112 = window;
+		var tmp12 = function() {
+			f12(a112);
+		};
+		window.onMinimize.add(tmp12);
+		var f13 = $bind(this,this.onMouseDown);
+		var a113 = window;
+		var tmp13 = function(x,y,a23) {
+			f13(a113,x,y,a23);
+		};
+		window.onMouseDown.add(tmp13);
+		var f14 = $bind(this,this.onMouseMove);
+		var a114 = window;
+		var tmp14 = function(x1,y1) {
+			f14(a114,x1,y1);
+		};
+		window.onMouseMove.add(tmp14);
+		var f15 = $bind(this,this.onMouseMoveRelative);
+		var a115 = window;
+		var tmp15 = function(x2,y2) {
+			f15(a115,x2,y2);
+		};
+		window.onMouseMoveRelative.add(tmp15);
+		var f16 = $bind(this,this.onMouseUp);
+		var a116 = window;
+		var tmp16 = function(x3,y3,a24) {
+			f16(a116,x3,y3,a24);
+		};
+		window.onMouseUp.add(tmp16);
+		var f17 = $bind(this,this.onMouseWheel);
+		var a117 = window;
+		var tmp17 = function(a25,a32) {
+			f17(a117,a25,a32);
+		};
+		window.onMouseWheel.add(tmp17);
+		var f18 = $bind(this,this.onWindowMove);
+		var a118 = window;
+		var tmp18 = function(x4,y4) {
+			f18(a118,x4,y4);
+		};
+		window.onMove.add(tmp18);
+		var f19 = $bind(this,this.onWindowResize);
+		var a119 = window;
+		var tmp19 = function(a26,a33) {
+			f19(a119,a26,a33);
+		};
+		window.onResize.add(tmp19);
+		var f20 = $bind(this,this.onWindowRestore);
+		var a120 = window;
+		var tmp20 = function() {
+			f20(a120);
+		};
+		window.onRestore.add(tmp20);
+		var f21 = $bind(this,this.onTextEdit);
+		var a121 = window;
+		var tmp21 = function(a27,a34,a4) {
+			f21(a121,a27,a34,a4);
+		};
+		window.onTextEdit.add(tmp21);
+		var f22 = $bind(this,this.onTextInput);
+		var a122 = window;
+		var tmp22 = function(a28) {
+			f22(a122,a28);
+		};
+		window.onTextInput.add(tmp22);
+		if(window.id > -1) {
+			this.onWindowCreate(window);
+		}
+		this.__windows.push(window);
+	},
+	registerModule: function(application) {
+		this.__application = application;
+		application.onExit.add($bind(this,this.onModuleExit),false,0);
+		application.onUpdate.add($bind(this,this.update));
+		var gamepad = (lime_ui_Gamepad().default).devices.iterator();
+		while(gamepad.hasNext()) {
+			var gamepad1 = gamepad.next();
+			this.__onGamepadConnect(gamepad1);
+		}
+		(lime_ui_Gamepad().default).onConnect.add($bind(this,this.__onGamepadConnect));
+		var joystick = (lime_ui_Joystick().default).devices.iterator();
+		while(joystick.hasNext()) {
+			var joystick1 = joystick.next();
+			this.__onJoystickConnect(joystick1);
+		}
+		(lime_ui_Joystick().default).onConnect.add($bind(this,this.__onJoystickConnect));
+		(lime_ui_Touch().default).onCancel.add($bind(this,this.onTouchCancel));
+		(lime_ui_Touch().default).onStart.add($bind(this,this.onTouchStart));
+		(lime_ui_Touch().default).onMove.add($bind(this,this.onTouchMove));
+		(lime_ui_Touch().default).onEnd.add($bind(this,this.onTouchEnd));
+	},
+	removeRenderer: function(renderer) {
+		if(renderer != null && this.__renderers.indexOf(renderer) > -1) {
+			(HxOverrides().default).remove(this.__renderers,renderer);
+		}
+	},
+	removeWindow: function(window) {
+		if(window != null && this.__windows.indexOf(window) > -1) {
+			(HxOverrides().default).remove(this.__windows,window);
+		}
+	},
+	setPreloader: function(preloader) {
+		if(this.__preloader != null) {
+			this.__preloader.onProgress.remove($bind(this,this.onPreloadProgress));
+			this.__preloader.onComplete.remove($bind(this,this.onPreloadComplete));
+		}
+		this.__preloader = preloader;
+		if(preloader == null || preloader.complete) {
+			this.onPreloadComplete();
+		} else {
+			preloader.onProgress.add($bind(this,this.onPreloadProgress));
+			preloader.onComplete.add($bind(this,this.onPreloadComplete));
+		}
+	},
+	unregisterModule: function(application) {
+		this.__application.onExit.remove($bind(this,this.onModuleExit));
+		this.__application.onUpdate.remove($bind(this,this.update));
+		(lime_ui_Gamepad().default).onConnect.remove($bind(this,this.__onGamepadConnect));
+		(lime_ui_Joystick().default).onConnect.remove($bind(this,this.__onJoystickConnect));
+		(lime_ui_Touch().default).onCancel.remove($bind(this,this.onTouchCancel));
+		(lime_ui_Touch().default).onStart.remove($bind(this,this.onTouchStart));
+		(lime_ui_Touch().default).onMove.remove($bind(this,this.onTouchMove));
+		(lime_ui_Touch().default).onEnd.remove($bind(this,this.onTouchEnd));
+		this.onModuleExit(0);
+	},
+	onGamepadAxisMove: function(gamepad,axis,value) {
+	},
+	onGamepadButtonDown: function(gamepad,button) {
+	},
+	onGamepadButtonUp: function(gamepad,button) {
+	},
+	onGamepadConnect: function(gamepad) {
+	},
+	onGamepadDisconnect: function(gamepad) {
+	},
+	onJoystickAxisMove: function(joystick,axis,value) {
+	},
+	onJoystickButtonDown: function(joystick,button) {
+	},
+	onJoystickButtonUp: function(joystick,button) {
+	},
+	onJoystickConnect: function(joystick) {
+	},
+	onJoystickDisconnect: function(joystick) {
+	},
+	onJoystickHatMove: function(joystick,hat,position) {
+	},
+	onJoystickTrackballMove: function(joystick,trackball,x,y) {
+	},
+	onKeyDown: function(window,keyCode,modifier) {
+	},
+	onKeyUp: function(window,keyCode,modifier) {
+	},
+	onModuleExit: function(code) {
+	},
+	onMouseDown: function(window,x,y,button) {
+	},
+	onMouseMove: function(window,x,y) {
+	},
+	onMouseMoveRelative: function(window,x,y) {
+	},
+	onMouseUp: function(window,x,y,button) {
+	},
+	onMouseWheel: function(window,deltaX,deltaY) {
+	},
+	onPreloadComplete: function() {
+	},
+	onPreloadProgress: function(loaded,total) {
+	},
+	onRenderContextLost: function(renderer) {
+	},
+	onRenderContextRestored: function(renderer,context) {
+	},
+	onTextEdit: function(window,text,start,length) {
+	},
+	onTextInput: function(window,text) {
+	},
+	onTouchCancel: function(touch) {
+	},
+	onTouchEnd: function(touch) {
+	},
+	onTouchMove: function(touch) {
+	},
+	onTouchStart: function(touch) {
+	},
+	onWindowActivate: function(window) {
+	},
+	onWindowClose: function(window) {
+	},
+	onWindowCreate: function(window) {
+	},
+	onWindowDeactivate: function(window) {
+	},
+	onWindowDropFile: function(window,file) {
+	},
+	onWindowEnter: function(window) {
+	},
+	onWindowFocusIn: function(window) {
+	},
+	onWindowFocusOut: function(window) {
+	},
+	onWindowFullscreen: function(window) {
+	},
+	onWindowLeave: function(window) {
+	},
+	onWindowMove: function(window,x,y) {
+	},
+	onWindowMinimize: function(window) {
+	},
+	onWindowResize: function(window,width,height) {
+	},
+	onWindowRestore: function(window) {
+	},
+	render: function(renderer) {
+	},
+	update: function(deltaTime) {
+	},
+	__onGamepadConnect: function(gamepad) {
+		this.onGamepadConnect(gamepad);
+		var f = $bind(this,this.onGamepadAxisMove);
+		var a1 = gamepad;
+		var tmp = function(a2,a3) {
+			f(a1,a2,a3);
+		};
+		gamepad.onAxisMove.add(tmp);
+		var f1 = $bind(this,this.onGamepadButtonDown);
+		var a11 = gamepad;
+		var tmp1 = function(a21) {
+			f1(a11,a21);
+		};
+		gamepad.onButtonDown.add(tmp1);
+		var f2 = $bind(this,this.onGamepadButtonUp);
+		var a12 = gamepad;
+		var tmp2 = function(a22) {
+			f2(a12,a22);
+		};
+		gamepad.onButtonUp.add(tmp2);
+		var f3 = $bind(this,this.onGamepadDisconnect);
+		var a13 = gamepad;
+		var tmp3 = function() {
+			f3(a13);
+		};
+		gamepad.onDisconnect.add(tmp3);
+	},
+	__onJoystickConnect: function(joystick) {
+		this.onJoystickConnect(joystick);
+		var f = $bind(this,this.onJoystickAxisMove);
+		var a1 = joystick;
+		var tmp = function(a2,a3) {
+			f(a1,a2,a3);
+		};
+		joystick.onAxisMove.add(tmp);
+		var f1 = $bind(this,this.onJoystickButtonDown);
+		var a11 = joystick;
+		var tmp1 = function(a21) {
+			f1(a11,a21);
+		};
+		joystick.onButtonDown.add(tmp1);
+		var f2 = $bind(this,this.onJoystickButtonUp);
+		var a12 = joystick;
+		var tmp2 = function(a22) {
+			f2(a12,a22);
+		};
+		joystick.onButtonUp.add(tmp2);
+		var f3 = $bind(this,this.onJoystickDisconnect);
+		var a13 = joystick;
+		var tmp3 = function() {
+			f3(a13);
+		};
+		joystick.onDisconnect.add(tmp3);
+		var f4 = $bind(this,this.onJoystickHatMove);
+		var a14 = joystick;
+		var tmp4 = function(a23,a31) {
+			f4(a14,a23,a31);
+		};
+		joystick.onHatMove.add(tmp4);
+		var f5 = $bind(this,this.onJoystickTrackballMove);
+		var a15 = joystick;
+		var tmp5 = function(a24,x,y) {
+			f5(a15,a24,x,y);
+		};
+		joystick.onTrackballMove.add(tmp5);
+	},
+	__onWindowClose: function(window) {
+		this.onWindowClose(window);
+		(HxOverrides().default).remove(this.__windows,window);
+	}
+};
+Module.prototype.__class__ = $hxClasses["lime.app.Module"] = Module;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Module;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Preloader.js

@@ -0,0 +1,204 @@
+// Class: lime.app.Preloader
+
+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 $bind = require("./../../bind_stub").default;
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+function lime_utils_Assets() {return require("./../../lime/utils/Assets");}
+function haxe_ds_StringMap() {return require("./../../haxe/ds/StringMap");}
+function haxe_ds_ObjectMap() {return require("./../../haxe/ds/ObjectMap");}
+function lime_app__$Event_$Int_$Int_$Void() {return require("./../../lime/app/_Event_Int_Int_Void");}
+function lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+
+// Constructor
+
+var Preloader = function() {
+	this.bytesTotalCache = new (haxe_ds_StringMap().default)();
+	this.bytesLoadedCache2 = new (haxe_ds_StringMap().default)();
+	this.bytesLoadedCache = new (haxe_ds_ObjectMap().default)();
+	this.onProgress = new (lime_app__$Event_$Int_$Int_$Void().default)();
+	this.onComplete = new (lime_app__$Event_$Void_$Void().default)();
+	this.bytesLoaded = 0;
+	this.bytesTotal = 0;
+	this.libraries = [];
+	this.libraryNames = [];
+	this.onProgress.add($bind(this,this.update));
+}
+
+// Meta
+
+Preloader.__name__ = ["lime","app","Preloader"];
+Preloader.prototype = {
+	addLibrary: function(library) {
+		this.libraries.push(library);
+	},
+	addLibraryName: function(name) {
+		if(this.libraryNames.indexOf(name) == -1) {
+			this.libraryNames.push(name);
+		}
+	},
+	create: function(config) {
+	},
+	load: function() {
+		var _gthis = this;
+		var _g = 0;
+		var _g1 = this.libraries;
+		while(_g < _g1.length) {
+			var library = _g1[_g];
+			++_g;
+			this.bytesTotal += library.bytesTotal;
+		}
+		this.loadedLibraries = -1;
+		this.preloadStarted = false;
+		var _g2 = 0;
+		var _g11 = this.libraries;
+		while(_g2 < _g11.length) {
+			var library1 = [_g11[_g2]];
+			++_g2;
+			(lime_utils_Log().default).verbose("Preloading asset library",{ fileName : "Preloader.hx", lineNumber : 153, className : "lime.app.Preloader", methodName : "load"});
+			library1[0].load().onProgress((function(library2) {
+				return function(loaded,total) {
+					if(!_gthis.bytesLoadedCache.exists(library2[0])) {
+						_gthis.bytesLoaded += loaded;
+					} else {
+						_gthis.bytesLoaded += loaded - _gthis.bytesLoadedCache.get(library2[0]);
+					}
+					_gthis.bytesLoadedCache.set(library2[0],loaded);
+					if(!_gthis.simulateProgress) {
+						_gthis.onProgress.dispatch(_gthis.bytesLoaded,_gthis.bytesTotal);
+					}
+				};
+			})(library1)).onComplete((function(library3) {
+				return function(_) {
+					if(!_gthis.bytesLoadedCache.exists(library3[0])) {
+						_gthis.bytesLoaded += library3[0].bytesTotal;
+					} else {
+						_gthis.bytesLoaded += library3[0].bytesTotal - _gthis.bytesLoadedCache.get(library3[0]);
+					}
+					_gthis.loadedAssetLibrary();
+				};
+			})(library1)).onError((function() {
+				return function(e) {
+					(lime_utils_Log().default).error(e,{ fileName : "Preloader.hx", lineNumber : 191, className : "lime.app.Preloader", methodName : "load"});
+				};
+			})());
+		}
+		var _g3 = 0;
+		var _g12 = this.libraryNames;
+		while(_g3 < _g12.length) {
+			var name = _g12[_g3];
+			++_g3;
+			this.bytesTotal += 200;
+		}
+		this.loadedLibraries++;
+		this.preloadStarted = true;
+		this.updateProgress();
+	},
+	loadedAssetLibrary: function(name) {
+		this.loadedLibraries++;
+		var current = this.loadedLibraries;
+		if(!this.preloadStarted) {
+			++current;
+		}
+		var totalLibraries = this.libraries.length + this.libraryNames.length;
+		if(name != null) {
+			(lime_utils_Log().default).verbose("Loaded asset library: " + name + " [" + current + "/" + totalLibraries + "]",{ fileName : "Preloader.hx", lineNumber : 223, className : "lime.app.Preloader", methodName : "loadedAssetLibrary"});
+		} else {
+			(lime_utils_Log().default).verbose("Loaded asset library [" + current + "/" + totalLibraries + "]",{ fileName : "Preloader.hx", lineNumber : 227, className : "lime.app.Preloader", methodName : "loadedAssetLibrary"});
+		}
+		this.updateProgress();
+	},
+	start: function() {
+		if(this.complete) {
+			return;
+		}
+		this.complete = true;
+		this.onComplete.dispatch();
+	},
+	update: function(loaded,total) {
+	},
+	updateProgress: function() {
+		var _gthis = this;
+		if(!this.simulateProgress) {
+			this.onProgress.dispatch(this.bytesLoaded,this.bytesTotal);
+		}
+		if(this.loadedLibraries == this.libraries.length && !this.initLibraryNames) {
+			this.initLibraryNames = true;
+			var _g = 0;
+			var _g1 = this.libraryNames;
+			while(_g < _g1.length) {
+				var name = [_g1[_g]];
+				++_g;
+				(lime_utils_Log().default).verbose("Preloading asset library: " + name[0],{ fileName : "Preloader.hx", lineNumber : 276, className : "lime.app.Preloader", methodName : "updateProgress"});
+				(lime_utils_Assets().default).loadLibrary(name[0]).onProgress((function(name1) {
+					return function(loaded,total) {
+						if(total > 0) {
+							if(!_gthis.bytesTotalCache.exists(name1[0])) {
+								_gthis.bytesTotalCache.set(name1[0],total);
+								_gthis.bytesTotal += total - 200;
+							}
+							if(loaded > total) {
+								loaded = total;
+							}
+							if(!_gthis.bytesLoadedCache2.exists(name1[0])) {
+								_gthis.bytesLoaded += loaded;
+							} else {
+								_gthis.bytesLoaded += loaded - _gthis.bytesLoadedCache2.get(name1[0]);
+							}
+							_gthis.bytesLoadedCache2.set(name1[0],loaded);
+							if(!_gthis.simulateProgress) {
+								_gthis.onProgress.dispatch(_gthis.bytesLoaded,_gthis.bytesTotal);
+							}
+						}
+					};
+				})(name)).onComplete((function(name2) {
+					return function(library) {
+						var total1 = 200;
+						if(_gthis.bytesTotalCache.exists(name2[0])) {
+							total1 = _gthis.bytesTotalCache.get(name2[0]);
+						}
+						if(!_gthis.bytesLoadedCache2.exists(name2[0])) {
+							_gthis.bytesLoaded += total1;
+						} else {
+							_gthis.bytesLoaded += total1 - _gthis.bytesLoadedCache2.get(name2[0]);
+						}
+						_gthis.loadedAssetLibrary(name2[0]);
+					};
+				})(name)).onError((function() {
+					return function(e) {
+						(lime_utils_Log().default).error(e,{ fileName : "Preloader.hx", lineNumber : 335, className : "lime.app.Preloader", methodName : "updateProgress"});
+					};
+				})());
+			}
+		}
+		if(!this.simulateProgress && this.loadedLibraries == this.libraries.length + this.libraryNames.length) {
+			if(!this.preloadComplete) {
+				this.preloadComplete = true;
+				(lime_utils_Log().default).verbose("Preload complete",{ fileName : "Preloader.hx", lineNumber : 349, className : "lime.app.Preloader", methodName : "updateProgress"});
+			}
+			this.start();
+		}
+	}
+};
+Preloader.prototype.__class__ = $hxClasses["lime.app.Preloader"] = Preloader;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Preloader;

hGameTest/node_modules/openfl/lib/_gen/lime/app/Promise.js

@@ -0,0 +1,103 @@
+// Class: lime.app.Promise
+
+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 $bind = require("./../../bind_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_app_Future() {return require("./../../lime/app/Future");}
+
+// Constructor
+
+var Promise = function() {
+	this.future = new (lime_app_Future().default)();
+}
+
+// Meta
+
+Promise.__name__ = ["lime","app","Promise"];
+Promise.prototype = {
+	complete: function(data) {
+		if(!this.future.isError) {
+			this.future.isComplete = true;
+			this.future.value = data;
+			if(this.future.__completeListeners != null) {
+				var _g = 0;
+				var _g1 = this.future.__completeListeners;
+				while(_g < _g1.length) {
+					var listener = _g1[_g];
+					++_g;
+					listener(data);
+				}
+				this.future.__completeListeners = null;
+			}
+		}
+		return this;
+	},
+	completeWith: function(future) {
+		future.onComplete($bind(this,this.complete));
+		future.onError($bind(this,this.error));
+		future.onProgress($bind(this,this.progress));
+		return this;
+	},
+	error: function(msg) {
+		if(!this.future.isComplete) {
+			this.future.isError = true;
+			this.future.error = msg;
+			if(this.future.__errorListeners != null) {
+				var _g = 0;
+				var _g1 = this.future.__errorListeners;
+				while(_g < _g1.length) {
+					var listener = _g1[_g];
+					++_g;
+					listener(msg);
+				}
+				this.future.__errorListeners = null;
+			}
+		}
+		return this;
+	},
+	progress: function(progress,total) {
+		if(!this.future.isError && !this.future.isComplete) {
+			if(this.future.__progressListeners != null) {
+				var _g = 0;
+				var _g1 = this.future.__progressListeners;
+				while(_g < _g1.length) {
+					var listener = _g1[_g];
+					++_g;
+					listener(progress,total);
+				}
+			}
+		}
+		return this;
+	},
+	get_isComplete: function() {
+		return this.future.isComplete;
+	},
+	get_isError: function() {
+		return this.future.isError;
+	}
+};
+Promise.prototype.__class__ = $hxClasses["lime.app.Promise"] = Promise;
+
+// Init
+
+{
+	var p = Promise.prototype;
+	Object.defineProperties(p,{ "isComplete" : { get : p.get_isComplete}, "isError" : { get : p.get_isError}});
+};
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Promise;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Array_String__Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Array_String__Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Array_String__Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Array_String__Void.__name__ = ["lime","app","_Event_Array_String__Void"];
+_Event_Array_String__Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Array_String__Void.prototype.__class__ = $hxClasses["lime.app._Event_Array_String__Void"] = _Event_Array_String__Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Array_String__Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Dynamic_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Dynamic_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Dynamic_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Dynamic_Void.__name__ = ["lime","app","_Event_Dynamic_Void"];
+_Event_Dynamic_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Dynamic_Void.prototype.__class__ = $hxClasses["lime.app._Event_Dynamic_Void"] = _Event_Dynamic_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Dynamic_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Float_Float_Float_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Float_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Float_Void.__name__ = ["lime","app","_Event_Float_Float_Float_Void"];
+_Event_Float_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Float_Void"] = _Event_Float_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Float_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Float_Float_Int_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Int_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Int_Void.__name__ = ["lime","app","_Event_Float_Float_Int_Void"];
+_Event_Float_Float_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Int_Void"] = _Event_Float_Float_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Int_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Float_Float_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Void.__name__ = ["lime","app","_Event_Float_Float_Void"];
+_Event_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Void"] = _Event_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Int_Float_Float_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Float_Float_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Float_Float_Void.__name__ = ["lime","app","_Event_Int_Float_Float_Void"];
+_Event_Int_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Float_Float_Void"] = _Event_Int_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Float_Float_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Int_Float_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Float_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Float_Void.__name__ = ["lime","app","_Event_Int_Float_Void"];
+_Event_Int_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Float_Void"] = _Event_Int_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Float_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Int_Int_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Int_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Int_Void.__name__ = ["lime","app","_Event_Int_Int_Void"];
+_Event_Int_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Int_Void"] = _Event_Int_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Int_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Int_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Void.__name__ = ["lime","app","_Event_Int_Void"];
+_Event_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Void"] = _Event_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Int_lime_ui_JoystickHatPosition_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_lime_ui_JoystickHatPosition_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_lime_ui_JoystickHatPosition_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_lime_ui_JoystickHatPosition_Void.__name__ = ["lime","app","_Event_Int_lime_ui_JoystickHatPosition_Void"];
+_Event_Int_lime_ui_JoystickHatPosition_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_lime_ui_JoystickHatPosition_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_lime_ui_JoystickHatPosition_Void"] = _Event_Int_lime_ui_JoystickHatPosition_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_lime_ui_JoystickHatPosition_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_String_Int_Int_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_String_Int_Int_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_String_Int_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_String_Int_Int_Void.__name__ = ["lime","app","_Event_String_Int_Int_Void"];
+_Event_String_Int_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_String_Int_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_String_Int_Int_Void"] = _Event_String_Int_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_String_Int_Int_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_String_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_String_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_String_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_String_Void.__name__ = ["lime","app","_Event_String_Void"];
+_Event_String_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_String_Void.prototype.__class__ = $hxClasses["lime.app._Event_String_Void"] = _Event_String_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_String_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_Void_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Void_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Void_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Void_Void.__name__ = ["lime","app","_Event_Void_Void"];
+_Event_Void_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function() {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i]();
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Void_Void.prototype.__class__ = $hxClasses["lime.app._Event_Void_Void"] = _Event_Void_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Void_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_haxe_Function_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_haxe_Function_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_haxe_Function_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_haxe_Function_Void.__name__ = ["lime","app","_Event_haxe_Function_Void"];
+_Event_haxe_Function_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_haxe_Function_Void.prototype.__class__ = $hxClasses["lime.app._Event_haxe_Function_Void"] = _Event_haxe_Function_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_haxe_Function_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_graphics_RenderContext_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_graphics_RenderContext_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_graphics_RenderContext_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_graphics_RenderContext_Void.__name__ = ["lime","app","_Event_lime_graphics_RenderContext_Void"];
+_Event_lime_graphics_RenderContext_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_graphics_RenderContext_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_graphics_RenderContext_Void"] = _Event_lime_graphics_RenderContext_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_graphics_RenderContext_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_GamepadAxis_Float_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_GamepadAxis_Float_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_GamepadAxis_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_GamepadAxis_Float_Void.__name__ = ["lime","app","_Event_lime_ui_GamepadAxis_Float_Void"];
+_Event_lime_ui_GamepadAxis_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_GamepadAxis_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_GamepadAxis_Float_Void"] = _Event_lime_ui_GamepadAxis_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_GamepadAxis_Float_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_GamepadButton_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_GamepadButton_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_GamepadButton_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_GamepadButton_Void.__name__ = ["lime","app","_Event_lime_ui_GamepadButton_Void"];
+_Event_lime_ui_GamepadButton_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_GamepadButton_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_GamepadButton_Void"] = _Event_lime_ui_GamepadButton_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_GamepadButton_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_Gamepad_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Gamepad_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Gamepad_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Gamepad_Void.__name__ = ["lime","app","_Event_lime_ui_Gamepad_Void"];
+_Event_lime_ui_Gamepad_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Gamepad_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Gamepad_Void"] = _Event_lime_ui_Gamepad_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Gamepad_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_Joystick_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Joystick_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Joystick_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Joystick_Void.__name__ = ["lime","app","_Event_lime_ui_Joystick_Void"];
+_Event_lime_ui_Joystick_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Joystick_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Joystick_Void"] = _Event_lime_ui_Joystick_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Joystick_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.__name__ = ["lime","app","_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void"];
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void"] = _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_ui_Touch_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Touch_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Touch_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Touch_Void.__name__ = ["lime","app","_Event_lime_ui_Touch_Void"];
+_Event_lime_ui_Touch_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Touch_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Touch_Void"] = _Event_lime_ui_Touch_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Touch_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_lime_utils_Resource_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_utils_Resource_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_utils_Resource_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_utils_Resource_Void.__name__ = ["lime","app","_Event_lime_utils_Resource_Void"];
+_Event_lime_utils_Resource_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_utils_Resource_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_utils_Resource_Void"] = _Event_lime_utils_Resource_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_utils_Resource_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Event_ofEvents_T_Void.js

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_ofEvents_T_Void
+
+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 Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_ofEvents_T_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_ofEvents_T_Void.__name__ = ["lime","app","_Event_ofEvents_T_Void"];
+_Event_ofEvents_T_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_ofEvents_T_Void.prototype.__class__ = $hxClasses["lime.app._Event_ofEvents_T_Void"] = _Event_ofEvents_T_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_ofEvents_T_Void;

hGameTest/node_modules/openfl/lib/_gen/lime/app/_Future/FutureWork.js

@@ -0,0 +1,62 @@
+// Class: lime.app._Future.FutureWork
+
+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 lime_system_ThreadPool() {return require("./../../../lime/system/ThreadPool");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var FutureWork = function(){}
+
+// Meta
+
+FutureWork.__name__ = ["lime","app","_Future","FutureWork"];
+FutureWork.prototype = {
+	
+};
+FutureWork.prototype.__class__ = $hxClasses["lime.app._Future.FutureWork"] = FutureWork;
+
+// Init
+
+
+
+// Statics
+
+FutureWork.queue = function(state) {
+	if(FutureWork.threadPool == null) {
+		FutureWork.threadPool = new (lime_system_ThreadPool().default)();
+		FutureWork.threadPool.doWork.add(FutureWork.threadPool_doWork);
+		FutureWork.threadPool.onComplete.add(FutureWork.threadPool_onComplete);
+		FutureWork.threadPool.onError.add(FutureWork.threadPool_onError);
+	}
+	FutureWork.threadPool.queue(state);
+}
+FutureWork.threadPool_doWork = function(state) {
+	try {
+		var result = state.work();
+		FutureWork.threadPool.sendComplete({ promise : state.promise, result : result});
+	} catch( e ) {
+		if (e instanceof (js__$Boot_HaxeError().default)) e = e.val;
+		FutureWork.threadPool.sendError({ promise : state.promise, error : e});
+	}
+}
+FutureWork.threadPool_onComplete = function(state) {
+	state.promise.complete(state.result);
+}
+FutureWork.threadPool_onError = function(state) {
+	state.promise.error(state.error);
+}
+
+
+// Export
+
+exports.default = FutureWork;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ConsoleRenderContext.js

@@ -0,0 +1,83 @@
+// Class: lime.graphics.ConsoleRenderContext
+
+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 lime_graphics_console_IndexBuffer() {return require("./../../lime/graphics/console/IndexBuffer");}
+function lime_graphics_console_VertexBuffer() {return require("./../../lime/graphics/console/VertexBuffer");}
+function lime_graphics_console_Shader() {return require("./../../lime/graphics/console/Shader");}
+
+// Constructor
+
+var ConsoleRenderContext = function() {
+}
+
+// Meta
+
+ConsoleRenderContext.__name__ = ["lime","graphics","ConsoleRenderContext"];
+ConsoleRenderContext.prototype = {
+	createIndexBuffer: function(indices,count) {
+		return new (lime_graphics_console_IndexBuffer().default)();
+	},
+	createVertexBuffer: function(decl,count) {
+		return new (lime_graphics_console_VertexBuffer().default)();
+	},
+	lookupShader: function(name) {
+		return new (lime_graphics_console_Shader().default)();
+	},
+	clear: function(r,g,b,a,depth,stencil) {
+		if(stencil == null) {
+			stencil = 0;
+		}
+		if(depth == null) {
+			depth = 1.0;
+		}
+	},
+	bindShader: function(shader) {
+	},
+	setViewport: function(x,y,width,height,nearPlane,farPlane) {
+		if(farPlane == null) {
+			farPlane = 1.0;
+		}
+		if(nearPlane == null) {
+			nearPlane = 0.0;
+		}
+	},
+	setVertexShaderConstantF: function(startRegister,vec4,vec4count) {
+	},
+	setVertexSource: function(vb) {
+	},
+	setIndexSource: function(ib) {
+	},
+	draw: function(primitive,startVertex,primitiveCount) {
+	},
+	drawIndexed: function(primitive,vertexCount,startIndex,primitiveCount) {
+	},
+	get_width: function() {
+		return 0;
+	},
+	get_height: function() {
+		return 0;
+	}
+};
+ConsoleRenderContext.prototype.__class__ = $hxClasses["lime.graphics.ConsoleRenderContext"] = ConsoleRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ConsoleRenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/FlashRenderContext.js

@@ -0,0 +1,154 @@
+// Class: lime.graphics.FlashRenderContext
+
+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 FlashRenderContext = function() {
+}
+
+// Meta
+
+FlashRenderContext.__name__ = ["lime","graphics","FlashRenderContext"];
+FlashRenderContext.prototype = {
+	addChild: function(child) {
+		return null;
+	},
+	addChildAt: function(child,index) {
+		return null;
+	},
+	addEventListener: function(type,listener,useCapture,priority,useWeakReference) {
+		if(useWeakReference == null) {
+			useWeakReference = false;
+		}
+		if(priority == null) {
+			priority = 0;
+		}
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	areInaccessibleObjectsUnderPoint: function(point) {
+		return false;
+	},
+	contains: function(child) {
+		return false;
+	},
+	dispatchEvent: function(event) {
+		return false;
+	},
+	getBounds: function(targetCoordinateSpace) {
+		return null;
+	},
+	getChildAt: function(index) {
+		return null;
+	},
+	getChildByName: function(name) {
+		return null;
+	},
+	getChildIndex: function(child) {
+		return 0;
+	},
+	getObjectsUnderPoint: function(point) {
+		return null;
+	},
+	getRect: function(targetCoordinateSpace) {
+		return null;
+	},
+	globalToLocal: function(point) {
+		return null;
+	},
+	globalToLocal3D: function(point) {
+		return null;
+	},
+	hasEventListener: function(type) {
+		return false;
+	},
+	hitTestObject: function(obj) {
+		return false;
+	},
+	hitTestPoint: function(x,y,shapeFlag) {
+		if(shapeFlag == null) {
+			shapeFlag = false;
+		}
+		return false;
+	},
+	local3DToGlobal: function(point3d) {
+		return null;
+	},
+	localToGlobal: function(point) {
+		return null;
+	},
+	removeChild: function(child) {
+		return null;
+	},
+	removeChildAt: function(index) {
+		return null;
+	},
+	removeChildren: function(beginIndex,endIndex) {
+		if(endIndex == null) {
+			endIndex = 2147483647;
+		}
+		if(beginIndex == null) {
+			beginIndex = 0;
+		}
+	},
+	removeEventListener: function(type,listener,useCapture) {
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	requestSoftKeyboard: function() {
+		return false;
+	},
+	setChildIndex: function(child,index) {
+	},
+	startDrag: function(lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	startTouchDrag: function(touchPointID,lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	stopAllMovieClips: function() {
+	},
+	stopDrag: function() {
+	},
+	stopTouchDrag: function(touchPointID) {
+	},
+	swapChildren: function(child1,child2) {
+	},
+	swapChildrenAt: function(index1,index2) {
+	},
+	toString: function() {
+		return null;
+	},
+	willTrigger: function(type) {
+		return false;
+	}
+};
+FlashRenderContext.prototype.__class__ = $hxClasses["lime.graphics.FlashRenderContext"] = FlashRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = FlashRenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageBuffer.js

@@ -0,0 +1,119 @@
+// Class: lime.graphics.ImageBuffer
+
+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_Browser() {return require("./../../js/Browser");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var ImageBuffer = function(data,width,height,bitsPerPixel,format) {
+	if(bitsPerPixel == null) {
+		bitsPerPixel = 32;
+	}
+	if(height == null) {
+		height = 0;
+	}
+	if(width == null) {
+		width = 0;
+	}
+	this.data = data;
+	this.width = width;
+	this.height = height;
+	this.bitsPerPixel = bitsPerPixel;
+	this.format = format == null ? 0 : format;
+	this.premultiplied = false;
+	this.transparent = true;
+}
+
+// Meta
+
+ImageBuffer.__name__ = ["lime","graphics","ImageBuffer"];
+ImageBuffer.prototype = {
+	clone: function() {
+		var buffer = new ImageBuffer(this.data,this.width,this.height,this.bitsPerPixel);
+		if(this.data != null) {
+			var elements = this.data.byteLength;
+			var this1;
+			if(elements != null) {
+				this1 = new Uint8Array(elements);
+			} else {
+				this1 = null;
+			}
+			buffer.data = this1;
+			var view = this.data;
+			var this2;
+			if(view != null) {
+				this2 = new Uint8Array(view);
+			} else {
+				this2 = null;
+			}
+			var copy = this2;
+			buffer.data.set(copy);
+		} else if(this.__srcImageData != null) {
+			buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+			buffer.__srcCanvas.width = this.__srcImageData.width;
+			buffer.__srcCanvas.height = this.__srcImageData.height;
+			buffer.__srcImageData = buffer.__srcContext.createImageData(this.__srcImageData.width,this.__srcImageData.height);
+			var copy1 = new Uint8ClampedArray(this.__srcImageData.data);
+			buffer.__srcImageData.data.set(copy1);
+		} else if(this.__srcCanvas != null) {
+			buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+			buffer.__srcCanvas.width = this.__srcCanvas.width;
+			buffer.__srcCanvas.height = this.__srcCanvas.height;
+			buffer.__srcContext.drawImage(this.__srcCanvas,0,0);
+		} else {
+			buffer.__srcImage = this.__srcImage;
+		}
+		buffer.bitsPerPixel = this.bitsPerPixel;
+		buffer.format = this.format;
+		buffer.premultiplied = this.premultiplied;
+		buffer.transparent = this.transparent;
+		return buffer;
+	},
+	get_src: function() {
+		if(this.__srcImage != null) {
+			return this.__srcImage;
+		}
+		return this.__srcCanvas;
+	},
+	set_src: function(value) {
+		if((Std().default)["is"](value,Image)) {
+			this.__srcImage = value;
+		} else if((Std().default)["is"](value,HTMLCanvasElement)) {
+			this.__srcCanvas = value;
+			this.__srcContext = this.__srcCanvas.getContext("2d");
+		}
+		return value;
+	},
+	get_stride: function() {
+		return this.width * 4;
+	}
+};
+ImageBuffer.prototype.__class__ = $hxClasses["lime.graphics.ImageBuffer"] = ImageBuffer;
+
+// Init
+
+{
+	var p = ImageBuffer.prototype;
+	Object.defineProperties(p,{ "src" : { get : p.get_src, set : p.set_src}, "stride" : { get : p.get_stride}});
+};
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ImageBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageChannel.js

@@ -0,0 +1,33 @@
+// Enum: lime.graphics.ImageChannel
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var ImageChannel = $hxClasses["lime.graphics.ImageChannel"] = { __ename__: ["lime","graphics","ImageChannel"], __constructs__: ["RED","GREEN","BLUE","ALPHA"] }
+
+ImageChannel.BLUE = ["BLUE",2];
+ImageChannel.BLUE.toString = $estr;
+ImageChannel.BLUE.__enum__ = ImageChannel;
+
+ImageChannel.GREEN = ["GREEN",1];
+ImageChannel.GREEN.toString = $estr;
+ImageChannel.GREEN.__enum__ = ImageChannel;
+
+ImageChannel.RED = ["RED",0];
+ImageChannel.RED.toString = $estr;
+ImageChannel.RED.__enum__ = ImageChannel;
+
+ImageChannel.ALPHA = ["ALPHA",3];
+ImageChannel.ALPHA.toString = $estr;
+ImageChannel.ALPHA.__enum__ = ImageChannel;
+
+
+exports.default = ImageChannel;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/ImageType.js

@@ -0,0 +1,33 @@
+// Enum: lime.graphics.ImageType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var ImageType = $hxClasses["lime.graphics.ImageType"] = { __ename__: ["lime","graphics","ImageType"], __constructs__: ["CANVAS","DATA","FLASH","CUSTOM"] }
+
+ImageType.CANVAS = ["CANVAS",0];
+ImageType.CANVAS.toString = $estr;
+ImageType.CANVAS.__enum__ = ImageType;
+
+ImageType.FLASH = ["FLASH",2];
+ImageType.FLASH.toString = $estr;
+ImageType.FLASH.__enum__ = ImageType;
+
+ImageType.DATA = ["DATA",1];
+ImageType.DATA.toString = $estr;
+ImageType.DATA.__enum__ = ImageType;
+
+ImageType.CUSTOM = ["CUSTOM",3];
+ImageType.CUSTOM.toString = $estr;
+ImageType.CUSTOM.__enum__ = ImageType;
+
+
+exports.default = ImageType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/RenderContext.js

@@ -0,0 +1,28 @@
+// Enum: lime.graphics.RenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var RenderContext = $hxClasses["lime.graphics.RenderContext"] = { __ename__: ["lime","graphics","RenderContext"], __constructs__: ["OPENGL","CANVAS","DOM","FLASH","CAIRO","CONSOLE","CUSTOM","NONE"] }
+
+RenderContext.OPENGL = function(gl) { var $x = ["OPENGL",0,gl]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CANVAS = function(context) { var $x = ["CANVAS",1,context]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.DOM = function(element) { var $x = ["DOM",2,element]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.NONE = ["NONE",7];
+RenderContext.NONE.toString = $estr;
+RenderContext.NONE.__enum__ = RenderContext;
+
+RenderContext.FLASH = function(stage) { var $x = ["FLASH",3,stage]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CONSOLE = function(context) { var $x = ["CONSOLE",5,context]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CAIRO = function(cairo) { var $x = ["CAIRO",4,cairo]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+RenderContext.CUSTOM = function(data) { var $x = ["CUSTOM",6,data]; $x.__enum__ = RenderContext; $x.toString = $estr; return $x; }
+
+exports.default = RenderContext;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/Renderer.js

@@ -0,0 +1,58 @@
+// Class: lime.graphics.Renderer
+
+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 lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+function lime_app__$Event_$lime_$graphics_$RenderContext_$Void() {return require("./../../lime/app/_Event_lime_graphics_RenderContext_Void");}
+function lime__$backend_html5_HTML5Renderer() {return require("./../../lime/_backend/html5/HTML5Renderer");}
+
+// Constructor
+
+var Renderer = function(window) {
+	this.onRender = new (lime_app__$Event_$Void_$Void().default)();
+	this.onContextRestored = new (lime_app__$Event_$lime_$graphics_$RenderContext_$Void().default)();
+	this.onContextLost = new (lime_app__$Event_$Void_$Void().default)();
+	this.window = window;
+	this.backend = new (lime__$backend_html5_HTML5Renderer().default)(this);
+	this.window.renderer = this;
+}
+
+// Meta
+
+Renderer.__name__ = ["lime","graphics","Renderer"];
+Renderer.prototype = {
+	create: function() {
+		this.backend.create();
+	},
+	flip: function() {
+		this.backend.flip();
+	},
+	readPixels: function(rect) {
+		return this.backend.readPixels(rect);
+	},
+	render: function() {
+		this.backend.render();
+	}
+};
+Renderer.prototype.__class__ = $hxClasses["lime.graphics.Renderer"] = Renderer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Renderer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/RendererType.js

@@ -0,0 +1,45 @@
+// Enum: lime.graphics.RendererType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var RendererType = $hxClasses["lime.graphics.RendererType"] = { __ename__: ["lime","graphics","RendererType"], __constructs__: ["OPENGL","CANVAS","DOM","FLASH","CAIRO","CONSOLE","CUSTOM"] }
+
+RendererType.OPENGL = ["OPENGL",0];
+RendererType.OPENGL.toString = $estr;
+RendererType.OPENGL.__enum__ = RendererType;
+
+RendererType.CANVAS = ["CANVAS",1];
+RendererType.CANVAS.toString = $estr;
+RendererType.CANVAS.__enum__ = RendererType;
+
+RendererType.DOM = ["DOM",2];
+RendererType.DOM.toString = $estr;
+RendererType.DOM.__enum__ = RendererType;
+
+RendererType.FLASH = ["FLASH",3];
+RendererType.FLASH.toString = $estr;
+RendererType.FLASH.__enum__ = RendererType;
+
+RendererType.CONSOLE = ["CONSOLE",5];
+RendererType.CONSOLE.toString = $estr;
+RendererType.CONSOLE.__enum__ = RendererType;
+
+RendererType.CAIRO = ["CAIRO",4];
+RendererType.CAIRO.toString = $estr;
+RendererType.CAIRO.__enum__ = RendererType;
+
+RendererType.CUSTOM = ["CUSTOM",6];
+RendererType.CUSTOM.toString = $estr;
+RendererType.CUSTOM.__enum__ = RendererType;
+
+
+exports.default = RendererType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/Cairo.js

@@ -0,0 +1,240 @@
+// Class: lime.graphics.cairo.Cairo
+
+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 Cairo = function(surface) {
+	var tmp = surface != null;
+}
+
+// Meta
+
+Cairo.__name__ = ["lime","graphics","cairo","Cairo"];
+Cairo.prototype = {
+	arc: function(xc,yc,radius,angle1,angle2) {
+	},
+	arcNegative: function(xc,yc,radius,angle1,angle2) {
+	},
+	clip: function() {
+	},
+	clipExtents: function(x1,y1,x2,y2) {
+	},
+	clipPreserve: function() {
+	},
+	closePath: function() {
+	},
+	copyPage: function() {
+	},
+	curveTo: function(x1,y1,x2,y2,x3,y3) {
+	},
+	fill: function() {
+	},
+	fillExtents: function(x1,y1,x2,y2) {
+	},
+	fillPreserve: function() {
+	},
+	identityMatrix: function() {
+	},
+	inClip: function(x,y) {
+		return false;
+	},
+	inFill: function(x,y) {
+		return false;
+	},
+	inStroke: function(x,y) {
+		return false;
+	},
+	lineTo: function(x,y) {
+	},
+	moveTo: function(x,y) {
+	},
+	mask: function(pattern) {
+	},
+	maskSurface: function(surface,x,y) {
+	},
+	newPath: function() {
+	},
+	paint: function() {
+	},
+	paintWithAlpha: function(alpha) {
+	},
+	popGroup: function() {
+		return null;
+	},
+	popGroupToSource: function() {
+	},
+	pushGroup: function() {
+	},
+	pushGroupWithContent: function(content) {
+	},
+	recreate: function(surface) {
+	},
+	rectangle: function(x,y,width,height) {
+	},
+	relCurveTo: function(dx1,dy1,dx2,dy2,dx3,dy3) {
+	},
+	relLineTo: function(dx,dy) {
+	},
+	relMoveTo: function(dx,dy) {
+	},
+	resetClip: function() {
+	},
+	restore: function() {
+	},
+	save: function() {
+	},
+	setFontSize: function(size) {
+	},
+	setSourceRGB: function(r,g,b) {
+	},
+	setSourceRGBA: function(r,g,b,a) {
+	},
+	setSourceSurface: function(surface,x,y) {
+	},
+	showGlyphs: function(glyphs) {
+	},
+	showPage: function() {
+	},
+	showText: function(utf8) {
+	},
+	status: function() {
+		return 0;
+	},
+	stroke: function() {
+	},
+	strokeExtents: function(x1,y1,x2,y2) {
+	},
+	strokePreserve: function() {
+	},
+	textPath: function(utf8) {
+	},
+	transform: function(matrix) {
+	},
+	rotate: function(amount) {
+	},
+	scale: function(x,y) {
+	},
+	translate: function(x,y) {
+	},
+	get_antialias: function() {
+		return 0;
+	},
+	set_antialias: function(value) {
+		return value;
+	},
+	get_currentPoint: function() {
+		return null;
+	},
+	get_dash: function() {
+		return [];
+	},
+	set_dash: function(value) {
+		return value;
+	},
+	get_dashCount: function() {
+		return 0;
+	},
+	get_fillRule: function() {
+		return 0;
+	},
+	set_fillRule: function(value) {
+		return value;
+	},
+	get_fontFace: function() {
+		return 0;
+	},
+	set_fontFace: function(value) {
+		return value;
+	},
+	get_fontOptions: function() {
+		return null;
+	},
+	set_fontOptions: function(value) {
+		return value;
+	},
+	get_groupTarget: function() {
+		return 0;
+	},
+	get_hasCurrentPoint: function() {
+		return false;
+	},
+	get_lineCap: function() {
+		return 0;
+	},
+	set_lineCap: function(value) {
+		return value;
+	},
+	get_lineJoin: function() {
+		return 0;
+	},
+	set_lineJoin: function(value) {
+		return value;
+	},
+	get_lineWidth: function() {
+		return 0;
+	},
+	set_lineWidth: function(value) {
+		return value;
+	},
+	get_matrix: function() {
+		return null;
+	},
+	set_matrix: function(value) {
+		return value;
+	},
+	get_miterLimit: function() {
+		return 0;
+	},
+	set_miterLimit: function(value) {
+		return value;
+	},
+	get_operator: function() {
+		return 0;
+	},
+	set_operator: function(value) {
+		return value;
+	},
+	get_source: function() {
+		return 0;
+	},
+	set_source: function(value) {
+		return value;
+	},
+	get_target: function() {
+		return 0;
+	},
+	get_tolerance: function() {
+		return 0;
+	},
+	set_tolerance: function(value) {
+		return value;
+	}
+};
+Cairo.prototype.__class__ = $hxClasses["lime.graphics.cairo.Cairo"] = Cairo;
+
+// Init
+
+
+
+// Statics
+
+Cairo.get_version = function() {
+	return 0;
+}
+Cairo.get_versionString = function() {
+	return "";
+}
+
+
+// Export
+
+exports.default = Cairo;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/CairoGlyph.js

@@ -0,0 +1,46 @@
+// Class: lime.graphics.cairo.CairoGlyph
+
+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 CairoGlyph = function(index,x,y) {
+	if(y == null) {
+		y = 0;
+	}
+	if(x == null) {
+		x = 0;
+	}
+	this.index = index;
+	this.x = x;
+	this.y = y;
+}
+
+// Meta
+
+CairoGlyph.__name__ = ["lime","graphics","cairo","CairoGlyph"];
+CairoGlyph.prototype = {
+	
+};
+CairoGlyph.prototype.__class__ = $hxClasses["lime.graphics.cairo.CairoGlyph"] = CairoGlyph;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = CairoGlyph;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFTFontFace/CairoFTFontFace_Impl_.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.cairo._CairoFTFontFace.CairoFTFontFace_Impl_
+
+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 CairoFTFontFace_Impl_ = function(){}
+
+// Meta
+
+CairoFTFontFace_Impl_.__name__ = ["lime","graphics","cairo","_CairoFTFontFace","CairoFTFontFace_Impl_"];
+CairoFTFontFace_Impl_.prototype = {
+	
+};
+CairoFTFontFace_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFTFontFace.CairoFTFontFace_Impl_"] = CairoFTFontFace_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFTFontFace_Impl_._new = function() {
+	var this1 = 0;
+	return this1;
+}
+CairoFTFontFace_Impl_.create = function(face,loadFlags) {
+	return 0;
+}
+CairoFTFontFace_Impl_.FT_LOAD_FORCE_AUTOHINT = 32
+
+// Export
+
+exports.default = CairoFTFontFace_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFontFace/CairoFontFace_Impl_.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.cairo._CairoFontFace.CairoFontFace_Impl_
+
+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 CairoFontFace_Impl_ = function(){}
+
+// Meta
+
+CairoFontFace_Impl_.__name__ = ["lime","graphics","cairo","_CairoFontFace","CairoFontFace_Impl_"];
+CairoFontFace_Impl_.prototype = {
+	
+};
+CairoFontFace_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFontFace.CairoFontFace_Impl_"] = CairoFontFace_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFontFace_Impl_._new = function() {
+	var this1 = null;
+	return this1;
+}
+CairoFontFace_Impl_.status = function(this1) {
+	return 0;
+}
+
+
+// Export
+
+exports.default = CairoFontFace_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoFontOptions/CairoFontOptions_Impl_.js

@@ -0,0 +1,63 @@
+// Class: lime.graphics.cairo._CairoFontOptions.CairoFontOptions_Impl_
+
+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 CairoFontOptions_Impl_ = function(){}
+
+// Meta
+
+CairoFontOptions_Impl_.__name__ = ["lime","graphics","cairo","_CairoFontOptions","CairoFontOptions_Impl_"];
+CairoFontOptions_Impl_.prototype = {
+	
+};
+CairoFontOptions_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoFontOptions.CairoFontOptions_Impl_"] = CairoFontOptions_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoFontOptions_Impl_._new = function() {
+	var this1 = null;
+	return this1;
+}
+CairoFontOptions_Impl_.get_antialias = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_antialias = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_hintMetrics = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_hintMetrics = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_hintStyle = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_hintStyle = function(this1,value) {
+	return value;
+}
+CairoFontOptions_Impl_.get_subpixelOrder = function(this1) {
+	return 0;
+}
+CairoFontOptions_Impl_.set_subpixelOrder = function(this1,value) {
+	return value;
+}
+
+
+// Export
+
+exports.default = CairoFontOptions_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoImageSurface/CairoImageSurface_Impl_.js

@@ -0,0 +1,62 @@
+// Class: lime.graphics.cairo._CairoImageSurface.CairoImageSurface_Impl_
+
+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 lime_utils__$DataPointer_DataPointer_$Impl_$() {return require("./../../../../lime/utils/_DataPointer/DataPointer_Impl_");}
+
+// Constructor
+
+var CairoImageSurface_Impl_ = function(){}
+
+// Meta
+
+CairoImageSurface_Impl_.__name__ = ["lime","graphics","cairo","_CairoImageSurface","CairoImageSurface_Impl_"];
+CairoImageSurface_Impl_.prototype = {
+	
+};
+CairoImageSurface_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoImageSurface.CairoImageSurface_Impl_"] = CairoImageSurface_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoImageSurface_Impl_._new = function(format,width,height) {
+	var this1 = 0;
+	return this1;
+}
+CairoImageSurface_Impl_.create = function(data,format,width,height,stride) {
+	return 0;
+}
+CairoImageSurface_Impl_.fromImage = function(image) {
+	return null;
+}
+CairoImageSurface_Impl_.get_data = function(this1) {
+	return (lime_utils__$DataPointer_DataPointer_$Impl_$().default).fromInt(0);
+}
+CairoImageSurface_Impl_.get_format = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_height = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_stride = function(this1) {
+	return 0;
+}
+CairoImageSurface_Impl_.get_width = function(this1) {
+	return 0;
+}
+
+
+// Export
+
+exports.default = CairoImageSurface_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoPattern/CairoPattern_Impl_.js

@@ -0,0 +1,79 @@
+// Class: lime.graphics.cairo._CairoPattern.CairoPattern_Impl_
+
+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 CairoPattern_Impl_ = function(){}
+
+// Meta
+
+CairoPattern_Impl_.__name__ = ["lime","graphics","cairo","_CairoPattern","CairoPattern_Impl_"];
+CairoPattern_Impl_.prototype = {
+	
+};
+CairoPattern_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoPattern.CairoPattern_Impl_"] = CairoPattern_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoPattern_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+CairoPattern_Impl_.addColorStopRGB = function(this1,offset,r,g,b) {
+}
+CairoPattern_Impl_.addColorStopRGBA = function(this1,offset,r,g,b,a) {
+}
+CairoPattern_Impl_.createForSurface = function(surface) {
+	return 0;
+}
+CairoPattern_Impl_.createLinear = function(x0,y0,x1,y1) {
+	return 0;
+}
+CairoPattern_Impl_.createRadial = function(cx0,cy0,radius0,cx1,cy1,radius1) {
+	return 0;
+}
+CairoPattern_Impl_.createRGB = function(r,g,b) {
+	return 0;
+}
+CairoPattern_Impl_.createRGBA = function(r,g,b,a) {
+	return 0;
+}
+CairoPattern_Impl_.get_colorStopCount = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.get_extend = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.set_extend = function(this1,value) {
+	return value;
+}
+CairoPattern_Impl_.get_filter = function(this1) {
+	return 0;
+}
+CairoPattern_Impl_.set_filter = function(this1,value) {
+	return value;
+}
+CairoPattern_Impl_.get_matrix = function(this1) {
+	return null;
+}
+CairoPattern_Impl_.set_matrix = function(this1,value) {
+	return value;
+}
+
+
+// Export
+
+exports.default = CairoPattern_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/cairo/_CairoSurface/CairoSurface_Impl_.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.cairo._CairoSurface.CairoSurface_Impl_
+
+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 CairoSurface_Impl_ = function(){}
+
+// Meta
+
+CairoSurface_Impl_.__name__ = ["lime","graphics","cairo","_CairoSurface","CairoSurface_Impl_"];
+CairoSurface_Impl_.prototype = {
+	
+};
+CairoSurface_Impl_.prototype.__class__ = $hxClasses["lime.graphics.cairo._CairoSurface.CairoSurface_Impl_"] = CairoSurface_Impl_;
+
+// Init
+
+
+
+// Statics
+
+CairoSurface_Impl_.flush = function(this1) {
+}
+
+
+// Export
+
+exports.default = CairoSurface_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/IndexBuffer.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.console.IndexBuffer
+
+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 IndexBuffer = function() {
+}
+
+// Meta
+
+IndexBuffer.__name__ = ["lime","graphics","console","IndexBuffer"];
+IndexBuffer.prototype = {
+	
+};
+IndexBuffer.prototype.__class__ = $hxClasses["lime.graphics.console.IndexBuffer"] = IndexBuffer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = IndexBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/Primitive.js

@@ -0,0 +1,37 @@
+// Enum: lime.graphics.console.Primitive
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var Primitive = $hxClasses["lime.graphics.console.Primitive"] = { __ename__: ["lime","graphics","console","Primitive"], __constructs__: ["Point","Line","LineStrip","Triangle","TriangleStrip"] }
+
+Primitive.Line = ["Line",1];
+Primitive.Line.toString = $estr;
+Primitive.Line.__enum__ = Primitive;
+
+Primitive.Triangle = ["Triangle",3];
+Primitive.Triangle.toString = $estr;
+Primitive.Triangle.__enum__ = Primitive;
+
+Primitive.TriangleStrip = ["TriangleStrip",4];
+Primitive.TriangleStrip.toString = $estr;
+Primitive.TriangleStrip.__enum__ = Primitive;
+
+Primitive.Point = ["Point",0];
+Primitive.Point.toString = $estr;
+Primitive.Point.__enum__ = Primitive;
+
+Primitive.LineStrip = ["LineStrip",2];
+Primitive.LineStrip.toString = $estr;
+Primitive.LineStrip.__enum__ = Primitive;
+
+
+exports.default = Primitive;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/Shader.js

@@ -0,0 +1,37 @@
+// Class: lime.graphics.console.Shader
+
+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 Shader = function() {
+}
+
+// Meta
+
+Shader.__name__ = ["lime","graphics","console","Shader"];
+Shader.prototype = {
+	
+};
+Shader.prototype.__class__ = $hxClasses["lime.graphics.console.Shader"] = Shader;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Shader;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/VertexBuffer.js

@@ -0,0 +1,43 @@
+// Class: lime.graphics.console.VertexBuffer
+
+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 lime_graphics_console_VertexOutput() {return require("./../../../lime/graphics/console/VertexOutput");}
+
+// Constructor
+
+var VertexBuffer = function() {
+}
+
+// Meta
+
+VertexBuffer.__name__ = ["lime","graphics","console","VertexBuffer"];
+VertexBuffer.prototype = {
+	lock: function() {
+		return new (lime_graphics_console_VertexOutput().default)();
+	},
+	unlock: function() {
+	}
+};
+VertexBuffer.prototype.__class__ = $hxClasses["lime.graphics.console.VertexBuffer"] = VertexBuffer;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VertexBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/console/VertexOutput.js

@@ -0,0 +1,42 @@
+// Class: lime.graphics.console.VertexOutput
+
+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 VertexOutput = function() {
+}
+
+// Meta
+
+VertexOutput.__name__ = ["lime","graphics","console","VertexOutput"];
+VertexOutput.prototype = {
+	vec2: function(x,y) {
+	},
+	vec3: function(x,y,z) {
+	},
+	color: function(r,g,b,a) {
+	}
+};
+VertexOutput.prototype.__class__ = $hxClasses["lime.graphics.console.VertexOutput"] = VertexOutput;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VertexOutput;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/BMP.js

@@ -0,0 +1,205 @@
+// Class: lime.graphics.format.BMP
+
+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 lime_graphics_format_BMPType() {return require("./../../../lime/graphics/format/BMPType");}
+function Type() {return require("./../../../Type");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function lime_math_Rectangle() {return require("./../../../lime/math/Rectangle");}
+
+// Constructor
+
+var BMP = function(){}
+
+// Meta
+
+BMP.__name__ = ["lime","graphics","format","BMP"];
+BMP.prototype = {
+	
+};
+BMP.prototype.__class__ = $hxClasses["lime.graphics.format.BMP"] = BMP;
+
+// Init
+
+
+
+// Statics
+
+BMP.encode = function(image,type) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	if(type == null) {
+		type = (lime_graphics_format_BMPType().default).RGB;
+	}
+	var fileHeaderLength = 14;
+	var infoHeaderLength = 40;
+	var pixelValuesLength = image.width * image.height * 4;
+	if(type != null) {
+		switch((Type().default).enumIndex(type)) {
+		case 0:
+			pixelValuesLength = image.width * 3 + image.width * 3 % 4 + image.height * 3 + image.height * 3;
+			break;
+		case 1:
+			infoHeaderLength = 108;
+			break;
+		case 2:
+			fileHeaderLength = 0;
+			pixelValuesLength += image.width * image.height;
+			break;
+		}
+	}
+	var data = (haxe_io_Bytes().default).alloc(fileHeaderLength + infoHeaderLength + pixelValuesLength);
+	var position = 0;
+	if(fileHeaderLength > 0) {
+		data.set(position++,66);
+		data.set(position++,77);
+		data.setInt32(position,data.get_length());
+		position += 4;
+		data.setUInt16(position,0);
+		position += 2;
+		data.setUInt16(position,0);
+		position += 2;
+		data.setInt32(position,fileHeaderLength + infoHeaderLength);
+		position += 4;
+	}
+	data.setInt32(position,infoHeaderLength);
+	position += 4;
+	data.setInt32(position,image.width);
+	position += 4;
+	data.setInt32(position,type == (lime_graphics_format_BMPType().default).ICO ? image.height * 2 : image.height);
+	position += 4;
+	data.setUInt16(position,1);
+	position += 2;
+	data.setUInt16(position,type == (lime_graphics_format_BMPType().default).RGB ? 24 : 32);
+	position += 2;
+	data.setInt32(position,type == (lime_graphics_format_BMPType().default).BITFIELD ? 3 : 0);
+	position += 4;
+	data.setInt32(position,pixelValuesLength);
+	position += 4;
+	data.setInt32(position,11824);
+	position += 4;
+	data.setInt32(position,11824);
+	position += 4;
+	data.setInt32(position,0);
+	position += 4;
+	data.setInt32(position,0);
+	position += 4;
+	if(type == (lime_graphics_format_BMPType().default).BITFIELD) {
+		data.setInt32(position,16711680);
+		position += 4;
+		data.setInt32(position,65280);
+		position += 4;
+		data.setInt32(position,255);
+		position += 4;
+		data.setInt32(position,-16777216);
+		position += 4;
+		data.set(position++,32);
+		data.set(position++,110);
+		data.set(position++,105);
+		data.set(position++,87);
+		var _g = 0;
+		while(_g < 48) {
+			var i = _g++;
+			data.set(position++,0);
+		}
+	}
+	var pixels = image.getPixels(new (lime_math_Rectangle().default)(0,0,image.width,image.height),1);
+	var readPosition = 0;
+	var a;
+	var r;
+	var g;
+	var b;
+	if(type != null) {
+		switch((Type().default).enumIndex(type)) {
+		case 0:
+			var _g1 = 0;
+			var _g2 = image.height;
+			while(_g1 < _g2) {
+				var y = _g1++;
+				readPosition = (image.height - 1 - y) * 4 * image.width;
+				var _g3 = 0;
+				var _g21 = image.width;
+				while(_g3 < _g21) {
+					var x = _g3++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+				}
+				var _g31 = 0;
+				var _g22 = image.width * 3 % 4;
+				while(_g31 < _g22) {
+					var i1 = _g31++;
+					data.set(position++,0);
+				}
+			}
+			break;
+		case 1:
+			var _g11 = 0;
+			var _g4 = image.height;
+			while(_g11 < _g4) {
+				var y1 = _g11++;
+				readPosition = (image.height - 1 - y1) * 4 * image.width;
+				var _g32 = 0;
+				var _g23 = image.width;
+				while(_g32 < _g23) {
+					var x1 = _g32++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+					data.set(position++,a);
+				}
+			}
+			break;
+		case 2:
+			var andMask = (haxe_io_Bytes().default).alloc(image.width * image.height);
+			var maskPosition = 0;
+			var _g12 = 0;
+			var _g5 = image.height;
+			while(_g12 < _g5) {
+				var y2 = _g12++;
+				readPosition = (image.height - 1 - y2) * 4 * image.width;
+				var _g33 = 0;
+				var _g24 = image.width;
+				while(_g33 < _g24) {
+					var x2 = _g33++;
+					a = pixels.get(readPosition++);
+					r = pixels.get(readPosition++);
+					g = pixels.get(readPosition++);
+					b = pixels.get(readPosition++);
+					data.set(position++,b);
+					data.set(position++,g);
+					data.set(position++,r);
+					data.set(position++,a);
+					andMask.set(maskPosition++,0);
+				}
+			}
+			data.blit(position,andMask,0,image.width * image.height);
+			break;
+		}
+	}
+	return data;
+}
+
+
+// Export
+
+exports.default = BMP;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/BMPType.js

@@ -0,0 +1,29 @@
+// Enum: lime.graphics.format.BMPType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var BMPType = $hxClasses["lime.graphics.format.BMPType"] = { __ename__: ["lime","graphics","format","BMPType"], __constructs__: ["RGB","BITFIELD","ICO"] }
+
+BMPType.ICO = ["ICO",2];
+BMPType.ICO.toString = $estr;
+BMPType.ICO.__enum__ = BMPType;
+
+BMPType.BITFIELD = ["BITFIELD",1];
+BMPType.BITFIELD.toString = $estr;
+BMPType.BITFIELD.__enum__ = BMPType;
+
+BMPType.RGB = ["RGB",0];
+BMPType.RGB.toString = $estr;
+BMPType.RGB.__enum__ = BMPType;
+
+
+exports.default = BMPType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/JPEG.js

@@ -0,0 +1,75 @@
+// Class: lime.graphics.format.JPEG
+
+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 lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_graphics_utils_ImageCanvasUtil() {return require("./../../../lime/graphics/utils/ImageCanvasUtil");}
+function js_Browser() {return require("./../../../js/Browser");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function HxOverrides() {return require("./../../../HxOverrides");}
+
+// Constructor
+
+var JPEG = function(){}
+
+// Meta
+
+JPEG.__name__ = ["lime","graphics","format","JPEG"];
+JPEG.prototype = {
+	
+};
+JPEG.prototype.__class__ = $hxClasses["lime.graphics.format.JPEG"] = JPEG;
+
+// Init
+
+
+
+// Statics
+
+JPEG.decodeBytes = function(bytes,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+JPEG.decodeFile = function(path,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+JPEG.encode = function(image,quality) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+	(lime_graphics_utils_ImageCanvasUtil().default).sync(image,false);
+	if(image.buffer.__srcCanvas != null) {
+		var data = image.buffer.__srcCanvas.toDataURL("image/jpeg",quality / 100);
+		var buffer = (js_Browser().default).get_window().atob(data.split(";base64,")[1]);
+		var bytes = (haxe_io_Bytes().default).alloc(buffer.length);
+		var _g1 = 0;
+		var _g = buffer.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			bytes.set(i,(HxOverrides().default).cca(buffer,i));
+		}
+		return bytes;
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = JPEG;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/format/PNG.js

@@ -0,0 +1,75 @@
+// Class: lime.graphics.format.PNG
+
+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 lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_graphics_utils_ImageCanvasUtil() {return require("./../../../lime/graphics/utils/ImageCanvasUtil");}
+function js_Browser() {return require("./../../../js/Browser");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function HxOverrides() {return require("./../../../HxOverrides");}
+
+// Constructor
+
+var PNG = function(){}
+
+// Meta
+
+PNG.__name__ = ["lime","graphics","format","PNG"];
+PNG.prototype = {
+	
+};
+PNG.prototype.__class__ = $hxClasses["lime.graphics.format.PNG"] = PNG;
+
+// Init
+
+
+
+// Statics
+
+PNG.decodeBytes = function(bytes,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+PNG.decodeFile = function(path,decodeData) {
+	if(decodeData == null) {
+		decodeData = true;
+	}
+	return null;
+}
+PNG.encode = function(image) {
+	if(image.get_premultiplied() || image.get_format() != 0) {
+		image = image.clone();
+		image.set_premultiplied(false);
+		image.set_format(0);
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+	(lime_graphics_utils_ImageCanvasUtil().default).sync(image,false);
+	if(image.buffer.__srcCanvas != null) {
+		var data = image.buffer.__srcCanvas.toDataURL("image/png");
+		var buffer = (js_Browser().default).get_window().atob(data.split(";base64,")[1]);
+		var bytes = (haxe_io_Bytes().default).alloc(buffer.length);
+		var _g1 = 0;
+		var _g = buffer.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			bytes.set(i,(HxOverrides().default).cca(buffer,i));
+		}
+		return bytes;
+	}
+	return null;
+}
+
+
+// Export
+
+exports.default = PNG;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/GLContextType.js

@@ -0,0 +1,29 @@
+// Enum: lime.graphics.opengl.GLContextType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../../estr_stub").default;
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Definition
+
+var GLContextType = $hxClasses["lime.graphics.opengl.GLContextType"] = { __ename__: ["lime","graphics","opengl","GLContextType"], __constructs__: ["OPENGL","GLES","WEBGL"] }
+
+GLContextType.OPENGL = ["OPENGL",0];
+GLContextType.OPENGL.toString = $estr;
+GLContextType.OPENGL.__enum__ = GLContextType;
+
+GLContextType.WEBGL = ["WEBGL",2];
+GLContextType.WEBGL.toString = $estr;
+GLContextType.WEBGL.__enum__ = GLContextType;
+
+GLContextType.GLES = ["GLES",1];
+GLContextType.GLES.toString = $estr;
+GLContextType.GLES.__enum__ = GLContextType;
+
+
+exports.default = GLContextType;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/_GLES2Context/GLES2Context_Impl_.js

@@ -0,0 +1,40 @@
+// Class: lime.graphics.opengl._GLES2Context.GLES2Context_Impl_
+
+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 lime_graphics_opengl_GL() {return require("./../../../../lime/graphics/opengl/GL");}
+
+// Constructor
+
+var GLES2Context_Impl_ = function(){}
+
+// Meta
+
+GLES2Context_Impl_.__name__ = ["lime","graphics","opengl","_GLES2Context","GLES2Context_Impl_"];
+GLES2Context_Impl_.prototype = {
+	
+};
+GLES2Context_Impl_.prototype.__class__ = $hxClasses["lime.graphics.opengl._GLES2Context.GLES2Context_Impl_"] = GLES2Context_Impl_;
+
+// Init
+
+
+
+// Statics
+
+GLES2Context_Impl_.fromGL = function(gl) {
+	return (lime_graphics_opengl_GL().default).context;
+}
+
+
+// Export
+
+exports.default = GLES2Context_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/opengl/_WebGLContext/WebGLContext_Impl_.js

@@ -0,0 +1,76 @@
+// Class: lime.graphics.opengl._WebGLContext.WebGLContext_Impl_
+
+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 lime_graphics_opengl_GL() {return require("./../../../../lime/graphics/opengl/GL");}
+
+// Constructor
+
+var WebGLContext_Impl_ = function(){}
+
+// Meta
+
+WebGLContext_Impl_.__name__ = ["lime","graphics","opengl","_WebGLContext","WebGLContext_Impl_"];
+WebGLContext_Impl_.prototype = {
+	
+};
+WebGLContext_Impl_.prototype.__class__ = $hxClasses["lime.graphics.opengl._WebGLContext.WebGLContext_Impl_"] = WebGLContext_Impl_;
+
+// Init
+
+
+
+// Statics
+
+WebGLContext_Impl_.bufferData = function(this1,target,srcData,usage) {
+	this1.bufferDataWEBGL(target,srcData,usage,null,null);
+}
+WebGLContext_Impl_.bufferSubData = function(this1,target,offset,srcData) {
+	this1.bufferSubDataWEBGL(target,offset,srcData,null,null);
+}
+WebGLContext_Impl_.compressedTexImage2D = function(this1,target,level,internalformat,width,height,border,srcData) {
+	this1.compressedTexImage2DWEBGL(target,level,internalformat,width,height,border,srcData,null,null);
+}
+WebGLContext_Impl_.compressedTexSubImage2D = function(this1,target,level,xoffset,yoffset,width,height,format,srcData) {
+	this1.compressedTexSubImage2DWEBGL(target,level,xoffset,yoffset,width,height,format,srcData,null,null);
+}
+WebGLContext_Impl_.readPixels = function(this1,x,y,width,height,format,type,pixels) {
+	this1.readPixelsWEBGL(x,y,width,height,format,type,pixels,null);
+}
+WebGLContext_Impl_.texImage2D = function(this1,target,level,internalformat,width,height,border,format,type,srcData) {
+	this1.texImage2DWEBGL(target,level,internalformat,width,height,border,format,type,srcData,null);
+}
+WebGLContext_Impl_.texSubImage2D = function(this1,target,level,xoffset,yoffset,width,height,format,type,srcData) {
+	this1.texSubImage2DWEBGL(target,level,xoffset,yoffset,width,height,format,type,srcData,null);
+}
+WebGLContext_Impl_.uniformMatrix2fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix2fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.uniformMatrix3fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix3fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.uniformMatrix4fv = function(this1,location,transpose,v) {
+	this1.uniformMatrix4fvWEBGL(location,transpose,v,null,null);
+}
+WebGLContext_Impl_.fromGL = function(gl) {
+	return (lime_graphics_opengl_GL().default).context;
+}
+WebGLContext_Impl_.fromGLES2Context = function(gl) {
+	return gl;
+}
+WebGLContext_Impl_.fromGLES3Context = function(gl) {
+	return gl;
+}
+
+
+// Export
+
+exports.default = WebGLContext_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/utils/ImageCanvasUtil.js

@@ -0,0 +1,294 @@
+// Class: lime.graphics.utils.ImageCanvasUtil
+
+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 lime_graphics_utils_ImageDataUtil() {return require("./../../../lime/graphics/utils/ImageDataUtil");}
+function lime_graphics_ImageType() {return require("./../../../lime/graphics/ImageType");}
+function lime_math_Vector2() {return require("./../../../lime/math/Vector2");}
+function lime_math_Rectangle() {return require("./../../../lime/math/Rectangle");}
+function lime_graphics_ImageChannel() {return require("./../../../lime/graphics/ImageChannel");}
+function Std() {return require("./../../../Std");}
+function js_Browser() {return require("./../../../js/Browser");}
+
+// Constructor
+
+var ImageCanvasUtil = function(){}
+
+// Meta
+
+ImageCanvasUtil.__name__ = ["lime","graphics","utils","ImageCanvasUtil"];
+ImageCanvasUtil.prototype = {
+	
+};
+ImageCanvasUtil.prototype.__class__ = $hxClasses["lime.graphics.utils.ImageCanvasUtil"] = ImageCanvasUtil;
+
+// Init
+
+
+
+// Statics
+
+ImageCanvasUtil.colorTransform = function(image,rect,colorMatrix) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).colorTransform(image,rect,colorMatrix);
+}
+ImageCanvasUtil.convertToCanvas = function(image,clear) {
+	if(clear == null) {
+		clear = false;
+	}
+	var buffer = image.buffer;
+	if(buffer.__srcImage != null) {
+		if(buffer.__srcCanvas == null) {
+			ImageCanvasUtil.createCanvas(image,buffer.__srcImage.width,buffer.__srcImage.height);
+			buffer.__srcContext.drawImage(buffer.__srcImage,0,0);
+		}
+		buffer.__srcImage = null;
+	} else if(buffer.__srcCanvas == null && buffer.data != null) {
+		image.set_transparent(true);
+		ImageCanvasUtil.createCanvas(image,buffer.width,buffer.height);
+		ImageCanvasUtil.createImageData(image);
+		buffer.__srcContext.putImageData(buffer.__srcImageData,0,0);
+	} else if(image.type == (lime_graphics_ImageType().default).DATA && buffer.__srcImageData != null && image.dirty) {
+		buffer.__srcContext.putImageData(buffer.__srcImageData,0,0);
+		image.dirty = false;
+	}
+	if(clear) {
+		buffer.data = null;
+		buffer.__srcImageData = null;
+	} else if(buffer.data == null && buffer.__srcImageData != null) {
+		buffer.data = buffer.__srcImageData.data;
+	}
+	image.type = (lime_graphics_ImageType().default).CANVAS;
+}
+ImageCanvasUtil.convertToData = function(image,clear) {
+	if(clear == null) {
+		clear = false;
+	}
+	var buffer = image.buffer;
+	if(buffer.__srcImage != null) {
+		ImageCanvasUtil.convertToCanvas(image);
+	}
+	if(buffer.__srcCanvas != null && buffer.data == null) {
+		ImageCanvasUtil.createImageData(image);
+		if(image.type == (lime_graphics_ImageType().default).CANVAS) {
+			image.dirty = false;
+		}
+	} else if(image.type == (lime_graphics_ImageType().default).CANVAS && buffer.__srcCanvas != null && image.dirty) {
+		if(buffer.__srcImageData == null) {
+			ImageCanvasUtil.createImageData(image);
+		} else {
+			buffer.__srcImageData = buffer.__srcContext.getImageData(0,0,buffer.width,buffer.height);
+			var elements = buffer.__srcImageData.data.buffer;
+			var this1;
+			if(elements != null) {
+				this1 = new Uint8Array(elements);
+			} else {
+				this1 = null;
+			}
+			buffer.data = this1;
+		}
+		image.dirty = false;
+	}
+	if(clear) {
+		image.buffer.__srcCanvas = null;
+		image.buffer.__srcContext = null;
+	}
+	image.type = (lime_graphics_ImageType().default).DATA;
+}
+ImageCanvasUtil.copyChannel = function(image,sourceImage,sourceRect,destPoint,sourceChannel,destChannel) {
+	ImageCanvasUtil.convertToData(sourceImage);
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).copyChannel(image,sourceImage,sourceRect,destPoint,sourceChannel,destChannel);
+}
+ImageCanvasUtil.copyPixels = function(image,sourceImage,sourceRect,destPoint,alphaImage,alphaPoint,mergeAlpha) {
+	if(mergeAlpha == null) {
+		mergeAlpha = false;
+	}
+	if(destPoint == null || destPoint.x >= image.width || destPoint.y >= image.height || sourceRect == null || sourceRect.width < 1 || sourceRect.height < 1) {
+		return;
+	}
+	if(alphaImage != null && alphaImage.get_transparent()) {
+		if(alphaPoint == null) {
+			alphaPoint = new (lime_math_Vector2().default)();
+		}
+		var tempData = image.clone();
+		tempData.copyChannel(alphaImage,new (lime_math_Rectangle().default)(alphaPoint.x,alphaPoint.y,sourceRect.width,sourceRect.height),new (lime_math_Vector2().default)(sourceRect.x,sourceRect.y),(lime_graphics_ImageChannel().default).ALPHA,(lime_graphics_ImageChannel().default).ALPHA);
+		sourceImage = tempData;
+	}
+	ImageCanvasUtil.convertToCanvas(image,true);
+	if(!mergeAlpha) {
+		if(image.get_transparent() && sourceImage.get_transparent()) {
+			image.buffer.__srcContext.clearRect(destPoint.x + image.offsetX,destPoint.y + image.offsetY,sourceRect.width + image.offsetX,sourceRect.height + image.offsetY);
+		}
+	}
+	ImageCanvasUtil.convertToCanvas(sourceImage);
+	if(sourceImage.buffer.get_src() != null) {
+		image.buffer.__srcContext.globalCompositeOperation = "source-over";
+		image.buffer.__srcContext.drawImage(sourceImage.buffer.get_src(),(Std().default)["int"](sourceRect.x + sourceImage.offsetX),(Std().default)["int"](sourceRect.y + sourceImage.offsetY),(Std().default)["int"](sourceRect.width),(Std().default)["int"](sourceRect.height),(Std().default)["int"](destPoint.x + image.offsetX),(Std().default)["int"](destPoint.y + image.offsetY),(Std().default)["int"](sourceRect.width),(Std().default)["int"](sourceRect.height));
+	}
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.createCanvas = function(image,width,height) {
+	var buffer = image.buffer;
+	if(buffer.__srcCanvas == null) {
+		buffer.__srcCanvas = (js_Browser().default).get_document().createElement("canvas");
+		buffer.__srcCanvas.width = width;
+		buffer.__srcCanvas.height = height;
+		if(!image.get_transparent()) {
+			if(!image.get_transparent()) {
+				buffer.__srcCanvas.setAttribute("moz-opaque","true");
+			}
+			buffer.__srcContext = buffer.__srcCanvas.getContext ("2d", { alpha: false });
+		} else {
+			buffer.__srcContext = buffer.__srcCanvas.getContext("2d");
+		}
+		buffer.__srcContext.mozImageSmoothingEnabled = false;
+		buffer.__srcContext.msImageSmoothingEnabled = false;
+		buffer.__srcContext.imageSmoothingEnabled = false;
+	}
+}
+ImageCanvasUtil.createImageData = function(image) {
+	var buffer = image.buffer;
+	if(buffer.__srcImageData == null) {
+		if(buffer.data == null) {
+			buffer.__srcImageData = buffer.__srcContext.getImageData(0,0,buffer.width,buffer.height);
+		} else {
+			buffer.__srcImageData = buffer.__srcContext.createImageData(buffer.width,buffer.height);
+			buffer.__srcImageData.data.set(buffer.data);
+		}
+		var elements = buffer.__srcImageData.data.buffer;
+		var this1;
+		if(elements != null) {
+			this1 = new Uint8Array(elements);
+		} else {
+			this1 = null;
+		}
+		buffer.data = this1;
+	}
+}
+ImageCanvasUtil.fillRect = function(image,rect,color,format) {
+	ImageCanvasUtil.convertToCanvas(image);
+	var r;
+	var g;
+	var b;
+	var a;
+	if(format == 1) {
+		r = color >> 16 & 255;
+		g = color >> 8 & 255;
+		b = color & 255;
+		if(image.get_transparent()) {
+			a = color >> 24 & 255;
+		} else {
+			a = 255;
+		}
+	} else {
+		r = color >> 24 & 255;
+		g = color >> 16 & 255;
+		b = color >> 8 & 255;
+		if(image.get_transparent()) {
+			a = color & 255;
+		} else {
+			a = 255;
+		}
+	}
+	if(rect.x == 0 && rect.y == 0 && rect.width == image.width && rect.height == image.height) {
+		if(image.get_transparent() && a == 0) {
+			image.buffer.__srcCanvas.width = image.buffer.width;
+			return;
+		}
+	}
+	if(a < 255) {
+		image.buffer.__srcContext.clearRect(rect.x + image.offsetX,rect.y + image.offsetY,rect.width + image.offsetX,rect.height + image.offsetY);
+	}
+	if(a > 0) {
+		image.buffer.__srcContext.fillStyle = "rgba(" + r + ", " + g + ", " + b + ", " + a / 255 + ")";
+		image.buffer.__srcContext.fillRect(rect.x + image.offsetX,rect.y + image.offsetY,rect.width + image.offsetX,rect.height + image.offsetY);
+	}
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.floodFill = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).floodFill(image,x,y,color,format);
+}
+ImageCanvasUtil.getPixel = function(image,x,y,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixel(image,x,y,format);
+}
+ImageCanvasUtil.getPixel32 = function(image,x,y,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixel32(image,x,y,format);
+}
+ImageCanvasUtil.getPixels = function(image,rect,format) {
+	ImageCanvasUtil.convertToData(image);
+	return (lime_graphics_utils_ImageDataUtil().default).getPixels(image,rect,format);
+}
+ImageCanvasUtil.merge = function(image,sourceImage,sourceRect,destPoint,redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier) {
+	ImageCanvasUtil.convertToData(sourceImage);
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).merge(image,sourceImage,sourceRect,destPoint,redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier);
+}
+ImageCanvasUtil.resize = function(image,newWidth,newHeight) {
+	var buffer = image.buffer;
+	if(buffer.__srcCanvas == null) {
+		ImageCanvasUtil.createCanvas(image,newWidth,newHeight);
+		buffer.__srcContext.drawImage(buffer.get_src(),0,0,newWidth,newHeight);
+	} else {
+		ImageCanvasUtil.convertToCanvas(image,true);
+		var sourceCanvas = buffer.__srcCanvas;
+		buffer.__srcCanvas = null;
+		ImageCanvasUtil.createCanvas(image,newWidth,newHeight);
+		buffer.__srcContext.drawImage(sourceCanvas,0,0,newWidth,newHeight);
+	}
+	buffer.__srcImageData = null;
+	buffer.data = null;
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.scroll = function(image,x,y) {
+	if(x % image.width == 0 && y % image.height == 0) {
+		return;
+	}
+	var copy = image.clone();
+	ImageCanvasUtil.convertToCanvas(image,true);
+	image.buffer.__srcContext.clearRect(x,y,image.width,image.height);
+	image.buffer.__srcContext.drawImage(copy.get_src(),x,y);
+	image.dirty = true;
+	image.version++;
+}
+ImageCanvasUtil.setPixel = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixel(image,x,y,color,format);
+}
+ImageCanvasUtil.setPixel32 = function(image,x,y,color,format) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixel32(image,x,y,color,format);
+}
+ImageCanvasUtil.setPixels = function(image,rect,bytePointer,format,endian) {
+	ImageCanvasUtil.convertToData(image);
+	(lime_graphics_utils_ImageDataUtil().default).setPixels(image,rect,bytePointer,format,endian);
+}
+ImageCanvasUtil.sync = function(image,clear) {
+	if(image == null) {
+		return;
+	}
+	if(image.type == (lime_graphics_ImageType().default).CANVAS) {
+		ImageCanvasUtil.convertToCanvas(image,clear);
+	} else {
+		ImageCanvasUtil.convertToData(image,clear);
+	}
+}
+
+
+// Export
+
+exports.default = ImageCanvasUtil;

hGameTest/node_modules/openfl/lib/_gen/lime/graphics/utils/_ImageDataUtil/ImageDataView.js

@@ -0,0 +1,105 @@
+// Class: lime.graphics.utils._ImageDataUtil.ImageDataView
+
+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 ImageDataView = function(image,rect) {
+	this.image = image;
+	if(rect == null) {
+		this.rect = image.get_rect();
+	} else {
+		if(rect.x < 0) {
+			rect.x = 0;
+		}
+		if(rect.y < 0) {
+			rect.y = 0;
+		}
+		if(rect.x + rect.width > image.width) {
+			rect.width = image.width - rect.x;
+		}
+		if(rect.y + rect.height > image.height) {
+			rect.height = image.height - rect.y;
+		}
+		if(rect.width < 0) {
+			rect.width = 0;
+		}
+		if(rect.height < 0) {
+			rect.height = 0;
+		}
+		this.rect = rect;
+	}
+	this.stride = image.buffer.get_stride();
+	this.__update();
+}
+
+// Meta
+
+ImageDataView.__name__ = ["lime","graphics","utils","_ImageDataUtil","ImageDataView"];
+ImageDataView.prototype = {
+	clip: function(x,y,width,height) {
+		this.rect.__contract(x,y,width,height);
+		this.__update();
+	},
+	hasRow: function(y) {
+		if(y >= 0) {
+			return y < this.height;
+		} else {
+			return false;
+		}
+	},
+	offset: function(x,y) {
+		if(x < 0) {
+			this.rect.x += x;
+			if(this.rect.x < 0) {
+				this.rect.x = 0;
+			}
+		} else {
+			this.rect.x += x;
+			this.rect.width -= x;
+		}
+		if(y < 0) {
+			this.rect.y += y;
+			if(this.rect.y < 0) {
+				this.rect.y = 0;
+			}
+		} else {
+			this.rect.y += y;
+			this.rect.height -= y;
+		}
+		this.__update();
+	},
+	row: function(y) {
+		return this.byteOffset + this.stride * y;
+	},
+	__update: function() {
+		this.x = Math.ceil(this.rect.x);
+		this.y = Math.ceil(this.rect.y);
+		this.width = Math.floor(this.rect.width);
+		this.height = Math.floor(this.rect.height);
+		this.byteOffset = this.stride * (this.y + this.image.offsetY) + (this.x + this.image.offsetX) * 4;
+	}
+};
+ImageDataView.prototype.__class__ = $hxClasses["lime.graphics.utils._ImageDataUtil.ImageDataView"] = ImageDataView;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ImageDataView;

hGameTest/node_modules/openfl/lib/_gen/lime/math/Matrix3.js

@@ -0,0 +1,309 @@
+// Class: lime.math.Matrix3
+
+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 lime_math_Vector2() {return require("./../../lime/math/Vector2");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var Matrix3 = function(a,b,c,d,tx,ty) {
+	if(ty == null) {
+		ty = 0;
+	}
+	if(tx == null) {
+		tx = 0;
+	}
+	if(d == null) {
+		d = 1;
+	}
+	if(c == null) {
+		c = 0;
+	}
+	if(b == null) {
+		b = 0;
+	}
+	if(a == null) {
+		a = 1;
+	}
+	this.a = a;
+	this.b = b;
+	this.c = c;
+	this.d = d;
+	this.tx = tx;
+	this.ty = ty;
+}
+
+// Meta
+
+Matrix3.__name__ = ["lime","math","Matrix3"];
+Matrix3.prototype = {
+	clone: function() {
+		return new Matrix3(this.a,this.b,this.c,this.d,this.tx,this.ty);
+	},
+	concat: function(m) {
+		var a1 = this.a * m.a + this.b * m.c;
+		this.b = this.a * m.b + this.b * m.d;
+		this.a = a1;
+		var c1 = this.c * m.a + this.d * m.c;
+		this.d = this.c * m.b + this.d * m.d;
+		this.c = c1;
+		var tx1 = this.tx * m.a + this.ty * m.c + m.tx;
+		this.ty = this.tx * m.b + this.ty * m.d + m.ty;
+		this.tx = tx1;
+	},
+	copyColumnFrom: function(column,vector4) {
+		if(column > 2) {
+			throw new (js__$Boot_HaxeError().default)("Column " + column + " out of bounds (2)");
+		} else if(column == 0) {
+			this.a = vector4.x;
+			this.c = vector4.y;
+		} else if(column == 1) {
+			this.b = vector4.x;
+			this.d = vector4.y;
+		} else {
+			this.tx = vector4.x;
+			this.ty = vector4.y;
+		}
+	},
+	copyColumnTo: function(column,vector4) {
+		if(column > 2) {
+			throw new (js__$Boot_HaxeError().default)("Column " + column + " out of bounds (2)");
+		} else if(column == 0) {
+			vector4.x = this.a;
+			vector4.y = this.c;
+			vector4.z = 0;
+		} else if(column == 1) {
+			vector4.x = this.b;
+			vector4.y = this.d;
+			vector4.z = 0;
+		} else {
+			vector4.x = this.tx;
+			vector4.y = this.ty;
+			vector4.z = 1;
+		}
+	},
+	copyFrom: function(sourceMatrix3) {
+		this.a = sourceMatrix3.a;
+		this.b = sourceMatrix3.b;
+		this.c = sourceMatrix3.c;
+		this.d = sourceMatrix3.d;
+		this.tx = sourceMatrix3.tx;
+		this.ty = sourceMatrix3.ty;
+	},
+	copyRowFrom: function(row,vector4) {
+		if(row > 2) {
+			throw new (js__$Boot_HaxeError().default)("Row " + row + " out of bounds (2)");
+		} else if(row == 0) {
+			this.a = vector4.x;
+			this.c = vector4.y;
+		} else if(row == 1) {
+			this.b = vector4.x;
+			this.d = vector4.y;
+		} else {
+			this.tx = vector4.x;
+			this.ty = vector4.y;
+		}
+	},
+	copyRowTo: function(row,vector4) {
+		if(row > 2) {
+			throw new (js__$Boot_HaxeError().default)("Row " + row + " out of bounds (2)");
+		} else if(row == 0) {
+			vector4.x = this.a;
+			vector4.y = this.b;
+			vector4.z = this.tx;
+		} else if(row == 1) {
+			vector4.x = this.c;
+			vector4.y = this.d;
+			vector4.z = this.ty;
+		} else {
+			vector4.setTo(0,0,1);
+		}
+	},
+	createBox: function(scaleX,scaleY,rotation,tx,ty) {
+		if(ty == null) {
+			ty = 0;
+		}
+		if(tx == null) {
+			tx = 0;
+		}
+		if(rotation == null) {
+			rotation = 0;
+		}
+		this.a = scaleX;
+		this.d = scaleY;
+		this.b = rotation;
+		this.tx = tx;
+		this.ty = ty;
+	},
+	createGradientBox: function(width,height,rotation,tx,ty) {
+		if(ty == null) {
+			ty = 0;
+		}
+		if(tx == null) {
+			tx = 0;
+		}
+		if(rotation == null) {
+			rotation = 0;
+		}
+		this.a = width / 1638.4;
+		this.d = height / 1638.4;
+		if(rotation != 0) {
+			var cos = Math.cos(rotation);
+			var sin = Math.sin(rotation);
+			this.b = sin * this.d;
+			this.c = -sin * this.a;
+			this.a *= cos;
+			this.d *= cos;
+		} else {
+			this.b = 0;
+			this.c = 0;
+		}
+		this.tx = tx + width / 2;
+		this.ty = ty + height / 2;
+	},
+	equals: function(Matrix3) {
+		if(Matrix3 != null && this.tx == Matrix3.tx && this.ty == Matrix3.ty && this.a == Matrix3.a && this.b == Matrix3.b && this.c == Matrix3.c) {
+			return this.d == Matrix3.d;
+		} else {
+			return false;
+		}
+	},
+	deltaTransformVector2: function(Vector2) {
+		return new (lime_math_Vector2().default)(Vector2.x * this.a + Vector2.y * this.c,Vector2.x * this.b + Vector2.y * this.d);
+	},
+	identity: function() {
+		this.a = 1;
+		this.b = 0;
+		this.c = 0;
+		this.d = 1;
+		this.tx = 0;
+		this.ty = 0;
+	},
+	invert: function() {
+		var norm = this.a * this.d - this.b * this.c;
+		if(norm == 0) {
+			this.a = this.b = this.c = this.d = 0;
+			this.tx = -this.tx;
+			this.ty = -this.ty;
+		} else {
+			norm = 1.0 / norm;
+			var a1 = this.d * norm;
+			this.d = this.a * norm;
+			this.a = a1;
+			this.b *= -norm;
+			this.c *= -norm;
+			var tx1 = -this.a * this.tx - this.c * this.ty;
+			this.ty = -this.b * this.tx - this.d * this.ty;
+			this.tx = tx1;
+		}
+		return this;
+	},
+	mult: function(m) {
+		var result = this.clone();
+		result.concat(m);
+		return result;
+	},
+	rotate: function(theta) {
+		var cos = Math.cos(theta);
+		var sin = Math.sin(theta);
+		var a1 = this.a * cos - this.b * sin;
+		this.b = this.a * sin + this.b * cos;
+		this.a = a1;
+		var c1 = this.c * cos - this.d * sin;
+		this.d = this.c * sin + this.d * cos;
+		this.c = c1;
+		var tx1 = this.tx * cos - this.ty * sin;
+		this.ty = this.tx * sin + this.ty * cos;
+		this.tx = tx1;
+	},
+	scale: function(sx,sy) {
+		this.a *= sx;
+		this.b *= sy;
+		this.c *= sx;
+		this.d *= sy;
+		this.tx *= sx;
+		this.ty *= sy;
+	},
+	setRotation: function(theta,scale) {
+		if(scale == null) {
+			scale = 1;
+		}
+		this.a = Math.cos(theta) * scale;
+		this.c = Math.sin(theta) * scale;
+		this.b = -this.c;
+		this.d = this.a;
+	},
+	setTo: function(a,b,c,d,tx,ty) {
+		this.a = a;
+		this.b = b;
+		this.c = c;
+		this.d = d;
+		this.tx = tx;
+		this.ty = ty;
+	},
+	to3DString: function(roundPixels) {
+		if(roundPixels == null) {
+			roundPixels = false;
+		}
+		if(roundPixels) {
+			return "Matrix33d(" + this.a + ", " + this.b + ", " + "0, 0, " + this.c + ", " + this.d + ", " + "0, 0, 0, 0, 1, 0, " + (Std().default)["int"](this.tx) + ", " + (Std().default)["int"](this.ty) + ", 0, 1)";
+		} else {
+			return "Matrix33d(" + this.a + ", " + this.b + ", " + "0, 0, " + this.c + ", " + this.d + ", " + "0, 0, 0, 0, 1, 0, " + this.tx + ", " + this.ty + ", 0, 1)";
+		}
+	},
+	toMozString: function() {
+		return "Matrix3(" + this.a + ", " + this.b + ", " + this.c + ", " + this.d + ", " + this.tx + "px, " + this.ty + "px)";
+	},
+	toString: function() {
+		return "Matrix3(" + this.a + ", " + this.b + ", " + this.c + ", " + this.d + ", " + this.tx + ", " + this.ty + ")";
+	},
+	transformVector2: function(pos) {
+		return new (lime_math_Vector2().default)(this.__transformX(pos),this.__transformY(pos));
+	},
+	translate: function(dx,dy) {
+		this.tx += dx;
+		this.ty += dy;
+	},
+	__cleanValues: function() {
+		this.a = Math.round(this.a * 1000) / 1000;
+		this.b = Math.round(this.b * 1000) / 1000;
+		this.c = Math.round(this.c * 1000) / 1000;
+		this.d = Math.round(this.d * 1000) / 1000;
+		this.tx = Math.round(this.tx * 10) / 10;
+		this.ty = Math.round(this.ty * 10) / 10;
+	},
+	__transformX: function(pos) {
+		return pos.x * this.a + pos.y * this.c + this.tx;
+	},
+	__transformY: function(pos) {
+		return pos.x * this.b + pos.y * this.d + this.ty;
+	},
+	__translateTransformed: function(pos) {
+		this.tx = this.__transformX(pos);
+		this.ty = this.__transformY(pos);
+	}
+};
+Matrix3.prototype.__class__ = $hxClasses["lime.math.Matrix3"] = Matrix3;
+
+// Init
+
+
+
+// Statics
+
+
+Matrix3.__identity = new Matrix3()
+
+// Export
+
+exports.default = Matrix3;

hGameTest/node_modules/openfl/lib/_gen/lime/math/Rectangle.js

@@ -0,0 +1,307 @@
+// Class: lime.math.Rectangle
+
+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 lime_math_Vector2() {return require("./../../lime/math/Vector2");}
+
+// Constructor
+
+var Rectangle = function(x,y,width,height) {
+	if(height == null) {
+		height = 0;
+	}
+	if(width == null) {
+		width = 0;
+	}
+	if(y == null) {
+		y = 0;
+	}
+	if(x == null) {
+		x = 0;
+	}
+	this.x = x;
+	this.y = y;
+	this.width = width;
+	this.height = height;
+}
+
+// Meta
+
+Rectangle.__name__ = ["lime","math","Rectangle"];
+Rectangle.prototype = {
+	clone: function() {
+		return new Rectangle(this.x,this.y,this.width,this.height);
+	},
+	contains: function(x,y) {
+		if(x >= this.x && y >= this.y && x < this.get_right()) {
+			return y < this.get_bottom();
+		} else {
+			return false;
+		}
+	},
+	containsPoint: function(point) {
+		return this.contains(point.x,point.y);
+	},
+	containsRect: function(rect) {
+		if(rect.width <= 0 || rect.height <= 0) {
+			if(rect.x > this.x && rect.y > this.y && rect.get_right() < this.get_right()) {
+				return rect.get_bottom() < this.get_bottom();
+			} else {
+				return false;
+			}
+		} else if(rect.x >= this.x && rect.y >= this.y && rect.get_right() <= this.get_right()) {
+			return rect.get_bottom() <= this.get_bottom();
+		} else {
+			return false;
+		}
+	},
+	copyFrom: function(sourceRect) {
+		this.x = sourceRect.x;
+		this.y = sourceRect.y;
+		this.width = sourceRect.width;
+		this.height = sourceRect.height;
+	},
+	equals: function(toCompare) {
+		if(toCompare != null && this.x == toCompare.x && this.y == toCompare.y && this.width == toCompare.width) {
+			return this.height == toCompare.height;
+		} else {
+			return false;
+		}
+	},
+	inflate: function(dx,dy) {
+		this.x -= dx;
+		this.width += dx * 2;
+		this.y -= dy;
+		this.height += dy * 2;
+	},
+	inflatePoint: function(point) {
+		this.inflate(point.x,point.y);
+	},
+	intersection: function(toIntersect) {
+		var x0 = this.x < toIntersect.x ? toIntersect.x : this.x;
+		var x1 = this.get_right() > toIntersect.get_right() ? toIntersect.get_right() : this.get_right();
+		if(x1 <= x0) {
+			return new Rectangle();
+		}
+		var y0 = this.y < toIntersect.y ? toIntersect.y : this.y;
+		var y1 = this.get_bottom() > toIntersect.get_bottom() ? toIntersect.get_bottom() : this.get_bottom();
+		if(y1 <= y0) {
+			return new Rectangle();
+		}
+		return new Rectangle(x0,y0,x1 - x0,y1 - y0);
+	},
+	intersects: function(toIntersect) {
+		var x0 = this.x < toIntersect.x ? toIntersect.x : this.x;
+		var x1 = this.get_right() > toIntersect.get_right() ? toIntersect.get_right() : this.get_right();
+		if(x1 <= x0) {
+			return false;
+		}
+		var y0 = this.y < toIntersect.y ? toIntersect.y : this.y;
+		var y1 = this.get_bottom() > toIntersect.get_bottom() ? toIntersect.get_bottom() : this.get_bottom();
+		return y1 > y0;
+	},
+	isEmpty: function() {
+		if(!(this.width <= 0)) {
+			return this.height <= 0;
+		} else {
+			return true;
+		}
+	},
+	offset: function(dx,dy) {
+		this.x += dx;
+		this.y += dy;
+	},
+	offsetPoint: function(point) {
+		this.x += point.x;
+		this.y += point.y;
+	},
+	setEmpty: function() {
+		this.x = this.y = this.width = this.height = 0;
+	},
+	setTo: function(xa,ya,widtha,heighta) {
+		this.x = xa;
+		this.y = ya;
+		this.width = widtha;
+		this.height = heighta;
+	},
+	transform: function(m) {
+		var tx0 = m.a * this.x + m.c * this.y;
+		var tx1 = tx0;
+		var ty0 = m.b * this.x + m.d * this.y;
+		var ty1 = ty0;
+		var tx = m.a * (this.x + this.width) + m.c * this.y;
+		var ty = m.b * (this.x + this.width) + m.d * this.y;
+		if(tx < tx0) {
+			tx0 = tx;
+		}
+		if(ty < ty0) {
+			ty0 = ty;
+		}
+		if(tx > tx1) {
+			tx1 = tx;
+		}
+		if(ty > ty1) {
+			ty1 = ty;
+		}
+		tx = m.a * (this.x + this.width) + m.c * (this.y + this.height);
+		ty = m.b * (this.x + this.width) + m.d * (this.y + this.height);
+		if(tx < tx0) {
+			tx0 = tx;
+		}
+		if(ty < ty0) {
+			ty0 = ty;
+		}
+		if(tx > tx1) {
+			tx1 = tx;
+		}
+		if(ty > ty1) {
+			ty1 = ty;
+		}
+		tx = m.a * this.x + m.c * (this.y + this.height);
+		ty = m.b * this.x + m.d * (this.y + this.height);
+		if(tx < tx0) {
+			tx0 = tx;
+		}
+		if(ty < ty0) {
+			ty0 = ty;
+		}
+		if(tx > tx1) {
+			tx1 = tx;
+		}
+		if(ty > ty1) {
+			ty1 = ty;
+		}
+		return new Rectangle(tx0 + m.tx,ty0 + m.ty,tx1 - tx0,ty1 - ty0);
+	},
+	union: function(toUnion) {
+		if(this.width == 0 || this.height == 0) {
+			return toUnion.clone();
+		} else if(toUnion.width == 0 || toUnion.height == 0) {
+			return this.clone();
+		}
+		var x0 = this.x > toUnion.x ? toUnion.x : this.x;
+		var x1 = this.get_right() < toUnion.get_right() ? toUnion.get_right() : this.get_right();
+		var y0 = this.y > toUnion.y ? toUnion.y : this.y;
+		var y1 = this.get_bottom() < toUnion.get_bottom() ? toUnion.get_bottom() : this.get_bottom();
+		return new Rectangle(x0,y0,x1 - x0,y1 - y0);
+	},
+	__contract: function(x,y,width,height) {
+		if(this.width == 0 && this.height == 0) {
+			return;
+		}
+		if(this.x < x) {
+			this.x = x;
+		}
+		if(this.y < y) {
+			this.y = y;
+		}
+		if(this.get_right() > x + width) {
+			this.width = x + width - this.x;
+		}
+		if(this.get_bottom() > y + height) {
+			this.height = y + height - this.y;
+		}
+	},
+	__expand: function(x,y,width,height) {
+		if(this.width == 0 && this.height == 0) {
+			this.x = x;
+			this.y = y;
+			this.width = width;
+			this.height = height;
+			return;
+		}
+		var cacheRight = this.get_right();
+		var cacheBottom = this.get_bottom();
+		if(this.x > x) {
+			this.x = x;
+		}
+		if(this.y > y) {
+			this.y = y;
+		}
+		if(cacheRight < x + width) {
+			this.width = x + width - this.x;
+		}
+		if(cacheBottom < y + height) {
+			this.height = y + height - this.y;
+		}
+	},
+	__toFlashRectangle: function() {
+		return null;
+	},
+	get_bottom: function() {
+		return this.y + this.height;
+	},
+	set_bottom: function(b) {
+		this.height = b - this.y;
+		return b;
+	},
+	get_bottomRight: function() {
+		return new (lime_math_Vector2().default)(this.x + this.width,this.y + this.height);
+	},
+	set_bottomRight: function(p) {
+		this.width = p.x - this.x;
+		this.height = p.y - this.y;
+		return p.clone();
+	},
+	get_left: function() {
+		return this.x;
+	},
+	set_left: function(l) {
+		this.width -= l - this.x;
+		this.x = l;
+		return l;
+	},
+	get_right: function() {
+		return this.x + this.width;
+	},
+	set_right: function(r) {
+		this.width = r - this.x;
+		return r;
+	},
+	get_size: function() {
+		return new (lime_math_Vector2().default)(this.width,this.height);
+	},
+	set_size: function(p) {
+		this.width = p.x;
+		this.height = p.y;
+		return p.clone();
+	},
+	get_top: function() {
+		return this.y;
+	},
+	set_top: function(t) {
+		this.height -= t - this.y;
+		this.y = t;
+		return t;
+	},
+	get_topLeft: function() {
+		return new (lime_math_Vector2().default)(this.x,this.y);
+	},
+	set_topLeft: function(p) {
+		this.x = p.x;
+		this.y = p.y;
+		return p.clone();
+	}
+};
+Rectangle.prototype.__class__ = $hxClasses["lime.math.Rectangle"] = Rectangle;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Rectangle;

hGameTest/node_modules/openfl/lib/_gen/lime/math/Vector2.js

@@ -0,0 +1,94 @@
+// Class: lime.math.Vector2
+
+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 Vector2 = function(x,y) {
+	if(y == null) {
+		y = 0;
+	}
+	if(x == null) {
+		x = 0;
+	}
+	this.x = x;
+	this.y = y;
+}
+
+// Meta
+
+Vector2.__name__ = ["lime","math","Vector2"];
+Vector2.prototype = {
+	add: function(v) {
+		return new Vector2(v.x + this.x,v.y + this.y);
+	},
+	clone: function() {
+		return new Vector2(this.x,this.y);
+	},
+	equals: function(toCompare) {
+		if(toCompare != null && toCompare.x == this.x) {
+			return toCompare.y == this.y;
+		} else {
+			return false;
+		}
+	},
+	normalize: function(thickness) {
+		if(this.x == 0 && this.y == 0) {
+			return;
+		} else {
+			var norm = thickness / Math.sqrt(this.x * this.x + this.y * this.y);
+			this.x *= norm;
+			this.y *= norm;
+		}
+	},
+	offset: function(dx,dy) {
+		this.x += dx;
+		this.y += dy;
+	},
+	setTo: function(xa,ya) {
+		this.x = xa;
+		this.y = ya;
+	},
+	subtract: function(v) {
+		return new Vector2(this.x - v.x,this.y - v.y);
+	},
+	__toFlashPoint: function() {
+		return null;
+	},
+	get_length: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	}
+};
+Vector2.prototype.__class__ = $hxClasses["lime.math.Vector2"] = Vector2;
+
+// Init
+
+
+
+// Statics
+
+Vector2.distance = function(pt1,pt2) {
+	var dx = pt1.x - pt2.x;
+	var dy = pt1.y - pt2.y;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+Vector2.interpolate = function(pt1,pt2,f) {
+	return new Vector2(pt2.x + f * (pt1.x - pt2.x),pt2.y + f * (pt1.y - pt2.y));
+}
+Vector2.polar = function(len,angle) {
+	return new Vector2(len * Math.cos(angle),len * Math.sin(angle));
+}
+
+
+// Export
+
+exports.default = Vector2;

hGameTest/node_modules/openfl/lib/_gen/lime/math/Vector4.js

@@ -0,0 +1,170 @@
+// Class: lime.math.Vector4
+
+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 Vector4 = function(x,y,z,w) {
+	if(w == null) {
+		w = 0.;
+	}
+	if(z == null) {
+		z = 0.;
+	}
+	if(y == null) {
+		y = 0.;
+	}
+	if(x == null) {
+		x = 0.;
+	}
+	this.w = w;
+	this.x = x;
+	this.y = y;
+	this.z = z;
+}
+
+// Meta
+
+Vector4.__name__ = ["lime","math","Vector4"];
+Vector4.prototype = {
+	add: function(a) {
+		return new Vector4(this.x + a.x,this.y + a.y,this.z + a.z);
+	},
+	clone: function() {
+		return new Vector4(this.x,this.y,this.z,this.w);
+	},
+	copyFrom: function(sourceVector4) {
+		this.x = sourceVector4.x;
+		this.y = sourceVector4.y;
+		this.z = sourceVector4.z;
+	},
+	crossProduct: function(a) {
+		return new Vector4(this.y * a.z - this.z * a.y,this.z * a.x - this.x * a.z,this.x * a.y - this.y * a.x,1);
+	},
+	decrementBy: function(a) {
+		this.x -= a.x;
+		this.y -= a.y;
+		this.z -= a.z;
+	},
+	dotProduct: function(a) {
+		return this.x * a.x + this.y * a.y + this.z * a.z;
+	},
+	equals: function(toCompare,allFour) {
+		if(allFour == null) {
+			allFour = false;
+		}
+		if(this.x == toCompare.x && this.y == toCompare.y && this.z == toCompare.z) {
+			if(!(!allFour)) {
+				return this.w == toCompare.w;
+			} else {
+				return true;
+			}
+		} else {
+			return false;
+		}
+	},
+	incrementBy: function(a) {
+		this.x += a.x;
+		this.y += a.y;
+		this.z += a.z;
+	},
+	nearEquals: function(toCompare,tolerance,allFour) {
+		if(allFour == null) {
+			allFour = false;
+		}
+		if(Math.abs(this.x - toCompare.x) < tolerance && Math.abs(this.y - toCompare.y) < tolerance && Math.abs(this.z - toCompare.z) < tolerance) {
+			if(!(!allFour)) {
+				return Math.abs(this.w - toCompare.w) < tolerance;
+			} else {
+				return true;
+			}
+		} else {
+			return false;
+		}
+	},
+	negate: function() {
+		this.x *= -1;
+		this.y *= -1;
+		this.z *= -1;
+	},
+	normalize: function() {
+		var l = this.get_length();
+		if(l != 0) {
+			this.x /= l;
+			this.y /= l;
+			this.z /= l;
+		}
+		return l;
+	},
+	project: function() {
+		this.x /= this.w;
+		this.y /= this.w;
+		this.z /= this.w;
+	},
+	scaleBy: function(s) {
+		this.x *= s;
+		this.y *= s;
+		this.z *= s;
+	},
+	setTo: function(xa,ya,za) {
+		this.x = xa;
+		this.y = ya;
+		this.z = za;
+	},
+	subtract: function(a) {
+		return new Vector4(this.x - a.x,this.y - a.y,this.z - a.z);
+	},
+	toString: function() {
+		return "Vector4(" + this.x + ", " + this.y + ", " + this.z + ")";
+	},
+	get_length: function() {
+		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+	},
+	get_lengthSquared: function() {
+		return this.x * this.x + this.y * this.y + this.z * this.z;
+	}
+};
+Vector4.prototype.__class__ = $hxClasses["lime.math.Vector4"] = Vector4;
+
+// Init
+
+
+
+// Statics
+
+Vector4.angleBetween = function(a,b) {
+	var a0 = a.clone();
+	a0.normalize();
+	var b0 = b.clone();
+	b0.normalize();
+	return Math.acos(a0.dotProduct(b0));
+}
+Vector4.distance = function(pt1,pt2) {
+	var x = pt2.x - pt1.x;
+	var y = pt2.y - pt1.y;
+	var z = pt2.z - pt1.z;
+	return Math.sqrt(x * x + y * y + z * z);
+}
+Vector4.get_X_AXIS = function() {
+	return new Vector4(1,0,0);
+}
+Vector4.get_Y_AXIS = function() {
+	return new Vector4(0,1,0);
+}
+Vector4.get_Z_AXIS = function() {
+	return new Vector4(0,0,1);
+}
+
+
+// Export
+
+exports.default = Vector4;

hGameTest/node_modules/openfl/lib/_gen/lime/math/_ColorMatrix/ColorMatrix_Impl_.js

@@ -0,0 +1,247 @@
+// Class: lime.math._ColorMatrix.ColorMatrix_Impl_
+
+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 Std() {return require("./../../../Std");}
+
+// Constructor
+
+var ColorMatrix_Impl_ = function(){}
+
+// Meta
+
+ColorMatrix_Impl_.__name__ = ["lime","math","_ColorMatrix","ColorMatrix_Impl_"];
+ColorMatrix_Impl_.prototype = {
+	
+};
+ColorMatrix_Impl_.prototype.__class__ = $hxClasses["lime.math._ColorMatrix.ColorMatrix_Impl_"] = ColorMatrix_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ColorMatrix_Impl_._new = function(data) {
+	var this1;
+	if(data != null && data.length == 20) {
+		this1 = data;
+	} else {
+		var array = ColorMatrix_Impl_.__identity;
+		var this2;
+		if(array != null) {
+			this2 = new Float32Array(array);
+		} else {
+			this2 = null;
+		}
+		this1 = this2;
+	}
+	return this1;
+}
+ColorMatrix_Impl_.clone = function(this1) {
+	var this2;
+	if(this1 != null) {
+		this2 = new Float32Array(this1);
+	} else {
+		this2 = null;
+	}
+	return ColorMatrix_Impl_._new(this2);
+}
+ColorMatrix_Impl_.concat = function(this1,second) {
+	var _g = this1;
+	_g[0] += second[0];
+	var _g1 = this1;
+	_g1[6] += second[6];
+	var _g2 = this1;
+	_g2[12] += second[12];
+	var _g3 = this1;
+	_g3[18] += second[18];
+}
+ColorMatrix_Impl_.copyFrom = function(this1,other) {
+	this1.set(other);
+}
+ColorMatrix_Impl_.identity = function(this1) {
+	this1[0] = 1;
+	this1[1] = 0;
+	this1[2] = 0;
+	this1[3] = 0;
+	this1[4] = 0;
+	this1[5] = 0;
+	this1[6] = 1;
+	this1[7] = 0;
+	this1[8] = 0;
+	this1[9] = 0;
+	this1[10] = 0;
+	this1[11] = 0;
+	this1[12] = 1;
+	this1[13] = 0;
+	this1[14] = 0;
+	this1[15] = 0;
+	this1[16] = 0;
+	this1[17] = 0;
+	this1[18] = 1;
+	this1[19] = 0;
+}
+ColorMatrix_Impl_.getAlphaTable = function(this1) {
+	if(ColorMatrix_Impl_.__alphaTable == null) {
+		var this2 = new Uint8Array(256);
+		ColorMatrix_Impl_.__alphaTable = this2;
+	}
+	var value;
+	ColorMatrix_Impl_.__alphaTable[0] = 0;
+	var _g = 1;
+	while(_g < 256) {
+		var i = _g++;
+		value = Math.floor(i * this1[18] + this1[19] * 255);
+		if(value > 255) {
+			value = 255;
+		}
+		if(value < 0) {
+			value = 0;
+		}
+		ColorMatrix_Impl_.__alphaTable[i] = value;
+	}
+	return ColorMatrix_Impl_.__alphaTable;
+}
+ColorMatrix_Impl_.getBlueTable = function(this1) {
+	if(ColorMatrix_Impl_.__blueTable == null) {
+		var this2 = new Uint8Array(256);
+		ColorMatrix_Impl_.__blueTable = this2;
+	}
+	var value;
+	var _g = 0;
+	while(_g < 256) {
+		var i = _g++;
+		value = Math.floor(i * this1[12] + this1[14] * 255);
+		if(value > 255) {
+			value = 255;
+		}
+		if(value < 0) {
+			value = 0;
+		}
+		ColorMatrix_Impl_.__blueTable[i] = value;
+	}
+	return ColorMatrix_Impl_.__blueTable;
+}
+ColorMatrix_Impl_.getGreenTable = function(this1) {
+	if(ColorMatrix_Impl_.__greenTable == null) {
+		var this2 = new Uint8Array(256);
+		ColorMatrix_Impl_.__greenTable = this2;
+	}
+	var value;
+	var _g = 0;
+	while(_g < 256) {
+		var i = _g++;
+		value = Math.floor(i * this1[6] + this1[9] * 255);
+		if(value > 255) {
+			value = 255;
+		}
+		if(value < 0) {
+			value = 0;
+		}
+		ColorMatrix_Impl_.__greenTable[i] = value;
+	}
+	return ColorMatrix_Impl_.__greenTable;
+}
+ColorMatrix_Impl_.getRedTable = function(this1) {
+	if(ColorMatrix_Impl_.__redTable == null) {
+		var this2 = new Uint8Array(256);
+		ColorMatrix_Impl_.__redTable = this2;
+	}
+	var value;
+	var _g = 0;
+	while(_g < 256) {
+		var i = _g++;
+		value = Math.floor(i * this1[0] + this1[4] * 255);
+		if(value > 255) {
+			value = 255;
+		}
+		if(value < 0) {
+			value = 0;
+		}
+		ColorMatrix_Impl_.__redTable[i] = value;
+	}
+	return ColorMatrix_Impl_.__redTable;
+}
+ColorMatrix_Impl_.__toFlashColorTransform = function(this1) {
+	return null;
+}
+ColorMatrix_Impl_.get_alphaMultiplier = function(this1) {
+	return this1[18];
+}
+ColorMatrix_Impl_.set_alphaMultiplier = function(this1,value) {
+	return this1[18] = value;
+}
+ColorMatrix_Impl_.get_alphaOffset = function(this1) {
+	return this1[19] * 255;
+}
+ColorMatrix_Impl_.set_alphaOffset = function(this1,value) {
+	return this1[19] = value / 255;
+}
+ColorMatrix_Impl_.get_blueMultiplier = function(this1) {
+	return this1[12];
+}
+ColorMatrix_Impl_.set_blueMultiplier = function(this1,value) {
+	return this1[12] = value;
+}
+ColorMatrix_Impl_.get_blueOffset = function(this1) {
+	return this1[14] * 255;
+}
+ColorMatrix_Impl_.set_blueOffset = function(this1,value) {
+	return this1[14] = value / 255;
+}
+ColorMatrix_Impl_.get_color = function(this1) {
+	return (Std().default)["int"](this1[4] * 255) << 16 | (Std().default)["int"](this1[9] * 255) << 8 | (Std().default)["int"](this1[14] * 255);
+}
+ColorMatrix_Impl_.set_color = function(this1,value) {
+	this1[4] = (value >> 16 & 255) / 255;
+	this1[9] = (value >> 8 & 255) / 255;
+	this1[14] = (value & 255) / 255;
+	this1[0] = 0;
+	this1[6] = 0;
+	this1[12] = 0;
+	return ColorMatrix_Impl_.get_color(this1);
+}
+ColorMatrix_Impl_.get_greenMultiplier = function(this1) {
+	return this1[6];
+}
+ColorMatrix_Impl_.set_greenMultiplier = function(this1,value) {
+	return this1[6] = value;
+}
+ColorMatrix_Impl_.get_greenOffset = function(this1) {
+	return this1[9] * 255;
+}
+ColorMatrix_Impl_.set_greenOffset = function(this1,value) {
+	return this1[9] = value / 255;
+}
+ColorMatrix_Impl_.get_redMultiplier = function(this1) {
+	return this1[0];
+}
+ColorMatrix_Impl_.set_redMultiplier = function(this1,value) {
+	return this1[0] = value;
+}
+ColorMatrix_Impl_.get_redOffset = function(this1) {
+	return this1[4] * 255;
+}
+ColorMatrix_Impl_.set_redOffset = function(this1,value) {
+	return this1[4] = value / 255;
+}
+ColorMatrix_Impl_.get = function(this1,index) {
+	return this1[index];
+}
+ColorMatrix_Impl_.set = function(this1,index,value) {
+	return this1[index] = value;
+}
+ColorMatrix_Impl_.__identity = [1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,0.0,1.0,0.0]
+
+// Export
+
+exports.default = ColorMatrix_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/math/_Matrix4/Matrix4_Impl_.js

@@ -0,0 +1,642 @@
+// Class: lime.math._Matrix4.Matrix4_Impl_
+
+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 lime_utils_Log() {return require("./../../../lime/utils/Log");}
+function js_Boot() {return require("./../../../js/Boot");}
+function lime_math_Vector4() {return require("./../../../lime/math/Vector4");}
+
+// Constructor
+
+var Matrix4_Impl_ = function(){}
+
+// Meta
+
+Matrix4_Impl_.__name__ = ["lime","math","_Matrix4","Matrix4_Impl_"];
+Matrix4_Impl_.prototype = {
+	
+};
+Matrix4_Impl_.prototype.__class__ = $hxClasses["lime.math._Matrix4.Matrix4_Impl_"] = Matrix4_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Matrix4_Impl_._new = function(data) {
+	var this1;
+	if(data != null && data.length == 16) {
+		this1 = data;
+	} else {
+		var array = Matrix4_Impl_.__identity;
+		var this2;
+		if(array != null) {
+			this2 = new Float32Array(array);
+		} else {
+			this2 = null;
+		}
+		this1 = this2;
+	}
+	return this1;
+}
+Matrix4_Impl_.append = function(this1,lhs) {
+	var m111 = this1[0];
+	var m121 = this1[4];
+	var m131 = this1[8];
+	var m141 = this1[12];
+	var m112 = this1[1];
+	var m122 = this1[5];
+	var m132 = this1[9];
+	var m142 = this1[13];
+	var m113 = this1[2];
+	var m123 = this1[6];
+	var m133 = this1[10];
+	var m143 = this1[14];
+	var m114 = this1[3];
+	var m124 = this1[7];
+	var m134 = this1[11];
+	var m144 = this1[15];
+	var m211 = Matrix4_Impl_.get(lhs,0);
+	var m221 = Matrix4_Impl_.get(lhs,4);
+	var m231 = Matrix4_Impl_.get(lhs,8);
+	var m241 = Matrix4_Impl_.get(lhs,12);
+	var m212 = Matrix4_Impl_.get(lhs,1);
+	var m222 = Matrix4_Impl_.get(lhs,5);
+	var m232 = Matrix4_Impl_.get(lhs,9);
+	var m242 = Matrix4_Impl_.get(lhs,13);
+	var m213 = Matrix4_Impl_.get(lhs,2);
+	var m223 = Matrix4_Impl_.get(lhs,6);
+	var m233 = Matrix4_Impl_.get(lhs,10);
+	var m243 = Matrix4_Impl_.get(lhs,14);
+	var m214 = Matrix4_Impl_.get(lhs,3);
+	var m224 = Matrix4_Impl_.get(lhs,7);
+	var m234 = Matrix4_Impl_.get(lhs,11);
+	var m244 = Matrix4_Impl_.get(lhs,15);
+	this1[0] = m111 * m211 + m112 * m221 + m113 * m231 + m114 * m241;
+	this1[1] = m111 * m212 + m112 * m222 + m113 * m232 + m114 * m242;
+	this1[2] = m111 * m213 + m112 * m223 + m113 * m233 + m114 * m243;
+	this1[3] = m111 * m214 + m112 * m224 + m113 * m234 + m114 * m244;
+	this1[4] = m121 * m211 + m122 * m221 + m123 * m231 + m124 * m241;
+	this1[5] = m121 * m212 + m122 * m222 + m123 * m232 + m124 * m242;
+	this1[6] = m121 * m213 + m122 * m223 + m123 * m233 + m124 * m243;
+	this1[7] = m121 * m214 + m122 * m224 + m123 * m234 + m124 * m244;
+	this1[8] = m131 * m211 + m132 * m221 + m133 * m231 + m134 * m241;
+	this1[9] = m131 * m212 + m132 * m222 + m133 * m232 + m134 * m242;
+	this1[10] = m131 * m213 + m132 * m223 + m133 * m233 + m134 * m243;
+	this1[11] = m131 * m214 + m132 * m224 + m133 * m234 + m134 * m244;
+	this1[12] = m141 * m211 + m142 * m221 + m143 * m231 + m144 * m241;
+	this1[13] = m141 * m212 + m142 * m222 + m143 * m232 + m144 * m242;
+	this1[14] = m141 * m213 + m142 * m223 + m143 * m233 + m144 * m243;
+	this1[15] = m141 * m214 + m142 * m224 + m143 * m234 + m144 * m244;
+}
+Matrix4_Impl_.appendRotation = function(this1,degrees,axis,pivotPoint) {
+	var m = Matrix4_Impl_.__getAxisRotation(this1,axis.x,axis.y,axis.z,degrees);
+	if(pivotPoint != null) {
+		var p = pivotPoint;
+		Matrix4_Impl_.appendTranslation(m,p.x,p.y,p.z);
+	}
+	Matrix4_Impl_.append(this1,m);
+}
+Matrix4_Impl_.appendScale = function(this1,xScale,yScale,zScale) {
+	var array = [xScale,0.0,0.0,0.0,0.0,yScale,0.0,0.0,0.0,0.0,zScale,0.0,0.0,0.0,0.0,1.0];
+	var this2;
+	if(array != null) {
+		this2 = new Float32Array(array);
+	} else {
+		this2 = null;
+	}
+	Matrix4_Impl_.append(this1,Matrix4_Impl_._new(this2));
+}
+Matrix4_Impl_.appendTranslation = function(this1,x,y,z) {
+	this1[12] += x;
+	this1[13] += y;
+	this1[14] += z;
+}
+Matrix4_Impl_.clone = function(this1) {
+	var this2;
+	if(this1 != null) {
+		this2 = new Float32Array(this1);
+	} else {
+		this2 = null;
+	}
+	return Matrix4_Impl_._new(this2);
+}
+Matrix4_Impl_.copyColumnFrom = function(this1,column,vector) {
+	switch(column) {
+	case 0:
+		this1[0] = vector.x;
+		this1[1] = vector.y;
+		this1[2] = vector.z;
+		this1[3] = vector.w;
+		break;
+	case 1:
+		this1[4] = vector.x;
+		this1[5] = vector.y;
+		this1[6] = vector.z;
+		this1[7] = vector.w;
+		break;
+	case 2:
+		this1[8] = vector.x;
+		this1[9] = vector.y;
+		this1[10] = vector.z;
+		this1[11] = vector.w;
+		break;
+	case 3:
+		this1[12] = vector.x;
+		this1[13] = vector.y;
+		this1[14] = vector.z;
+		this1[15] = vector.w;
+		break;
+	default:
+		(lime_utils_Log().default).error("Column " + column + " out of bounds [0, ..., 3]",{ fileName : "Matrix4.hx", lineNumber : 139, className : "lime.math._Matrix4.Matrix4_Impl_", methodName : "copyColumnFrom"});
+	}
+}
+Matrix4_Impl_.copyColumnTo = function(this1,column,vector) {
+	switch(column) {
+	case 0:
+		vector.x = this1[0];
+		vector.y = this1[1];
+		vector.z = this1[2];
+		vector.w = this1[3];
+		break;
+	case 1:
+		vector.x = this1[4];
+		vector.y = this1[5];
+		vector.z = this1[6];
+		vector.w = this1[7];
+		break;
+	case 2:
+		vector.x = this1[8];
+		vector.y = this1[9];
+		vector.z = this1[10];
+		vector.w = this1[11];
+		break;
+	case 3:
+		vector.x = this1[12];
+		vector.y = this1[13];
+		vector.z = this1[14];
+		vector.w = this1[15];
+		break;
+	default:
+		(lime_utils_Log().default).error("Column " + column + " out of bounds [0, ..., 3]",{ fileName : "Matrix4.hx", lineNumber : 180, className : "lime.math._Matrix4.Matrix4_Impl_", methodName : "copyColumnTo"});
+	}
+}
+Matrix4_Impl_.copyFrom = function(this1,other) {
+	this1.set(other);
+}
+Matrix4_Impl_.copythisFrom = function(this1,array,index,transposeValues) {
+	if(transposeValues == null) {
+		transposeValues = false;
+	}
+	if(index == null) {
+		index = 0;
+	}
+	if(transposeValues) {
+		Matrix4_Impl_.transpose(this1);
+	}
+	var l = array.length - index;
+	var _g1 = 0;
+	var _g = l;
+	while(_g1 < _g) {
+		var c = _g1++;
+		this1[c] = array[c + index];
+	}
+	if(transposeValues) {
+		Matrix4_Impl_.transpose(this1);
+	}
+}
+Matrix4_Impl_.copythisTo = function(this1,array,index,transposeValues) {
+	if(transposeValues == null) {
+		transposeValues = false;
+	}
+	if(index == null) {
+		index = 0;
+	}
+	if(transposeValues) {
+		Matrix4_Impl_.transpose(this1);
+	}
+	var l = this1.length;
+	var _g1 = 0;
+	var _g = l;
+	while(_g1 < _g) {
+		var c = _g1++;
+		array[c + index] = this1[c];
+	}
+	if(transposeValues) {
+		Matrix4_Impl_.transpose(this1);
+	}
+}
+Matrix4_Impl_.copyRowFrom = function(this1,row,vector) {
+	switch(row) {
+	case 0:
+		this1[0] = vector.x;
+		this1[4] = vector.y;
+		this1[8] = vector.z;
+		this1[12] = vector.w;
+		break;
+	case 1:
+		this1[1] = vector.x;
+		this1[5] = vector.y;
+		this1[9] = vector.z;
+		this1[13] = vector.w;
+		break;
+	case 2:
+		this1[2] = vector.x;
+		this1[6] = vector.y;
+		this1[10] = vector.z;
+		this1[14] = vector.w;
+		break;
+	case 3:
+		this1[3] = vector.x;
+		this1[7] = vector.y;
+		this1[11] = vector.z;
+		this1[15] = vector.w;
+		break;
+	default:
+		(lime_utils_Log().default).error("Row " + row + " out of bounds [0, ..., 3]",{ fileName : "Matrix4.hx", lineNumber : 258, className : "lime.math._Matrix4.Matrix4_Impl_", methodName : "copyRowFrom"});
+	}
+}
+Matrix4_Impl_.create2D = function(x,y,scale,rotation) {
+	if(rotation == null) {
+		rotation = 0;
+	}
+	if(scale == null) {
+		scale = 1;
+	}
+	var theta = rotation * Math.PI / 180.0;
+	var c = Math.cos(theta);
+	var s = Math.sin(theta);
+	var array = [c * scale,-s * scale,0,0,s * scale,c * scale,0,0,0,0,1,0,x,y,0,1];
+	var this1;
+	if(array != null) {
+		this1 = new Float32Array(array);
+	} else {
+		this1 = null;
+	}
+	return Matrix4_Impl_._new(this1);
+}
+Matrix4_Impl_.createABCD = function(a,b,c,d,tx,ty,matrix) {
+	if(matrix == null) {
+		matrix = Matrix4_Impl_._new();
+	}
+	Matrix4_Impl_.set(matrix,0,a);
+	Matrix4_Impl_.set(matrix,1,b);
+	Matrix4_Impl_.set(matrix,2,0);
+	Matrix4_Impl_.set(matrix,3,0);
+	Matrix4_Impl_.set(matrix,4,c);
+	Matrix4_Impl_.set(matrix,5,d);
+	Matrix4_Impl_.set(matrix,6,0);
+	Matrix4_Impl_.set(matrix,7,0);
+	Matrix4_Impl_.set(matrix,8,0);
+	Matrix4_Impl_.set(matrix,9,0);
+	Matrix4_Impl_.set(matrix,10,1);
+	Matrix4_Impl_.set(matrix,11,0);
+	Matrix4_Impl_.set(matrix,12,tx);
+	Matrix4_Impl_.set(matrix,13,ty);
+	Matrix4_Impl_.set(matrix,14,0);
+	Matrix4_Impl_.set(matrix,15,1);
+	return matrix;
+}
+Matrix4_Impl_.createOrtho = function(x0,x1,y0,y1,zNear,zFar) {
+	var sx = 1.0 / (x1 - x0);
+	var sy = 1.0 / (y1 - y0);
+	var sz = 1.0 / (zFar - zNear);
+	var array = [2.0 * sx,0,0,0,0,2.0 * sy,0,0,0,0,-2.0 * sz,0,-(x0 + x1) * sx,-(y0 + y1) * sy,-(zNear + zFar) * sz,1];
+	var this1;
+	if(array != null) {
+		this1 = new Float32Array(array);
+	} else {
+		this1 = null;
+	}
+	return Matrix4_Impl_._new(this1);
+}
+Matrix4_Impl_.copyRowTo = function(this1,row,vector) {
+	switch(row) {
+	case 0:
+		vector.x = this1[0];
+		vector.y = this1[4];
+		vector.z = this1[8];
+		vector.w = this1[12];
+		break;
+	case 1:
+		vector.x = this1[1];
+		vector.y = this1[5];
+		vector.z = this1[9];
+		vector.w = this1[13];
+		break;
+	case 2:
+		vector.x = this1[2];
+		vector.y = this1[6];
+		vector.z = this1[10];
+		vector.w = this1[14];
+		break;
+	case 3:
+		vector.x = this1[3];
+		vector.y = this1[7];
+		vector.z = this1[11];
+		vector.w = this1[15];
+		break;
+	default:
+		(lime_utils_Log().default).error("Row " + row + " out of bounds [0, ..., 3]",{ fileName : "Matrix4.hx", lineNumber : 360, className : "lime.math._Matrix4.Matrix4_Impl_", methodName : "copyRowTo"});
+	}
+}
+Matrix4_Impl_.copyToMatrix4 = function(this1,other) {
+	((js_Boot().default).__cast(other , Float32Array)).set(this1);
+}
+Matrix4_Impl_.deltaTransformVector = function(this1,v) {
+	var x = v.x;
+	var y = v.y;
+	var z = v.z;
+	return new (lime_math_Vector4().default)(x * this1[0] + y * this1[4] + z * this1[8] + this1[3],x * this1[1] + y * this1[5] + z * this1[9] + this1[7],x * this1[2] + y * this1[6] + z * this1[10] + this1[11],0);
+}
+Matrix4_Impl_.identity = function(this1) {
+	this1[0] = 1;
+	this1[1] = 0;
+	this1[2] = 0;
+	this1[3] = 0;
+	this1[4] = 0;
+	this1[5] = 1;
+	this1[6] = 0;
+	this1[7] = 0;
+	this1[8] = 0;
+	this1[9] = 0;
+	this1[10] = 1;
+	this1[11] = 0;
+	this1[12] = 0;
+	this1[13] = 0;
+	this1[14] = 0;
+	this1[15] = 1;
+}
+Matrix4_Impl_.interpolate = function(thisMat,toMat,percent) {
+	var m = Matrix4_Impl_._new();
+	var _g = 0;
+	while(_g < 16) {
+		var i = _g++;
+		Matrix4_Impl_.set(m,i,Matrix4_Impl_.get(thisMat,i) + (Matrix4_Impl_.get(toMat,i) - Matrix4_Impl_.get(thisMat,i)) * percent);
+	}
+	return m;
+}
+Matrix4_Impl_.interpolateTo = function(this1,toMat,percent) {
+	var _g = 0;
+	while(_g < 16) {
+		var i = _g++;
+		this1[i] += (Matrix4_Impl_.get(toMat,i) - this1[i]) * percent;
+	}
+}
+Matrix4_Impl_.invert = function(this1) {
+	var d = Matrix4_Impl_.get_determinant(this1);
+	var invertable = Math.abs(d) > 0.00000000001;
+	if(invertable) {
+		d = 1 / d;
+		var m11 = this1[0];
+		var m21 = this1[4];
+		var m31 = this1[8];
+		var m41 = this1[12];
+		var m12 = this1[1];
+		var m22 = this1[5];
+		var m32 = this1[9];
+		var m42 = this1[13];
+		var m13 = this1[2];
+		var m23 = this1[6];
+		var m33 = this1[10];
+		var m43 = this1[14];
+		var m14 = this1[3];
+		var m24 = this1[7];
+		var m34 = this1[11];
+		var m44 = this1[15];
+		this1[0] = d * (m22 * (m33 * m44 - m43 * m34) - m32 * (m23 * m44 - m43 * m24) + m42 * (m23 * m34 - m33 * m24));
+		this1[1] = -d * (m12 * (m33 * m44 - m43 * m34) - m32 * (m13 * m44 - m43 * m14) + m42 * (m13 * m34 - m33 * m14));
+		this1[2] = d * (m12 * (m23 * m44 - m43 * m24) - m22 * (m13 * m44 - m43 * m14) + m42 * (m13 * m24 - m23 * m14));
+		this1[3] = -d * (m12 * (m23 * m34 - m33 * m24) - m22 * (m13 * m34 - m33 * m14) + m32 * (m13 * m24 - m23 * m14));
+		this1[4] = -d * (m21 * (m33 * m44 - m43 * m34) - m31 * (m23 * m44 - m43 * m24) + m41 * (m23 * m34 - m33 * m24));
+		this1[5] = d * (m11 * (m33 * m44 - m43 * m34) - m31 * (m13 * m44 - m43 * m14) + m41 * (m13 * m34 - m33 * m14));
+		this1[6] = -d * (m11 * (m23 * m44 - m43 * m24) - m21 * (m13 * m44 - m43 * m14) + m41 * (m13 * m24 - m23 * m14));
+		this1[7] = d * (m11 * (m23 * m34 - m33 * m24) - m21 * (m13 * m34 - m33 * m14) + m31 * (m13 * m24 - m23 * m14));
+		this1[8] = d * (m21 * (m32 * m44 - m42 * m34) - m31 * (m22 * m44 - m42 * m24) + m41 * (m22 * m34 - m32 * m24));
+		this1[9] = -d * (m11 * (m32 * m44 - m42 * m34) - m31 * (m12 * m44 - m42 * m14) + m41 * (m12 * m34 - m32 * m14));
+		this1[10] = d * (m11 * (m22 * m44 - m42 * m24) - m21 * (m12 * m44 - m42 * m14) + m41 * (m12 * m24 - m22 * m14));
+		this1[11] = -d * (m11 * (m22 * m34 - m32 * m24) - m21 * (m12 * m34 - m32 * m14) + m31 * (m12 * m24 - m22 * m14));
+		this1[12] = -d * (m21 * (m32 * m43 - m42 * m33) - m31 * (m22 * m43 - m42 * m23) + m41 * (m22 * m33 - m32 * m23));
+		this1[13] = d * (m11 * (m32 * m43 - m42 * m33) - m31 * (m12 * m43 - m42 * m13) + m41 * (m12 * m33 - m32 * m13));
+		this1[14] = -d * (m11 * (m22 * m43 - m42 * m23) - m21 * (m12 * m43 - m42 * m13) + m41 * (m12 * m23 - m22 * m13));
+		this1[15] = d * (m11 * (m22 * m33 - m32 * m23) - m21 * (m12 * m33 - m32 * m13) + m31 * (m12 * m23 - m22 * m13));
+	}
+	return invertable;
+}
+Matrix4_Impl_.pointAt = function(this1,pos,at,up) {
+	if(at == null) {
+		at = new (lime_math_Vector4().default)(0,0,-1);
+	}
+	if(up == null) {
+		up = new (lime_math_Vector4().default)(0,-1,0);
+	}
+	var dir = at.subtract(pos);
+	var vup = up.clone();
+	var right;
+	dir.normalize();
+	vup.normalize();
+	var dir2 = dir.clone();
+	dir2.scaleBy(vup.dotProduct(dir));
+	vup = vup.subtract(dir2);
+	if(vup.get_length() > 0) {
+		vup.normalize();
+	} else if(dir.x != 0) {
+		vup = new (lime_math_Vector4().default)(-dir.y,dir.x,0);
+	} else {
+		vup = new (lime_math_Vector4().default)(1,0,0);
+	}
+	right = vup.crossProduct(dir);
+	right.normalize();
+	this1[0] = right.x;
+	this1[4] = right.y;
+	this1[8] = right.z;
+	this1[12] = 0.0;
+	this1[1] = vup.x;
+	this1[5] = vup.y;
+	this1[9] = vup.z;
+	this1[13] = 0.0;
+	this1[2] = dir.x;
+	this1[6] = dir.y;
+	this1[10] = dir.z;
+	this1[14] = 0.0;
+	this1[3] = pos.x;
+	this1[7] = pos.y;
+	this1[11] = pos.z;
+	this1[15] = 1.0;
+}
+Matrix4_Impl_.prepend = function(this1,rhs) {
+	var m111 = Matrix4_Impl_.get(rhs,0);
+	var m121 = Matrix4_Impl_.get(rhs,4);
+	var m131 = Matrix4_Impl_.get(rhs,8);
+	var m141 = Matrix4_Impl_.get(rhs,12);
+	var m112 = Matrix4_Impl_.get(rhs,1);
+	var m122 = Matrix4_Impl_.get(rhs,5);
+	var m132 = Matrix4_Impl_.get(rhs,9);
+	var m142 = Matrix4_Impl_.get(rhs,13);
+	var m113 = Matrix4_Impl_.get(rhs,2);
+	var m123 = Matrix4_Impl_.get(rhs,6);
+	var m133 = Matrix4_Impl_.get(rhs,10);
+	var m143 = Matrix4_Impl_.get(rhs,14);
+	var m114 = Matrix4_Impl_.get(rhs,3);
+	var m124 = Matrix4_Impl_.get(rhs,7);
+	var m134 = Matrix4_Impl_.get(rhs,11);
+	var m144 = Matrix4_Impl_.get(rhs,15);
+	var m211 = this1[0];
+	var m221 = this1[4];
+	var m231 = this1[8];
+	var m241 = this1[12];
+	var m212 = this1[1];
+	var m222 = this1[5];
+	var m232 = this1[9];
+	var m242 = this1[13];
+	var m213 = this1[2];
+	var m223 = this1[6];
+	var m233 = this1[10];
+	var m243 = this1[14];
+	var m214 = this1[3];
+	var m224 = this1[7];
+	var m234 = this1[11];
+	var m244 = this1[15];
+	this1[0] = m111 * m211 + m112 * m221 + m113 * m231 + m114 * m241;
+	this1[1] = m111 * m212 + m112 * m222 + m113 * m232 + m114 * m242;
+	this1[2] = m111 * m213 + m112 * m223 + m113 * m233 + m114 * m243;
+	this1[3] = m111 * m214 + m112 * m224 + m113 * m234 + m114 * m244;
+	this1[4] = m121 * m211 + m122 * m221 + m123 * m231 + m124 * m241;
+	this1[5] = m121 * m212 + m122 * m222 + m123 * m232 + m124 * m242;
+	this1[6] = m121 * m213 + m122 * m223 + m123 * m233 + m124 * m243;
+	this1[7] = m121 * m214 + m122 * m224 + m123 * m234 + m124 * m244;
+	this1[8] = m131 * m211 + m132 * m221 + m133 * m231 + m134 * m241;
+	this1[9] = m131 * m212 + m132 * m222 + m133 * m232 + m134 * m242;
+	this1[10] = m131 * m213 + m132 * m223 + m133 * m233 + m134 * m243;
+	this1[11] = m131 * m214 + m132 * m224 + m133 * m234 + m134 * m244;
+	this1[12] = m141 * m211 + m142 * m221 + m143 * m231 + m144 * m241;
+	this1[13] = m141 * m212 + m142 * m222 + m143 * m232 + m144 * m242;
+	this1[14] = m141 * m213 + m142 * m223 + m143 * m233 + m144 * m243;
+	this1[15] = m141 * m214 + m142 * m224 + m143 * m234 + m144 * m244;
+}
+Matrix4_Impl_.prependRotation = function(this1,degrees,axis,pivotPoint) {
+	var m = Matrix4_Impl_.__getAxisRotation(this1,axis.x,axis.y,axis.z,degrees);
+	if(pivotPoint != null) {
+		var p = pivotPoint;
+		Matrix4_Impl_.appendTranslation(m,p.x,p.y,p.z);
+	}
+	Matrix4_Impl_.prepend(this1,m);
+}
+Matrix4_Impl_.prependScale = function(this1,xScale,yScale,zScale) {
+	var array = [xScale,0.0,0.0,0.0,0.0,yScale,0.0,0.0,0.0,0.0,zScale,0.0,0.0,0.0,0.0,1.0];
+	var this2;
+	if(array != null) {
+		this2 = new Float32Array(array);
+	} else {
+		this2 = null;
+	}
+	Matrix4_Impl_.prepend(this1,Matrix4_Impl_._new(this2));
+}
+Matrix4_Impl_.prependTranslation = function(this1,x,y,z) {
+	var m = Matrix4_Impl_._new();
+	Matrix4_Impl_.set_position(m,new (lime_math_Vector4().default)(x,y,z));
+	Matrix4_Impl_.prepend(this1,m);
+}
+Matrix4_Impl_.transformVector = function(this1,v) {
+	var x = v.x;
+	var y = v.y;
+	var z = v.z;
+	return new (lime_math_Vector4().default)(x * this1[0] + y * this1[4] + z * this1[8] + this1[12],x * this1[1] + y * this1[5] + z * this1[9] + this1[13],x * this1[2] + y * this1[6] + z * this1[10] + this1[14],x * this1[3] + y * this1[7] + z * this1[11] + this1[15]);
+}
+Matrix4_Impl_.transformVectors = function(this1,ain,aout) {
+	var i = 0;
+	var x;
+	var y;
+	var z;
+	while(i + 3 <= ain.length) {
+		x = ain[i];
+		y = ain[i + 1];
+		z = ain[i + 2];
+		aout[i] = x * this1[0] + y * this1[4] + z * this1[8] + this1[12];
+		aout[i + 1] = x * this1[1] + y * this1[5] + z * this1[9] + this1[13];
+		aout[i + 2] = x * this1[2] + y * this1[6] + z * this1[10] + this1[14];
+		i += 3;
+	}
+}
+Matrix4_Impl_.transpose = function(this1) {
+	var temp = this1[1];
+	this1[1] = this1[4];
+	this1[4] = temp;
+	var temp1 = this1[2];
+	this1[2] = this1[8];
+	this1[8] = temp1;
+	var temp2 = this1[3];
+	this1[3] = this1[12];
+	this1[12] = temp2;
+	var temp3 = this1[6];
+	this1[6] = this1[9];
+	this1[9] = temp3;
+	var temp4 = this1[7];
+	this1[7] = this1[13];
+	this1[13] = temp4;
+	var temp5 = this1[11];
+	this1[11] = this1[14];
+	this1[14] = temp5;
+}
+Matrix4_Impl_.__getAxisRotation = function(this1,x,y,z,degrees) {
+	var m = Matrix4_Impl_._new();
+	var a1 = new (lime_math_Vector4().default)(x,y,z);
+	var rad = -degrees * (Math.PI / 180);
+	var c = Math.cos(rad);
+	var s = Math.sin(rad);
+	var t = 1.0 - c;
+	Matrix4_Impl_.set(m,0,c + a1.x * a1.x * t);
+	Matrix4_Impl_.set(m,5,c + a1.y * a1.y * t);
+	Matrix4_Impl_.set(m,10,c + a1.z * a1.z * t);
+	var tmp1 = a1.x * a1.y * t;
+	var tmp2 = a1.z * s;
+	Matrix4_Impl_.set(m,4,tmp1 + tmp2);
+	Matrix4_Impl_.set(m,1,tmp1 - tmp2);
+	tmp1 = a1.x * a1.z * t;
+	tmp2 = a1.y * s;
+	Matrix4_Impl_.set(m,8,tmp1 - tmp2);
+	Matrix4_Impl_.set(m,2,tmp1 + tmp2);
+	tmp1 = a1.y * a1.z * t;
+	tmp2 = a1.x * s;
+	Matrix4_Impl_.set(m,9,tmp1 + tmp2);
+	Matrix4_Impl_.set(m,6,tmp1 - tmp2);
+	return m;
+}
+Matrix4_Impl_.__swap = function(this1,a,b) {
+	var temp = this1[a];
+	this1[a] = this1[b];
+	this1[b] = temp;
+}
+Matrix4_Impl_.get_determinant = function(this1) {
+	return (this1[0] * this1[5] - this1[4] * this1[1]) * (this1[10] * this1[15] - this1[14] * this1[11]) - (this1[0] * this1[9] - this1[8] * this1[1]) * (this1[6] * this1[15] - this1[14] * this1[7]) + (this1[0] * this1[13] - this1[12] * this1[1]) * (this1[6] * this1[11] - this1[10] * this1[7]) + (this1[4] * this1[9] - this1[8] * this1[5]) * (this1[2] * this1[15] - this1[14] * this1[3]) - (this1[4] * this1[13] - this1[12] * this1[5]) * (this1[2] * this1[11] - this1[10] * this1[3]) + (this1[8] * this1[13] - this1[12] * this1[9]) * (this1[2] * this1[7] - this1[6] * this1[3]);
+}
+Matrix4_Impl_.get_position = function(this1) {
+	return new (lime_math_Vector4().default)(this1[12],this1[13],this1[14]);
+}
+Matrix4_Impl_.set_position = function(this1,val) {
+	this1[12] = val.x;
+	this1[13] = val.y;
+	this1[14] = val.z;
+	return val;
+}
+Matrix4_Impl_.get = function(this1,index) {
+	return this1[index];
+}
+Matrix4_Impl_.set = function(this1,index,value) {
+	this1[index] = value;
+	return value;
+}
+Matrix4_Impl_.__identity = [1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0]
+
+// Export
+
+exports.default = Matrix4_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/math/color/_ARGB/ARGB_Impl_.js

@@ -0,0 +1,168 @@
+// Class: lime.math.color._ARGB.ARGB_Impl_
+
+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 lime_math_color__$RGBA_RGBA_$Impl_$() {return require("./../../../../lime/math/color/_RGBA/RGBA_Impl_");}
+
+// Constructor
+
+var ARGB_Impl_ = function(){}
+
+// Meta
+
+ARGB_Impl_.__name__ = ["lime","math","color","_ARGB","ARGB_Impl_"];
+ARGB_Impl_.prototype = {
+	
+};
+ARGB_Impl_.prototype.__class__ = $hxClasses["lime.math.color._ARGB.ARGB_Impl_"] = ARGB_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ARGB_Impl_._new = function(argb) {
+	if(argb == null) {
+		argb = 0;
+	}
+	var this1 = argb;
+	return this1;
+}
+ARGB_Impl_.create = function(a,r,g,b) {
+	var this1 = 0;
+	var argb = this1;
+	argb = (a & 255) << 24 | (r & 255) << 16 | (g & 255) << 8 | b & 255;
+	return argb;
+}
+ARGB_Impl_.multiplyAlpha = function(this1) {
+	if((this1 >>> 24 & 255) == 0) {
+		this1 = 0;
+	} else if((this1 >>> 24 & 255) != 255) {
+		ARGB_Impl_.a16 = (lime_math_color__$RGBA_RGBA_$Impl_$().default).__alpha16[this1 >>> 24 & 255];
+		this1 = (this1 >>> 24 & 255 & 255) << 24 | ((this1 >>> 16 & 255) * ARGB_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * ARGB_Impl_.a16 >> 16 & 255) << 8 | (this1 & 255) * ARGB_Impl_.a16 >> 16 & 255;
+	}
+}
+ARGB_Impl_.readUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	switch(format) {
+	case 0:
+		this1 = (data[offset + 1] & 255) << 24 | (data[offset + 2] & 255) << 16 | (data[offset + 3] & 255) << 8 | data[offset] & 255;
+		break;
+	case 1:
+		this1 = (data[offset + 2] & 255) << 24 | (data[offset + 3] & 255) << 16 | (data[offset] & 255) << 8 | data[offset + 1] & 255;
+		break;
+	case 2:
+		this1 = (data[offset + 1] & 255) << 24 | (data[offset] & 255) << 16 | (data[offset + 3] & 255) << 8 | data[offset + 2] & 255;
+		break;
+	}
+	if(premultiplied) {
+		if((this1 >>> 24 & 255) != 0 && (this1 >>> 24 & 255) != 255) {
+			ARGB_Impl_.unmult = 255.0 / (this1 >>> 24 & 255);
+			this1 = (this1 >>> 24 & 255 & 255) << 24 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 16 & 255) * ARGB_Impl_.unmult)] & 255) << 16 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 8 & 255) * ARGB_Impl_.unmult)] & 255) << 8 | (lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 & 255) * ARGB_Impl_.unmult)] & 255;
+		}
+	}
+}
+ARGB_Impl_.set = function(this1,a,r,g,b) {
+	this1 = (a & 255) << 24 | (r & 255) << 16 | (g & 255) << 8 | b & 255;
+}
+ARGB_Impl_.unmultiplyAlpha = function(this1) {
+	if((this1 >>> 24 & 255) != 0 && (this1 >>> 24 & 255) != 255) {
+		ARGB_Impl_.unmult = 255.0 / (this1 >>> 24 & 255);
+		this1 = (this1 >>> 24 & 255 & 255) << 24 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 16 & 255) * ARGB_Impl_.unmult)] & 255) << 16 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 8 & 255) * ARGB_Impl_.unmult)] & 255) << 8 | (lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 & 255) * ARGB_Impl_.unmult)] & 255;
+	}
+}
+ARGB_Impl_.writeUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	if(premultiplied) {
+		if((this1 >>> 24 & 255) == 0) {
+			this1 = 0;
+		} else if((this1 >>> 24 & 255) != 255) {
+			ARGB_Impl_.a16 = (lime_math_color__$RGBA_RGBA_$Impl_$().default).__alpha16[this1 >>> 24 & 255];
+			this1 = (this1 >>> 24 & 255 & 255) << 24 | ((this1 >>> 16 & 255) * ARGB_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * ARGB_Impl_.a16 >> 16 & 255) << 8 | (this1 & 255) * ARGB_Impl_.a16 >> 16 & 255;
+		}
+	}
+	switch(format) {
+	case 0:
+		data[offset] = this1 >>> 16 & 255;
+		data[offset + 1] = this1 >>> 8 & 255;
+		data[offset + 2] = this1 & 255;
+		data[offset + 3] = this1 >>> 24 & 255;
+		break;
+	case 1:
+		data[offset] = this1 >>> 24 & 255;
+		data[offset + 1] = this1 >>> 16 & 255;
+		data[offset + 2] = this1 >>> 8 & 255;
+		data[offset + 3] = this1 & 255;
+		break;
+	case 2:
+		data[offset] = this1 & 255;
+		data[offset + 1] = this1 >>> 8 & 255;
+		data[offset + 2] = this1 >>> 16 & 255;
+		data[offset + 3] = this1 >>> 24 & 255;
+		break;
+	}
+}
+ARGB_Impl_.__fromBGRA = function(bgra) {
+	var this1 = 0;
+	var argb = this1;
+	argb = (bgra & 255 & 255) << 24 | (bgra >>> 8 & 255 & 255) << 16 | (bgra >>> 16 & 255 & 255) << 8 | bgra >>> 24 & 255 & 255;
+	return argb;
+}
+ARGB_Impl_.__fromRGBA = function(rgba) {
+	var this1 = 0;
+	var argb = this1;
+	argb = (rgba & 255 & 255) << 24 | (rgba >>> 24 & 255 & 255) << 16 | (rgba >>> 16 & 255 & 255) << 8 | rgba >>> 8 & 255 & 255;
+	return argb;
+}
+ARGB_Impl_.get_a = function(this1) {
+	return this1 >>> 24 & 255;
+}
+ARGB_Impl_.set_a = function(this1,value) {
+	this1 = (value & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+ARGB_Impl_.get_b = function(this1) {
+	return this1 & 255;
+}
+ARGB_Impl_.set_b = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | value & 255;
+	return value;
+}
+ARGB_Impl_.get_g = function(this1) {
+	return this1 >>> 8 & 255;
+}
+ARGB_Impl_.set_g = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (value & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+ARGB_Impl_.get_r = function(this1) {
+	return this1 >>> 16 & 255;
+}
+ARGB_Impl_.set_r = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (value & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+
+
+// Export
+
+exports.default = ARGB_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/math/color/_BGRA/BGRA_Impl_.js

@@ -0,0 +1,168 @@
+// Class: lime.math.color._BGRA.BGRA_Impl_
+
+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 lime_math_color__$RGBA_RGBA_$Impl_$() {return require("./../../../../lime/math/color/_RGBA/RGBA_Impl_");}
+
+// Constructor
+
+var BGRA_Impl_ = function(){}
+
+// Meta
+
+BGRA_Impl_.__name__ = ["lime","math","color","_BGRA","BGRA_Impl_"];
+BGRA_Impl_.prototype = {
+	
+};
+BGRA_Impl_.prototype.__class__ = $hxClasses["lime.math.color._BGRA.BGRA_Impl_"] = BGRA_Impl_;
+
+// Init
+
+
+
+// Statics
+
+BGRA_Impl_._new = function(bgra) {
+	if(bgra == null) {
+		bgra = 0;
+	}
+	var this1 = bgra;
+	return this1;
+}
+BGRA_Impl_.create = function(b,g,r,a) {
+	var this1 = 0;
+	var bgra = this1;
+	bgra = (b & 255) << 24 | (g & 255) << 16 | (r & 255) << 8 | a & 255;
+	return bgra;
+}
+BGRA_Impl_.multiplyAlpha = function(this1) {
+	if((this1 & 255) == 0) {
+		this1 = 0;
+	} else if((this1 & 255) != 255) {
+		BGRA_Impl_.a16 = (lime_math_color__$RGBA_RGBA_$Impl_$().default).__alpha16[this1 & 255];
+		this1 = ((this1 >>> 24 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 24 | ((this1 >>> 16 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 8 | this1 & 255 & 255;
+	}
+}
+BGRA_Impl_.readUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	switch(format) {
+	case 0:
+		this1 = (data[offset + 2] & 255) << 24 | (data[offset + 1] & 255) << 16 | (data[offset] & 255) << 8 | data[offset + 3] & 255;
+		break;
+	case 1:
+		this1 = (data[offset + 3] & 255) << 24 | (data[offset + 2] & 255) << 16 | (data[offset + 1] & 255) << 8 | data[offset] & 255;
+		break;
+	case 2:
+		this1 = (data[offset] & 255) << 24 | (data[offset + 1] & 255) << 16 | (data[offset + 2] & 255) << 8 | data[offset + 3] & 255;
+		break;
+	}
+	if(premultiplied) {
+		if((this1 & 255) != 0 && (this1 & 255) != 255) {
+			BGRA_Impl_.unmult = 255.0 / (this1 & 255);
+			this1 = ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 24 & 255) * BGRA_Impl_.unmult)] & 255) << 24 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 16 & 255) * BGRA_Impl_.unmult)] & 255) << 16 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 8 & 255) * BGRA_Impl_.unmult)] & 255) << 8 | this1 & 255 & 255;
+		}
+	}
+}
+BGRA_Impl_.set = function(this1,b,g,r,a) {
+	this1 = (b & 255) << 24 | (g & 255) << 16 | (r & 255) << 8 | a & 255;
+}
+BGRA_Impl_.unmultiplyAlpha = function(this1) {
+	if((this1 & 255) != 0 && (this1 & 255) != 255) {
+		BGRA_Impl_.unmult = 255.0 / (this1 & 255);
+		this1 = ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 24 & 255) * BGRA_Impl_.unmult)] & 255) << 24 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 16 & 255) * BGRA_Impl_.unmult)] & 255) << 16 | ((lime_math_color__$RGBA_RGBA_$Impl_$().default).__clamp[Math.floor((this1 >>> 8 & 255) * BGRA_Impl_.unmult)] & 255) << 8 | this1 & 255 & 255;
+	}
+}
+BGRA_Impl_.writeUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	if(premultiplied) {
+		if((this1 & 255) == 0) {
+			this1 = 0;
+		} else if((this1 & 255) != 255) {
+			BGRA_Impl_.a16 = (lime_math_color__$RGBA_RGBA_$Impl_$().default).__alpha16[this1 & 255];
+			this1 = ((this1 >>> 24 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 24 | ((this1 >>> 16 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * BGRA_Impl_.a16 >> 16 & 255) << 8 | this1 & 255 & 255;
+		}
+	}
+	switch(format) {
+	case 0:
+		data[offset] = this1 >>> 8 & 255;
+		data[offset + 1] = this1 >>> 16 & 255;
+		data[offset + 2] = this1 >>> 24 & 255;
+		data[offset + 3] = this1 & 255;
+		break;
+	case 1:
+		data[offset] = this1 & 255;
+		data[offset + 1] = this1 >>> 8 & 255;
+		data[offset + 2] = this1 >>> 16 & 255;
+		data[offset + 3] = this1 >>> 24 & 255;
+		break;
+	case 2:
+		data[offset] = this1 >>> 24 & 255;
+		data[offset + 1] = this1 >>> 16 & 255;
+		data[offset + 2] = this1 >>> 8 & 255;
+		data[offset + 3] = this1 & 255;
+		break;
+	}
+}
+BGRA_Impl_.__fromARGB = function(argb) {
+	var this1 = 0;
+	var bgra = this1;
+	bgra = (argb & 255 & 255) << 24 | (argb >>> 8 & 255 & 255) << 16 | (argb >>> 16 & 255 & 255) << 8 | argb >>> 24 & 255 & 255;
+	return bgra;
+}
+BGRA_Impl_.__fromRGBA = function(rgba) {
+	var this1 = 0;
+	var bgra = this1;
+	bgra = (rgba >>> 8 & 255 & 255) << 24 | (rgba >>> 16 & 255 & 255) << 16 | (rgba >>> 24 & 255 & 255) << 8 | rgba & 255 & 255;
+	return bgra;
+}
+BGRA_Impl_.get_a = function(this1) {
+	return this1 & 255;
+}
+BGRA_Impl_.set_a = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | value & 255;
+	return value;
+}
+BGRA_Impl_.get_b = function(this1) {
+	return this1 >>> 24 & 255;
+}
+BGRA_Impl_.set_b = function(this1,value) {
+	this1 = (value & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+BGRA_Impl_.get_g = function(this1) {
+	return this1 >>> 16 & 255;
+}
+BGRA_Impl_.set_g = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (value & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+BGRA_Impl_.get_r = function(this1) {
+	return this1 >>> 8 & 255;
+}
+BGRA_Impl_.set_r = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (value & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+
+
+// Export
+
+exports.default = BGRA_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/math/color/_RGBA/RGBA_Impl_.js

@@ -0,0 +1,192 @@
+// Class: lime.math.color._RGBA.RGBA_Impl_
+
+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 RGBA_Impl_ = function(){}
+
+// Meta
+
+RGBA_Impl_.__name__ = ["lime","math","color","_RGBA","RGBA_Impl_"];
+RGBA_Impl_.prototype = {
+	
+};
+RGBA_Impl_.prototype.__class__ = $hxClasses["lime.math.color._RGBA.RGBA_Impl_"] = RGBA_Impl_;
+
+// Init
+
+{
+	var this1 = new Uint32Array(256);
+	RGBA_Impl_.__alpha16 = this1;
+	var _g = 0;
+	while(_g < 256) {
+		var i = _g++;
+		RGBA_Impl_.__alpha16[i] = Math.ceil(i * 257.003921568627447);
+	}
+	var this2 = new Uint8Array(510);
+	RGBA_Impl_.__clamp = this2;
+	var _g1 = 0;
+	while(_g1 < 255) {
+		var i1 = _g1++;
+		RGBA_Impl_.__clamp[i1] = i1;
+	}
+	var _g11 = 255;
+	var _g2 = 511;
+	while(_g11 < _g2) {
+		var i2 = _g11++;
+		RGBA_Impl_.__clamp[i2] = 255;
+	}
+};
+
+// Statics
+
+RGBA_Impl_._new = function(rgba) {
+	if(rgba == null) {
+		rgba = 0;
+	}
+	var this1 = rgba;
+	return this1;
+}
+RGBA_Impl_.create = function(r,g,b,a) {
+	var this1 = 0;
+	var rgba = this1;
+	rgba = (r & 255) << 24 | (g & 255) << 16 | (b & 255) << 8 | a & 255;
+	return rgba;
+}
+RGBA_Impl_.multiplyAlpha = function(this1) {
+	if((this1 & 255) == 0) {
+		if(this1 != 0) {
+			this1 = 0;
+		}
+	} else if((this1 & 255) != 255) {
+		RGBA_Impl_.a16 = RGBA_Impl_.__alpha16[this1 & 255];
+		this1 = ((this1 >>> 24 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 24 | ((this1 >>> 16 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 8 | this1 & 255 & 255;
+	}
+}
+RGBA_Impl_.readUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	switch(format) {
+	case 0:
+		this1 = (data[offset] & 255) << 24 | (data[offset + 1] & 255) << 16 | (data[offset + 2] & 255) << 8 | data[offset + 3] & 255;
+		break;
+	case 1:
+		this1 = (data[offset + 1] & 255) << 24 | (data[offset + 2] & 255) << 16 | (data[offset + 3] & 255) << 8 | data[offset] & 255;
+		break;
+	case 2:
+		this1 = (data[offset + 2] & 255) << 24 | (data[offset + 1] & 255) << 16 | (data[offset] & 255) << 8 | data[offset + 3] & 255;
+		break;
+	}
+	if(premultiplied) {
+		if((this1 & 255) != 0 && (this1 & 255) != 255) {
+			RGBA_Impl_.unmult = 255.0 / (this1 & 255);
+			this1 = (RGBA_Impl_.__clamp[Math.round((this1 >>> 24 & 255) * RGBA_Impl_.unmult)] & 255) << 24 | (RGBA_Impl_.__clamp[Math.round((this1 >>> 16 & 255) * RGBA_Impl_.unmult)] & 255) << 16 | (RGBA_Impl_.__clamp[Math.round((this1 >>> 8 & 255) * RGBA_Impl_.unmult)] & 255) << 8 | this1 & 255 & 255;
+		}
+	}
+}
+RGBA_Impl_.set = function(this1,r,g,b,a) {
+	this1 = (r & 255) << 24 | (g & 255) << 16 | (b & 255) << 8 | a & 255;
+}
+RGBA_Impl_.unmultiplyAlpha = function(this1) {
+	if((this1 & 255) != 0 && (this1 & 255) != 255) {
+		RGBA_Impl_.unmult = 255.0 / (this1 & 255);
+		this1 = (RGBA_Impl_.__clamp[Math.round((this1 >>> 24 & 255) * RGBA_Impl_.unmult)] & 255) << 24 | (RGBA_Impl_.__clamp[Math.round((this1 >>> 16 & 255) * RGBA_Impl_.unmult)] & 255) << 16 | (RGBA_Impl_.__clamp[Math.round((this1 >>> 8 & 255) * RGBA_Impl_.unmult)] & 255) << 8 | this1 & 255 & 255;
+	}
+}
+RGBA_Impl_.writeUInt8 = function(this1,data,offset,format,premultiplied) {
+	if(premultiplied == null) {
+		premultiplied = false;
+	}
+	if(format == null) {
+		format = 0;
+	}
+	if(premultiplied) {
+		if((this1 & 255) == 0) {
+			if(this1 != 0) {
+				this1 = 0;
+			}
+		} else if((this1 & 255) != 255) {
+			RGBA_Impl_.a16 = RGBA_Impl_.__alpha16[this1 & 255];
+			this1 = ((this1 >>> 24 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 24 | ((this1 >>> 16 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 16 | ((this1 >>> 8 & 255) * RGBA_Impl_.a16 >> 16 & 255) << 8 | this1 & 255 & 255;
+		}
+	}
+	switch(format) {
+	case 0:
+		data[offset] = this1 >>> 24 & 255;
+		data[offset + 1] = this1 >>> 16 & 255;
+		data[offset + 2] = this1 >>> 8 & 255;
+		data[offset + 3] = this1 & 255;
+		break;
+	case 1:
+		data[offset] = this1 & 255;
+		data[offset + 1] = this1 >>> 24 & 255;
+		data[offset + 2] = this1 >>> 16 & 255;
+		data[offset + 3] = this1 >>> 8 & 255;
+		break;
+	case 2:
+		data[offset] = this1 >>> 8 & 255;
+		data[offset + 1] = this1 >>> 16 & 255;
+		data[offset + 2] = this1 >>> 24 & 255;
+		data[offset + 3] = this1 & 255;
+		break;
+	}
+}
+RGBA_Impl_.__fromARGB = function(argb) {
+	var this1 = 0;
+	var rgba = this1;
+	rgba = (argb >>> 16 & 255 & 255) << 24 | (argb >>> 8 & 255 & 255) << 16 | (argb & 255 & 255) << 8 | argb >>> 24 & 255 & 255;
+	return rgba;
+}
+RGBA_Impl_.__fromBGRA = function(bgra) {
+	var this1 = 0;
+	var rgba = this1;
+	rgba = (bgra >>> 8 & 255 & 255) << 24 | (bgra >>> 16 & 255 & 255) << 16 | (bgra >>> 24 & 255 & 255) << 8 | bgra & 255 & 255;
+	return rgba;
+}
+RGBA_Impl_.get_a = function(this1) {
+	return this1 & 255;
+}
+RGBA_Impl_.set_a = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | value & 255;
+	return value;
+}
+RGBA_Impl_.get_b = function(this1) {
+	return this1 >>> 8 & 255;
+}
+RGBA_Impl_.set_b = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (value & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+RGBA_Impl_.get_g = function(this1) {
+	return this1 >>> 16 & 255;
+}
+RGBA_Impl_.set_g = function(this1,value) {
+	this1 = (this1 >>> 24 & 255 & 255) << 24 | (value & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+RGBA_Impl_.get_r = function(this1) {
+	return this1 >>> 24 & 255;
+}
+RGBA_Impl_.set_r = function(this1,value) {
+	this1 = (value & 255) << 24 | (this1 >>> 16 & 255 & 255) << 16 | (this1 >>> 8 & 255 & 255) << 8 | this1 & 255 & 255;
+	return value;
+}
+
+
+// Export
+
+exports.default = RGBA_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/media/ALAudioContext.js

@@ -0,0 +1,376 @@
+// Class: lime.media.ALAudioContext
+
+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 lime_media_openal_AL() {return require("./../../lime/media/openal/AL");}
+
+// Constructor
+
+var ALAudioContext = function() {
+	this.EXPONENT_DISTANCE_CLAMPED = 53254;
+	this.EXPONENT_DISTANCE = 53253;
+	this.LINEAR_DISTANCE_CLAMPED = 53252;
+	this.LINEAR_DISTANCE = 53251;
+	this.INVERSE_DISTANCE_CLAMPED = 53250;
+	this.INVERSE_DISTANCE = 53249;
+	this.DISTANCE_MODEL = 53248;
+	this.DOPPLER_VELOCITY = 49153;
+	this.SPEED_OF_SOUND = 49155;
+	this.DOPPLER_FACTOR = 49152;
+	this.EXTENSIONS = 45060;
+	this.RENDERER = 45059;
+	this.VERSION = 45058;
+	this.VENDOR = 45057;
+	this.OUT_OF_MEMORY = 40965;
+	this.INVALID_OPERATION = 40964;
+	this.INVALID_VALUE = 40963;
+	this.INVALID_ENUM = 40962;
+	this.INVALID_NAME = 40961;
+	this.NO_ERROR = 0;
+	this.SIZE = 8196;
+	this.CHANNELS = 8195;
+	this.BITS = 8194;
+	this.FREQUENCY = 8193;
+	this.FORMAT_STEREO16 = 4355;
+	this.FORMAT_STEREO8 = 4354;
+	this.FORMAT_MONO16 = 4353;
+	this.FORMAT_MONO8 = 4352;
+	this.UNDETERMINED = 4144;
+	this.STREAMING = 4137;
+	this.STATIC = 4136;
+	this.SOURCE_TYPE = 4135;
+	this.BYTE_OFFSET = 4134;
+	this.SAMPLE_OFFSET = 4133;
+	this.SEC_OFFSET = 4132;
+	this.MAX_DISTANCE = 4131;
+	this.CONE_OUTER_GAIN = 4130;
+	this.ROLLOFF_FACTOR = 4129;
+	this.REFERENCE_DISTANCE = 4128;
+	this.BUFFERS_PROCESSED = 4118;
+	this.BUFFERS_QUEUED = 4117;
+	this.STOPPED = 4116;
+	this.PAUSED = 4115;
+	this.PLAYING = 4114;
+	this.INITIAL = 4113;
+	this.SOURCE_STATE = 4112;
+	this.ORIENTATION = 4111;
+	this.MAX_GAIN = 4110;
+	this.MIN_GAIN = 4109;
+	this.GAIN = 4106;
+	this.BUFFER = 4105;
+	this.LOOPING = 4103;
+	this.VELOCITY = 4102;
+	this.DIRECTION = 4101;
+	this.POSITION = 4100;
+	this.PITCH = 4099;
+	this.CONE_OUTER_ANGLE = 4098;
+	this.CONE_INNER_ANGLE = 4097;
+	this.SOURCE_RELATIVE = 514;
+	this.TRUE = 1;
+	this.FALSE = 0;
+	this.NONE = 0;
+}
+
+// Meta
+
+ALAudioContext.__name__ = ["lime","media","ALAudioContext"];
+ALAudioContext.prototype = {
+	bufferData: function(buffer,format,data,size,freq) {
+		(lime_media_openal_AL().default).bufferData(buffer,format,data,size,freq);
+	},
+	buffer3f: function(buffer,param,value1,value2,value3) {
+		(lime_media_openal_AL().default).buffer3f(buffer,param,value1,value2,value3);
+	},
+	buffer3i: function(buffer,param,value1,value2,value3) {
+		(lime_media_openal_AL().default).buffer3i(buffer,param,value1,value2,value3);
+	},
+	bufferf: function(buffer,param,value) {
+		(lime_media_openal_AL().default).bufferf(buffer,param,value);
+	},
+	bufferfv: function(buffer,param,values) {
+		(lime_media_openal_AL().default).bufferfv(buffer,param,values);
+	},
+	bufferi: function(buffer,param,value) {
+		(lime_media_openal_AL().default).bufferi(buffer,param,value);
+	},
+	bufferiv: function(buffer,param,values) {
+		(lime_media_openal_AL().default).bufferiv(buffer,param,values);
+	},
+	createSource: function() {
+		return (lime_media_openal_AL().default).createSource();
+	},
+	createBuffer: function() {
+		return (lime_media_openal_AL().default).createBuffer();
+	},
+	deleteBuffer: function(buffer) {
+		(lime_media_openal_AL().default).deleteBuffer(buffer);
+	},
+	deleteBuffers: function(buffers) {
+		(lime_media_openal_AL().default).deleteBuffers(buffers);
+	},
+	deleteSource: function(source) {
+		(lime_media_openal_AL().default).deleteSource(source);
+	},
+	deleteSources: function(sources) {
+		(lime_media_openal_AL().default).deleteSources(sources);
+	},
+	disable: function(capability) {
+		(lime_media_openal_AL().default).disable(capability);
+	},
+	distanceModel: function(distanceModel) {
+		(lime_media_openal_AL().default).distanceModel(distanceModel);
+	},
+	dopplerFactor: function(value) {
+		(lime_media_openal_AL().default).dopplerFactor(value);
+	},
+	dopplerVelocity: function(value) {
+		(lime_media_openal_AL().default).dopplerVelocity(value);
+	},
+	enable: function(capability) {
+		(lime_media_openal_AL().default).enable(capability);
+	},
+	genSource: function() {
+		return this.createSource();
+	},
+	genSources: function(n) {
+		return (lime_media_openal_AL().default).genSources(n);
+	},
+	genBuffer: function() {
+		return this.createBuffer();
+	},
+	genBuffers: function(n) {
+		return (lime_media_openal_AL().default).genBuffers(n);
+	},
+	getBoolean: function(param) {
+		return (lime_media_openal_AL().default).getBoolean(param);
+	},
+	getBooleanv: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getBooleanv(param,count);
+	},
+	getBuffer3f: function(buffer,param) {
+		return (lime_media_openal_AL().default).getBuffer3f(buffer,param);
+	},
+	getBuffer3i: function(buffer,param) {
+		return (lime_media_openal_AL().default).getBuffer3i(buffer,param);
+	},
+	getBufferf: function(buffer,param) {
+		return (lime_media_openal_AL().default).getBufferf(buffer,param);
+	},
+	getBufferfv: function(buffer,param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getBufferfv(buffer,param,count);
+	},
+	getBufferi: function(buffer,param) {
+		return (lime_media_openal_AL().default).getBufferi(buffer,param);
+	},
+	getBufferiv: function(buffer,param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getBufferiv(buffer,param,count);
+	},
+	getDouble: function(param) {
+		return (lime_media_openal_AL().default).getDouble(param);
+	},
+	getDoublev: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getDoublev(param,count);
+	},
+	getEnumValue: function(ename) {
+		return (lime_media_openal_AL().default).getEnumValue(ename);
+	},
+	getError: function() {
+		return (lime_media_openal_AL().default).getError();
+	},
+	getErrorString: function() {
+		return (lime_media_openal_AL().default).getErrorString();
+	},
+	getFloat: function(param) {
+		return (lime_media_openal_AL().default).getFloat(param);
+	},
+	getFloatv: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getFloatv(param,count);
+	},
+	getInteger: function(param) {
+		return (lime_media_openal_AL().default).getInteger(param);
+	},
+	getIntegerv: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getIntegerv(param,count);
+	},
+	getListener3f: function(param) {
+		return (lime_media_openal_AL().default).getListener3f(param);
+	},
+	getListener3i: function(param) {
+		return (lime_media_openal_AL().default).getListener3i(param);
+	},
+	getListenerf: function(param) {
+		return (lime_media_openal_AL().default).getListenerf(param);
+	},
+	getListenerfv: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getListenerfv(param,count);
+	},
+	getListeneri: function(param) {
+		return (lime_media_openal_AL().default).getListeneri(param);
+	},
+	getListeneriv: function(param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getListeneriv(param,count);
+	},
+	getProcAddress: function(fname) {
+		return (lime_media_openal_AL().default).getProcAddress(fname);
+	},
+	getSource3f: function(source,param) {
+		return (lime_media_openal_AL().default).getSource3f(source,param);
+	},
+	getSourcef: function(source,param) {
+		return (lime_media_openal_AL().default).getSourcef(source,param);
+	},
+	getSource3i: function(source,param) {
+		return (lime_media_openal_AL().default).getSource3i(source,param);
+	},
+	getSourcefv: function(source,param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getSourcefv(source,param);
+	},
+	getSourcei: function(source,param) {
+		return (lime_media_openal_AL().default).getSourcei(source,param);
+	},
+	getSourceiv: function(source,param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_AL().default).getSourceiv(source,param,count);
+	},
+	getString: function(param) {
+		return (lime_media_openal_AL().default).getString(param);
+	},
+	isBuffer: function(buffer) {
+		return (lime_media_openal_AL().default).isBuffer(buffer);
+	},
+	isEnabled: function(capability) {
+		return (lime_media_openal_AL().default).isEnabled(capability);
+	},
+	isExtensionPresent: function(extname) {
+		return (lime_media_openal_AL().default).isExtensionPresent(extname);
+	},
+	isSource: function(source) {
+		return (lime_media_openal_AL().default).isSource(source);
+	},
+	listener3f: function(param,value1,value2,value3) {
+		(lime_media_openal_AL().default).listener3f(param,value1,value2,value3);
+	},
+	listener3i: function(param,value1,value2,value3) {
+		(lime_media_openal_AL().default).listener3i(param,value1,value2,value3);
+	},
+	listenerf: function(param,value) {
+		(lime_media_openal_AL().default).listenerf(param,value);
+	},
+	listenerfv: function(param,values) {
+		(lime_media_openal_AL().default).listenerfv(param,values);
+	},
+	listeneri: function(param,value) {
+		(lime_media_openal_AL().default).listeneri(param,value);
+	},
+	listeneriv: function(param,values) {
+		(lime_media_openal_AL().default).listeneriv(param,values);
+	},
+	source3f: function(source,param,value1,value2,value3) {
+		(lime_media_openal_AL().default).source3f(source,param,value1,value2,value3);
+	},
+	source3i: function(source,param,value1,value2,value3) {
+		(lime_media_openal_AL().default).source3i(source,param,value1,value2,value3);
+	},
+	sourcef: function(source,param,value) {
+		(lime_media_openal_AL().default).sourcef(source,param,value);
+	},
+	sourcefv: function(source,param,values) {
+		(lime_media_openal_AL().default).sourcefv(source,param,values);
+	},
+	sourcei: function(source,param,value) {
+		(lime_media_openal_AL().default).sourcei(source,param,value);
+	},
+	sourceiv: function(source,param,values) {
+		(lime_media_openal_AL().default).sourceiv(source,param,values);
+	},
+	sourcePlay: function(source) {
+		(lime_media_openal_AL().default).sourcePlay(source);
+	},
+	sourcePlayv: function(sources) {
+		(lime_media_openal_AL().default).sourcePlayv(sources);
+	},
+	sourceStop: function(source) {
+		(lime_media_openal_AL().default).sourceStop(source);
+	},
+	sourceStopv: function(sources) {
+		(lime_media_openal_AL().default).sourceStopv(sources);
+	},
+	sourceRewind: function(source) {
+		(lime_media_openal_AL().default).sourceRewind(source);
+	},
+	sourceRewindv: function(sources) {
+		(lime_media_openal_AL().default).sourceRewindv(sources);
+	},
+	sourcePause: function(source) {
+		(lime_media_openal_AL().default).sourcePause(source);
+	},
+	sourcePausev: function(sources) {
+		(lime_media_openal_AL().default).sourcePausev(sources);
+	},
+	sourceQueueBuffer: function(source,buffer) {
+		(lime_media_openal_AL().default).sourceQueueBuffer(source,buffer);
+	},
+	sourceQueueBuffers: function(source,nb,buffers) {
+		(lime_media_openal_AL().default).sourceQueueBuffers(source,nb,buffers);
+	},
+	sourceUnqueueBuffer: function(source) {
+		return (lime_media_openal_AL().default).sourceUnqueueBuffer(source);
+	},
+	sourceUnqueueBuffers: function(source,nb) {
+		return (lime_media_openal_AL().default).sourceUnqueueBuffers(source,nb);
+	},
+	speedOfSound: function(value) {
+		(lime_media_openal_AL().default).speedOfSound(value);
+	}
+};
+ALAudioContext.prototype.__class__ = $hxClasses["lime.media.ALAudioContext"] = ALAudioContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ALAudioContext;

hGameTest/node_modules/openfl/lib/_gen/lime/media/ALCAudioContext.js

@@ -0,0 +1,107 @@
+// Class: lime.media.ALCAudioContext
+
+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 lime_media_openal_ALC() {return require("./../../lime/media/openal/ALC");}
+
+// Constructor
+
+var ALCAudioContext = function() {
+	this.ALL_DEVICES_SPECIFIER = 4115;
+	this.DEFAULT_ALL_DEVICES_SPECIFIER = 4114;
+	this.ENUMERATE_ALL_EXT = 1;
+	this.EXTENSIONS = 4102;
+	this.DEVICE_SPECIFIER = 4101;
+	this.DEFAULT_DEVICE_SPECIFIER = 4100;
+	this.ALL_ATTRIBUTES = 4099;
+	this.ATTRIBUTES_SIZE = 4098;
+	this.OUT_OF_MEMORY = 40965;
+	this.INVALID_VALUE = 40964;
+	this.INVALID_ENUM = 40963;
+	this.INVALID_CONTEXT = 40962;
+	this.INVALID_DEVICE = 40961;
+	this.NO_ERROR = 0;
+	this.STEREO_SOURCES = 4113;
+	this.MONO_SOURCES = 4112;
+	this.SYNC = 4105;
+	this.REFRESH = 4104;
+	this.FREQUENCY = 4103;
+	this.TRUE = 1;
+	this.FALSE = 0;
+}
+
+// Meta
+
+ALCAudioContext.__name__ = ["lime","media","ALCAudioContext"];
+ALCAudioContext.prototype = {
+	closeDevice: function(device) {
+		return (lime_media_openal_ALC().default).closeDevice(device);
+	},
+	createContext: function(device,attrlist) {
+		return (lime_media_openal_ALC().default).createContext(device,attrlist);
+	},
+	destroyContext: function(context) {
+		(lime_media_openal_ALC().default).destroyContext(context);
+	},
+	getContextsDevice: function(context) {
+		return (lime_media_openal_ALC().default).getContextsDevice(context);
+	},
+	getCurrentContext: function() {
+		return (lime_media_openal_ALC().default).getCurrentContext();
+	},
+	getError: function(device) {
+		return (lime_media_openal_ALC().default).getError(device);
+	},
+	getErrorString: function(device) {
+		return (lime_media_openal_ALC().default).getErrorString(device);
+	},
+	getIntegerv: function(device,param,count) {
+		if(count == null) {
+			count = 1;
+		}
+		return (lime_media_openal_ALC().default).getIntegerv(device,param,count);
+	},
+	getString: function(device,param) {
+		return (lime_media_openal_ALC().default).getString(device,param);
+	},
+	makeContextCurrent: function(context) {
+		return (lime_media_openal_ALC().default).makeContextCurrent(context);
+	},
+	openDevice: function(deviceName) {
+		return (lime_media_openal_ALC().default).openDevice(deviceName);
+	},
+	pauseDevice: function(device) {
+		(lime_media_openal_ALC().default).pauseDevice(device);
+	},
+	processContext: function(context) {
+		(lime_media_openal_ALC().default).processContext(context);
+	},
+	resumeDevice: function(device) {
+		(lime_media_openal_ALC().default).resumeDevice(device);
+	},
+	suspendContext: function(context) {
+		(lime_media_openal_ALC().default).suspendContext(context);
+	}
+};
+ALCAudioContext.prototype.__class__ = $hxClasses["lime.media.ALCAudioContext"] = ALCAudioContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ALCAudioContext;

hGameTest/node_modules/openfl/lib/_gen/lime/media/AudioBuffer.js

@@ -0,0 +1,179 @@
+// Class: lime.media.AudioBuffer
+
+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_crypto_Base64() {return require("./../../haxe/crypto/Base64");}
+function lime_media_howlerjs_Howl() {return require("howler");}
+function lime_app_Promise() {return require("./../../lime/app/Promise");}
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+
+// Constructor
+
+var AudioBuffer = function() {
+}
+
+// Meta
+
+AudioBuffer.__name__ = ["lime","media","AudioBuffer"];
+AudioBuffer.prototype = {
+	dispose: function() {
+		this.__srcHowl.unload();
+	},
+	get_src: function() {
+		return this.__srcHowl;
+	},
+	set_src: function(value) {
+		return this.__srcHowl = value;
+	}
+};
+AudioBuffer.prototype.__class__ = $hxClasses["lime.media.AudioBuffer"] = AudioBuffer;
+
+// Init
+
+{
+	var p = AudioBuffer.prototype;
+	Object.defineProperties(p,{ "src" : { get : p.get_src, set : p.set_src}});
+};
+
+// Statics
+
+AudioBuffer.fromBase64 = function(base64String) {
+	if(base64String == null) {
+		return null;
+	}
+	if(base64String.indexOf(",") == -1) {
+		base64String = "data:" + AudioBuffer.__getCodec((haxe_crypto_Base64().default).decode(base64String)) + ";base64," + base64String;
+	}
+	var audioBuffer = new AudioBuffer();
+	audioBuffer.set_src(new (lime_media_howlerjs_Howl().Howl)({ src : [base64String], html5 : true, preload : false}));
+	return audioBuffer;
+}
+AudioBuffer.fromBytes = function(bytes) {
+	if(bytes == null) {
+		return null;
+	}
+	var audioBuffer = new AudioBuffer();
+	audioBuffer.set_src(new (lime_media_howlerjs_Howl().Howl)({ src : ["data:" + AudioBuffer.__getCodec(bytes) + ";base64," + (haxe_crypto_Base64().default).encode(bytes)], html5 : true, preload : false}));
+	return audioBuffer;
+}
+AudioBuffer.fromFile = function(path) {
+	if(path == null) {
+		return null;
+	}
+	var audioBuffer = new AudioBuffer();
+	audioBuffer.__srcHowl = new (lime_media_howlerjs_Howl().Howl)({ src : [path], preload : false});
+	return audioBuffer;
+}
+AudioBuffer.fromFiles = function(paths) {
+	var audioBuffer = new AudioBuffer();
+	audioBuffer.__srcHowl = new (lime_media_howlerjs_Howl().Howl)({ src : paths, preload : false});
+	return audioBuffer;
+}
+AudioBuffer.fromVorbisFile = function(vorbisFile) {
+	return null;
+}
+AudioBuffer.loadFromFile = function(path) {
+	var promise = new (lime_app_Promise().default)();
+	var audioBuffer = AudioBuffer.fromFile(path);
+	if(audioBuffer != null) {
+		if(audioBuffer != null) {
+			audioBuffer.__srcHowl.on("load",function() {
+				promise.complete(audioBuffer);
+			});
+			audioBuffer.__srcHowl.on("loaderror",function(id,msg) {
+				promise.error(msg);
+			});
+			audioBuffer.__srcHowl.load();
+		}
+	} else {
+		promise.error(null);
+	}
+	return promise.future;
+}
+AudioBuffer.loadFromFiles = function(paths) {
+	var promise = new (lime_app_Promise().default)();
+	var audioBuffer = AudioBuffer.fromFiles(paths);
+	if(audioBuffer != null) {
+		audioBuffer.__srcHowl.on("load",function() {
+			promise.complete(audioBuffer);
+		});
+		audioBuffer.__srcHowl.on("loaderror",function() {
+			promise.error(null);
+		});
+		audioBuffer.__srcHowl.load();
+	} else {
+		promise.error(null);
+	}
+	return promise.future;
+}
+AudioBuffer.__getCodec = function(bytes) {
+	var signature = bytes.getString(0,4);
+	switch(signature) {
+	case "OggS":
+		return "audio/ogg";
+	case "RIFF":
+		if(bytes.getString(8,4) == "WAVE") {
+			return "audio/wav";
+		} else {
+			var _g = bytes.get(2);
+			var _g1 = bytes.get(1);
+			var _g2 = bytes.get(0);
+			switch(_g2) {
+			case 73:
+				if(_g1 == 68) {
+					if(_g == 51) {
+						return "audio/mp3";
+					}
+				}
+				break;
+			case 255:
+				switch(_g1) {
+				case 250:case 251:
+					return "audio/mp3";
+				default:
+				}
+				break;
+			default:
+			}
+		}
+		break;
+	case "fLaC":
+		return "audio/flac";
+	default:
+		var _g3 = bytes.get(2);
+		var _g11 = bytes.get(1);
+		var _g21 = bytes.get(0);
+		switch(_g21) {
+		case 73:
+			if(_g11 == 68) {
+				if(_g3 == 51) {
+					return "audio/mp3";
+				}
+			}
+			break;
+		case 255:
+			switch(_g11) {
+			case 250:case 251:
+				return "audio/mp3";
+			default:
+			}
+			break;
+		default:
+		}
+	}
+	(lime_utils_Log().default).error("Unsupported sound format",{ fileName : "AudioBuffer.hx", lineNumber : 493, className : "lime.media.AudioBuffer", methodName : "__getCodec"});
+	return null;
+}
+
+
+// Export
+
+exports.default = AudioBuffer;

hGameTest/node_modules/openfl/lib/_gen/lime/media/AudioContext.js

@@ -0,0 +1,22 @@
+// Enum: lime.media.AudioContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var AudioContext = $hxClasses["lime.media.AudioContext"] = { __ename__: ["lime","media","AudioContext"], __constructs__: ["OPENAL","HTML5","WEB","FLASH","CUSTOM"] }
+
+AudioContext.OPENAL = function(alc,al) { var $x = ["OPENAL",0,alc,al]; $x.__enum__ = AudioContext; $x.toString = $estr; return $x; }
+AudioContext.FLASH = function(context) { var $x = ["FLASH",3,context]; $x.__enum__ = AudioContext; $x.toString = $estr; return $x; }
+AudioContext.WEB = function(context) { var $x = ["WEB",2,context]; $x.__enum__ = AudioContext; $x.toString = $estr; return $x; }
+AudioContext.CUSTOM = function(data) { var $x = ["CUSTOM",4,data]; $x.__enum__ = AudioContext; $x.toString = $estr; return $x; }
+AudioContext.HTML5 = function(context) { var $x = ["HTML5",1,context]; $x.__enum__ = AudioContext; $x.toString = $estr; return $x; }
+
+exports.default = AudioContext;

hGameTest/node_modules/openfl/lib/_gen/lime/media/AudioManager.js

@@ -0,0 +1,102 @@
+// Class: lime.media.AudioManager
+
+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 lime_media_AudioContext() {return require("./../../lime/media/AudioContext");}
+function lime_media_HTML5AudioContext() {return require("./../../lime/media/HTML5AudioContext");}
+function Type() {return require("./../../Type");}
+
+// Constructor
+
+var AudioManager = function(){}
+
+// Meta
+
+AudioManager.__name__ = ["lime","media","AudioManager"];
+AudioManager.prototype = {
+	
+};
+AudioManager.prototype.__class__ = $hxClasses["lime.media.AudioManager"] = AudioManager;
+
+// Init
+
+
+
+// Statics
+
+AudioManager.init = function(context) {
+	if(AudioManager.context == null) {
+		if(context == null) {
+			try {
+				window.AudioContext = window.AudioContext || window.webkitAudioContext;
+				AudioManager.context = (lime_media_AudioContext().default).WEB(new AudioContext ());
+			} catch( e ) {
+				AudioManager.context = (lime_media_AudioContext().default).HTML5(new (lime_media_HTML5AudioContext().default)());
+			}
+		} else {
+			AudioManager.context = context;
+		}
+	}
+}
+AudioManager.resume = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				var device = alc.getContextsDevice(currentContext);
+				alc.resumeDevice(device);
+				alc.processContext(currentContext);
+			}
+		}
+	}
+}
+AudioManager.shutdown = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				var device = alc.getContextsDevice(currentContext);
+				alc.makeContextCurrent(null);
+				alc.destroyContext(currentContext);
+				if(device != null) {
+					alc.closeDevice(device);
+				}
+			}
+		}
+		AudioManager.context = null;
+	}
+}
+AudioManager.suspend = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				alc.suspendContext(currentContext);
+				var device = alc.getContextsDevice(currentContext);
+				alc.pauseDevice(device);
+			}
+		}
+	}
+}
+
+
+// Export
+
+exports.default = AudioManager;

hGameTest/node_modules/openfl/lib/_gen/lime/media/AudioSource.js

@@ -0,0 +1,101 @@
+// Class: lime.media.AudioSource
+
+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 lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+function lime__$backend_html5_HTML5AudioSource() {return require("./../../lime/_backend/html5/HTML5AudioSource");}
+
+// Constructor
+
+var AudioSource = function(buffer,offset,length,loops) {
+	if(loops == null) {
+		loops = 0;
+	}
+	if(offset == null) {
+		offset = 0;
+	}
+	this.onComplete = new (lime_app__$Event_$Void_$Void().default)();
+	this.buffer = buffer;
+	this.offset = offset;
+	this.backend = new (lime__$backend_html5_HTML5AudioSource().default)(this);
+	if(length != null && length != 0) {
+		this.set_length(length);
+	}
+	this.set_loops(loops);
+	if(buffer != null) {
+		this.init();
+	}
+}
+
+// Meta
+
+AudioSource.__name__ = ["lime","media","AudioSource"];
+AudioSource.prototype = {
+	dispose: function() {
+		this.backend.dispose();
+	},
+	init: function() {
+		this.backend.init();
+	},
+	play: function() {
+		this.backend.play();
+	},
+	pause: function() {
+		this.backend.pause();
+	},
+	stop: function() {
+		this.backend.stop();
+	},
+	get_currentTime: function() {
+		return this.backend.getCurrentTime();
+	},
+	set_currentTime: function(value) {
+		return this.backend.setCurrentTime(value);
+	},
+	get_gain: function() {
+		return this.backend.getGain();
+	},
+	set_gain: function(value) {
+		return this.backend.setGain(value);
+	},
+	get_length: function() {
+		return this.backend.getLength();
+	},
+	set_length: function(value) {
+		return this.backend.setLength(value);
+	},
+	get_loops: function() {
+		return this.backend.getLoops();
+	},
+	set_loops: function(value) {
+		return this.backend.setLoops(value);
+	},
+	get_position: function() {
+		return this.backend.getPosition();
+	},
+	set_position: function(value) {
+		return this.backend.setPosition(value);
+	}
+};
+AudioSource.prototype.__class__ = $hxClasses["lime.media.AudioSource"] = AudioSource;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = AudioSource;

hGameTest/node_modules/openfl/lib/_gen/lime/media/FlashAudioContext.js

@@ -0,0 +1,89 @@
+// Class: lime.media.FlashAudioContext
+
+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 FlashAudioContext = function() {
+}
+
+// Meta
+
+FlashAudioContext.__name__ = ["lime","media","FlashAudioContext"];
+FlashAudioContext.prototype = {
+	createBuffer: function(stream,context) {
+		return null;
+	},
+	getBytesLoaded: function(buffer) {
+		return 0;
+	},
+	getBytesTotal: function(buffer) {
+		return 0;
+	},
+	getID3: function(buffer) {
+		return null;
+	},
+	getIsBuffering: function(buffer) {
+		return false;
+	},
+	getIsURLInaccessible: function(buffer) {
+		return false;
+	},
+	getLength: function(buffer) {
+		return 0;
+	},
+	getURL: function(buffer) {
+		return null;
+	},
+	close: function(buffer) {
+	},
+	extract: function(buffer,target,length,startPosition) {
+		if(startPosition == null) {
+			startPosition = -1;
+		}
+		return 0;
+	},
+	load: function(buffer,stream,context) {
+	},
+	loadCompressedDataFromByteArray: function(buffer,bytes,bytesLength) {
+	},
+	loadPCMFromByteArray: function(buffer,bytes,samples,format,stereo,sampleRate) {
+		if(sampleRate == null) {
+			sampleRate = 44100;
+		}
+		if(stereo == null) {
+			stereo = true;
+		}
+	},
+	play: function(buffer,startTime,loops,sndTransform) {
+		if(loops == null) {
+			loops = 0;
+		}
+		if(startTime == null) {
+			startTime = 0;
+		}
+		return null;
+	}
+};
+FlashAudioContext.prototype.__class__ = $hxClasses["lime.media.FlashAudioContext"] = FlashAudioContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = FlashAudioContext;

hGameTest/node_modules/openfl/lib/_gen/lime/media/HTML5AudioContext.js

@@ -0,0 +1,248 @@
+// Class: lime.media.HTML5AudioContext
+
+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 lime_media_AudioBuffer() {return require("./../../lime/media/AudioBuffer");}
+
+// Constructor
+
+var HTML5AudioContext = function() {
+	this.NETWORK_NO_SOURCE = 3;
+	this.NETWORK_LOADING = 2;
+	this.NETWORK_IDLE = 1;
+	this.NETWORK_EMPTY = 0;
+	this.HAVE_NOTHING = 0;
+	this.HAVE_METADATA = 1;
+	this.HAVE_FUTURE_DATA = 3;
+	this.HAVE_ENOUGH_DATA = 4;
+	this.HAVE_CURRENT_DATA = 2;
+}
+
+// Meta
+
+HTML5AudioContext.__name__ = ["lime","media","HTML5AudioContext"];
+HTML5AudioContext.prototype = {
+	canPlayType: function(buffer,type) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.canPlayType(type);
+		}
+		return null;
+	},
+	createBuffer: function(urlString) {
+		var buffer = new (lime_media_AudioBuffer().default)();
+		buffer.__srcAudio = new Audio();
+		buffer.__srcAudio.src = urlString;
+		return buffer;
+	},
+	getAutoplay: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.autoplay;
+		}
+		return false;
+	},
+	getBuffered: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.buffered;
+		}
+		return null;
+	},
+	getCurrentSrc: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.currentSrc;
+		}
+		return null;
+	},
+	getCurrentTime: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.currentTime;
+		}
+		return 0;
+	},
+	getDefaultPlaybackRate: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.defaultPlaybackRate;
+		}
+		return 1;
+	},
+	getDuration: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.duration;
+		}
+		return 0;
+	},
+	getEnded: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.ended;
+		}
+		return false;
+	},
+	getError: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.error;
+		}
+		return null;
+	},
+	getLoop: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.loop;
+		}
+		return false;
+	},
+	getMuted: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.muted;
+		}
+		return false;
+	},
+	getNetworkState: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.networkState;
+		}
+		return 0;
+	},
+	getPaused: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.paused;
+		}
+		return false;
+	},
+	getPlaybackRate: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.playbackRate;
+		}
+		return 1;
+	},
+	getPlayed: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.played;
+		}
+		return null;
+	},
+	getPreload: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.preload;
+		}
+		return null;
+	},
+	getReadyState: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.readyState;
+		}
+		return 0;
+	},
+	getSeekable: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.seekable;
+		}
+		return null;
+	},
+	getSeeking: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.seeking;
+		}
+		return false;
+	},
+	getSrc: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.src;
+		}
+		return null;
+	},
+	getStartTime: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.playbackRate;
+		}
+		return 0;
+	},
+	getVolume: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			return buffer.__srcAudio.volume;
+		}
+		return 1;
+	},
+	load: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.load();
+			return;
+		}
+	},
+	pause: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.pause();
+			return;
+		}
+	},
+	play: function(buffer) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.play();
+			return;
+		}
+	},
+	setAutoplay: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.autoplay = value;
+		}
+	},
+	setCurrentTime: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.currentTime = value;
+		}
+	},
+	setDefaultPlaybackRate: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.defaultPlaybackRate = value;
+		}
+	},
+	setLoop: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.loop = value;
+		}
+	},
+	setMuted: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.muted = value;
+		}
+	},
+	setPlaybackRate: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.playbackRate = value;
+		}
+	},
+	setPreload: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.preload = value;
+		}
+	},
+	setSrc: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.src = value;
+		}
+	},
+	setVolume: function(buffer,value) {
+		if(buffer.__srcAudio != null) {
+			buffer.__srcAudio.volume = value;
+		}
+	}
+};
+HTML5AudioContext.prototype.__class__ = $hxClasses["lime.media.HTML5AudioContext"] = HTML5AudioContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = HTML5AudioContext;

hGameTest/node_modules/openfl/lib/_gen/lime/media/codecs/vorbis/VorbisComment.js

@@ -0,0 +1,37 @@
+// Class: lime.media.codecs.vorbis.VorbisComment
+
+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 VorbisComment = function() {
+}
+
+// Meta
+
+VorbisComment.__name__ = ["lime","media","codecs","vorbis","VorbisComment"];
+VorbisComment.prototype = {
+	
+};
+VorbisComment.prototype.__class__ = $hxClasses["lime.media.codecs.vorbis.VorbisComment"] = VorbisComment;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VorbisComment;

hGameTest/node_modules/openfl/lib/_gen/lime/media/codecs/vorbis/VorbisFile.js

@@ -0,0 +1,161 @@
+// Class: lime.media.codecs.vorbis.VorbisFile
+
+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__$Int64__$_$_$Int64() {return require("./../../../../haxe/_Int64/___Int64");}
+
+// Constructor
+
+var VorbisFile = function(handle) {
+	this.handle = handle;
+}
+
+// Meta
+
+VorbisFile.__name__ = ["lime","media","codecs","vorbis","VorbisFile"];
+VorbisFile.prototype = {
+	bitrate: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		return 0;
+	},
+	bitrateInstant: function() {
+		return 0;
+	},
+	clear: function() {
+	},
+	comment: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		return null;
+	},
+	crosslap: function(other) {
+		return 0;
+	},
+	info: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		return null;
+	},
+	pcmSeek: function(pos) {
+		return 0;
+	},
+	pcmSeekLap: function(pos) {
+		return 0;
+	},
+	pcmSeekPage: function(pos) {
+		return 0;
+	},
+	pcmSeekPageLap: function(pos) {
+		return 0;
+	},
+	pcmTell: function() {
+		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
+		return this1;
+	},
+	pcmTotal: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
+		return this1;
+	},
+	rawSeek: function(pos) {
+		return 0;
+	},
+	rawSeekLap: function(pos) {
+		return 0;
+	},
+	rawTell: function() {
+		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
+		return this1;
+	},
+	rawTotal: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
+		return this1;
+	},
+	read: function(buffer,position,length,bigEndianPacking,wordSize,signed) {
+		if(signed == null) {
+			signed = true;
+		}
+		if(wordSize == null) {
+			wordSize = 2;
+		}
+		if(bigEndianPacking == null) {
+			bigEndianPacking = false;
+		}
+		if(length == null) {
+			length = 4096;
+		}
+		return 0;
+	},
+	readFloat: function(pcmChannels,samples) {
+		return 0;
+	},
+	seekable: function() {
+		return false;
+	},
+	serialNumber: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		return 0;
+	},
+	streams: function() {
+		return 0;
+	},
+	timeSeek: function(s) {
+		return 0;
+	},
+	timeSeekLap: function(s) {
+		return 0;
+	},
+	timeSeekPage: function(s) {
+		return 0;
+	},
+	timeSeekPageLap: function(s) {
+		return 0;
+	},
+	timeTell: function() {
+		return 0;
+	},
+	timeTotal: function(bitstream) {
+		if(bitstream == null) {
+			bitstream = -1;
+		}
+		return 0;
+	}
+};
+VorbisFile.prototype.__class__ = $hxClasses["lime.media.codecs.vorbis.VorbisFile"] = VorbisFile;
+
+// Init
+
+
+
+// Statics
+
+VorbisFile.fromBytes = function(bytes) {
+	return null;
+}
+VorbisFile.fromFile = function(path) {
+	return null;
+}
+
+
+// Export
+
+exports.default = VorbisFile;

hGameTest/node_modules/openfl/lib/_gen/lime/media/codecs/vorbis/VorbisInfo.js

@@ -0,0 +1,37 @@
+// Class: lime.media.codecs.vorbis.VorbisInfo
+
+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 VorbisInfo = function() {
+}
+
+// Meta
+
+VorbisInfo.__name__ = ["lime","media","codecs","vorbis","VorbisInfo"];
+VorbisInfo.prototype = {
+	
+};
+VorbisInfo.prototype.__class__ = $hxClasses["lime.media.codecs.vorbis.VorbisInfo"] = VorbisInfo;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = VorbisInfo;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/AL.js

@@ -0,0 +1,526 @@
+// Class: lime.media.openal.AL
+
+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 AL = function(){}
+
+// Meta
+
+AL.__name__ = ["lime","media","openal","AL"];
+AL.prototype = {
+	
+};
+AL.prototype.__class__ = $hxClasses["lime.media.openal.AL"] = AL;
+
+// Init
+
+
+
+// Statics
+
+AL.removeDirectFilter = function(source) {
+}
+AL.removeSend = function(source,index) {
+}
+AL.auxf = function(aux,param,value) {
+}
+AL.auxfv = function(aux,param,values) {
+}
+AL.auxi = function(aux,param,value) {
+}
+AL.auxiv = function(aux,param,values) {
+}
+AL.bufferData = function(buffer,format,data,size,freq) {
+}
+AL.buffer3f = function(buffer,param,value1,value2,value3) {
+}
+AL.buffer3i = function(buffer,param,value1,value2,value3) {
+}
+AL.bufferf = function(buffer,param,value) {
+}
+AL.bufferfv = function(buffer,param,values) {
+}
+AL.bufferi = function(buffer,param,value) {
+}
+AL.bufferiv = function(buffer,param,values) {
+}
+AL.createAux = function() {
+	return null;
+}
+AL.createBuffer = function() {
+	return null;
+}
+AL.createEffect = function() {
+	return null;
+}
+AL.createFilter = function() {
+	return null;
+}
+AL.createSource = function() {
+	return null;
+}
+AL.deleteBuffer = function(buffer) {
+}
+AL.deleteBuffers = function(buffers) {
+}
+AL.deleteSource = function(source) {
+}
+AL.deleteSources = function(sources) {
+}
+AL.disable = function(capability) {
+}
+AL.distanceModel = function(distanceModel) {
+}
+AL.dopplerFactor = function(value) {
+}
+AL.dopplerVelocity = function(value) {
+}
+AL.effectf = function(effect,param,value) {
+}
+AL.effectfv = function(effect,param,values) {
+}
+AL.effecti = function(effect,param,value) {
+}
+AL.effectiv = function(effect,param,values) {
+}
+AL.enable = function(capability) {
+}
+AL.genSource = function() {
+	return null;
+}
+AL.genSources = function(n) {
+	return null;
+}
+AL.genBuffer = function() {
+	return null;
+}
+AL.genBuffers = function(n) {
+	return null;
+}
+AL.getBoolean = function(param) {
+	return false;
+}
+AL.getBooleanv = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getBuffer3f = function(buffer,param) {
+	return null;
+}
+AL.getBuffer3i = function(buffer,param) {
+	return null;
+}
+AL.getBufferf = function(buffer,param) {
+	return 0;
+}
+AL.getBufferfv = function(buffer,param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getBufferi = function(buffer,param) {
+	return 0;
+}
+AL.getBufferiv = function(buffer,param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getDouble = function(param) {
+	return 0;
+}
+AL.getDoublev = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getEnumValue = function(ename) {
+	return 0;
+}
+AL.getError = function() {
+	return 0;
+}
+AL.getErrorString = function() {
+	var _g = AL.getError();
+	switch(_g) {
+	case 40961:
+		return "INVALID_NAME: Invalid parameter name";
+	case 40962:
+		return "INVALID_ENUM: Invalid enum value";
+	case 40963:
+		return "INVALID_VALUE: Invalid parameter value";
+	case 40964:
+		return "INVALID_OPERATION: Illegal operation or call";
+	case 40965:
+		return "OUT_OF_MEMORY: OpenAL has run out of memory";
+	default:
+		return "";
+	}
+}
+AL.getFilteri = function(filter,param) {
+	return 0;
+}
+AL.getFloat = function(param) {
+	return 0;
+}
+AL.getFloatv = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getInteger = function(param) {
+	return 0;
+}
+AL.getIntegerv = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getListener3f = function(param) {
+	return null;
+}
+AL.getListener3i = function(param) {
+	return null;
+}
+AL.getListenerf = function(param) {
+	return 0;
+}
+AL.getListenerfv = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getListeneri = function(param) {
+	return 0;
+}
+AL.getListeneriv = function(param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getParameter = function(param) {
+	return null;
+}
+AL.getProcAddress = function(fname) {
+	return null;
+}
+AL.getSource3f = function(source,param) {
+	return null;
+}
+AL.getSourcef = function(source,param) {
+	return 0;
+}
+AL.getSource3i = function(source,param) {
+	return null;
+}
+AL.getSourcefv = function(source,param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getSourcei = function(source,param) {
+	return 0;
+}
+AL.getSourceiv = function(source,param,count) {
+	if(count == null) {
+		count = 1;
+	}
+	return null;
+}
+AL.getString = function(param) {
+	return null;
+}
+AL.isBuffer = function(buffer) {
+	return false;
+}
+AL.isEnabled = function(capability) {
+	return false;
+}
+AL.isExtensionPresent = function(extname) {
+	return false;
+}
+AL.isAux = function(aux) {
+	return false;
+}
+AL.isEffect = function(effect) {
+	return false;
+}
+AL.isFilter = function(filter) {
+	return false;
+}
+AL.isSource = function(source) {
+	return false;
+}
+AL.listener3f = function(param,value1,value2,value3) {
+}
+AL.listener3i = function(param,value1,value2,value3) {
+}
+AL.listenerf = function(param,value) {
+}
+AL.listenerfv = function(param,values) {
+}
+AL.listeneri = function(param,value) {
+}
+AL.listeneriv = function(param,values) {
+}
+AL.source3f = function(source,param,value1,value2,value3) {
+}
+AL.source3i = function(source,param,value1,value2,value3) {
+}
+AL.sourcef = function(source,param,value) {
+}
+AL.sourcefv = function(source,param,values) {
+}
+AL.sourcei = function(source,param,value) {
+}
+AL.filteri = function(filter,param,value) {
+}
+AL.filterf = function(filter,param,value) {
+}
+AL.sourceiv = function(source,param,values) {
+}
+AL.sourcePlay = function(source) {
+}
+AL.sourcePlayv = function(sources) {
+}
+AL.sourceStop = function(source) {
+}
+AL.sourceStopv = function(sources) {
+}
+AL.sourceRewind = function(source) {
+}
+AL.sourceRewindv = function(sources) {
+}
+AL.sourcePause = function(source) {
+}
+AL.sourcePausev = function(sources) {
+}
+AL.sourceQueueBuffer = function(source,buffer) {
+}
+AL.sourceQueueBuffers = function(source,nb,buffers) {
+}
+AL.sourceUnqueueBuffer = function(source) {
+	return 0;
+}
+AL.sourceUnqueueBuffers = function(source,nb) {
+	return null;
+}
+AL.speedOfSound = function(value) {
+}
+AL.NONE = 0
+AL.FALSE = 0
+AL.TRUE = 1
+AL.SOURCE_RELATIVE = 514
+AL.CONE_INNER_ANGLE = 4097
+AL.CONE_OUTER_ANGLE = 4098
+AL.PITCH = 4099
+AL.POSITION = 4100
+AL.DIRECTION = 4101
+AL.VELOCITY = 4102
+AL.LOOPING = 4103
+AL.BUFFER = 4105
+AL.GAIN = 4106
+AL.MIN_GAIN = 4109
+AL.MAX_GAIN = 4110
+AL.ORIENTATION = 4111
+AL.SOURCE_STATE = 4112
+AL.INITIAL = 4113
+AL.PLAYING = 4114
+AL.PAUSED = 4115
+AL.STOPPED = 4116
+AL.BUFFERS_QUEUED = 4117
+AL.BUFFERS_PROCESSED = 4118
+AL.REFERENCE_DISTANCE = 4128
+AL.ROLLOFF_FACTOR = 4129
+AL.CONE_OUTER_GAIN = 4130
+AL.MAX_DISTANCE = 4131
+AL.SEC_OFFSET = 4132
+AL.SAMPLE_OFFSET = 4133
+AL.BYTE_OFFSET = 4134
+AL.SOURCE_TYPE = 4135
+AL.STATIC = 4136
+AL.STREAMING = 4137
+AL.UNDETERMINED = 4144
+AL.FORMAT_MONO8 = 4352
+AL.FORMAT_MONO16 = 4353
+AL.FORMAT_STEREO8 = 4354
+AL.FORMAT_STEREO16 = 4355
+AL.FREQUENCY = 8193
+AL.BITS = 8194
+AL.CHANNELS = 8195
+AL.SIZE = 8196
+AL.NO_ERROR = 0
+AL.INVALID_NAME = 40961
+AL.INVALID_ENUM = 40962
+AL.INVALID_VALUE = 40963
+AL.INVALID_OPERATION = 40964
+AL.OUT_OF_MEMORY = 40965
+AL.VENDOR = 45057
+AL.VERSION = 45058
+AL.RENDERER = 45059
+AL.EXTENSIONS = 45060
+AL.DOPPLER_FACTOR = 49152
+AL.SPEED_OF_SOUND = 49155
+AL.DOPPLER_VELOCITY = 49153
+AL.DISTANCE_MODEL = 53248
+AL.INVERSE_DISTANCE = 53249
+AL.INVERSE_DISTANCE_CLAMPED = 53250
+AL.LINEAR_DISTANCE = 53251
+AL.LINEAR_DISTANCE_CLAMPED = 53252
+AL.EXPONENT_DISTANCE = 53253
+AL.EXPONENT_DISTANCE_CLAMPED = 53254
+AL.METERS_PER_UNIT = 131076
+AL.DIRECT_FILTER = 131077
+AL.AUXILIARY_SEND_FILTER = 131078
+AL.AIR_ABSORPTION_FACTOR = 131079
+AL.ROOM_ROLLOFF_FACTOR = 131080
+AL.CONE_OUTER_GAINHF = 131081
+AL.DIRECT_FILTER_GAINHF_AUTO = 131082
+AL.AUXILIARY_SEND_FILTER_GAIN_AUTO = 131083
+AL.AUXILIARY_SEND_FILTER_GAINHF_AUTO = 131084
+AL.REVERB_DENSITY = 1
+AL.REVERB_DIFFUSION = 2
+AL.REVERB_GAIN = 3
+AL.REVERB_GAINHF = 4
+AL.REVERB_DECAY_TIME = 5
+AL.REVERB_DECAY_HFRATIO = 6
+AL.REVERB_REFLECTIONS_GAIN = 7
+AL.REVERB_REFLECTIONS_DELAY = 8
+AL.REVERB_LATE_REVERB_GAIN = 9
+AL.REVERB_LATE_REVERB_DELAY = 10
+AL.REVERB_AIR_ABSORPTION_GAINHF = 11
+AL.REVERB_ROOM_ROLLOFF_FACTOR = 12
+AL.REVERB_DECAY_HFLIMIT = 13
+AL.EAXREVERB_DENSITY = 1
+AL.EAXREVERB_DIFFUSION = 2
+AL.EAXREVERB_GAIN = 3
+AL.EAXREVERB_GAINHF = 4
+AL.EAXREVERB_GAINLF = 5
+AL.EAXREVERB_DECAY_TIME = 6
+AL.EAXREVERB_DECAY_HFRATIO = 7
+AL.EAXREVERB_DECAY_LFRATIO = 8
+AL.EAXREVERB_REFLECTIONS_GAIN = 9
+AL.EAXREVERB_REFLECTIONS_DELAY = 10
+AL.EAXREVERB_REFLECTIONS_PAN = 11
+AL.EAXREVERB_LATE_REVERB_GAIN = 12
+AL.EAXREVERB_LATE_REVERB_DELAY = 13
+AL.EAXREVERB_LATE_REVERB_PAN = 14
+AL.EAXREVERB_ECHO_TIME = 15
+AL.EAXREVERB_ECHO_DEPTH = 16
+AL.EAXREVERB_MODULATION_TIME = 17
+AL.EAXREVERB_MODULATION_DEPTH = 18
+AL.EAXREVERB_AIR_ABSORPTION_GAINHF = 19
+AL.EAXREVERB_HFREFERENCE = 20
+AL.EAXREVERB_LFREFERENCE = 21
+AL.EAXREVERB_ROOM_ROLLOFF_FACTOR = 22
+AL.EAXREVERB_DECAY_HFLIMIT = 23
+AL.CHORUS_WAVEFORM = 1
+AL.CHORUS_PHASE = 2
+AL.CHORUS_RATE = 3
+AL.CHORUS_DEPTH = 4
+AL.CHORUS_FEEDBACK = 5
+AL.CHORUS_DELAY = 6
+AL.DISTORTION_EDGE = 1
+AL.DISTORTION_GAIN = 2
+AL.DISTORTION_LOWPASS_CUTOFF = 3
+AL.DISTORTION_EQCENTER = 4
+AL.DISTORTION_EQBANDWIDTH = 5
+AL.ECHO_DELAY = 1
+AL.ECHO_LRDELAY = 2
+AL.ECHO_DAMPING = 3
+AL.ECHO_FEEDBACK = 4
+AL.ECHO_SPREAD = 5
+AL.FLANGER_WAVEFORM = 1
+AL.FLANGER_PHASE = 2
+AL.FLANGER_RATE = 3
+AL.FLANGER_DEPTH = 4
+AL.FLANGER_FEEDBACK = 5
+AL.FLANGER_DELAY = 6
+AL.FREQUENCY_SHIFTER_FREQUENCY = 1
+AL.FREQUENCY_SHIFTER_LEFT_DIRECTION = 2
+AL.FREQUENCY_SHIFTER_RIGHT_DIRECTION = 3
+AL.VOCAL_MORPHER_PHONEMEA = 1
+AL.VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 2
+AL.VOCAL_MORPHER_PHONEMEB = 3
+AL.VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 4
+AL.VOCAL_MORPHER_WAVEFORM = 5
+AL.VOCAL_MORPHER_RATE = 6
+AL.PITCH_SHIFTER_COARSE_TUNE = 1
+AL.PITCH_SHIFTER_FINE_TUNE = 2
+AL.RING_MODULATOR_FREQUENCY = 1
+AL.RING_MODULATOR_HIGHPASS_CUTOFF = 2
+AL.RING_MODULATOR_WAVEFORM = 3
+AL.AUTOWAH_ATTACK_TIME = 1
+AL.AUTOWAH_RELEASE_TIME = 2
+AL.AUTOWAH_RESONANCE = 3
+AL.AUTOWAH_PEAK_GAIN = 4
+AL.COMPRESSOR_ONOFF = 1
+AL.EQUALIZER_LOW_GAIN = 1
+AL.EQUALIZER_LOW_CUTOFF = 2
+AL.EQUALIZER_MID1_GAIN = 3
+AL.EQUALIZER_MID1_CENTER = 4
+AL.EQUALIZER_MID1_WIDTH = 5
+AL.EQUALIZER_MID2_GAIN = 6
+AL.EQUALIZER_MID2_CENTER = 7
+AL.EQUALIZER_MID2_WIDTH = 8
+AL.EQUALIZER_HIGH_GAIN = 9
+AL.EQUALIZER_HIGH_CUTOFF = 10
+AL.EFFECT_FIRST_PARAMETER = 0
+AL.EFFECT_LAST_PARAMETER = 32768
+AL.EFFECT_TYPE = 32769
+AL.EFFECT_NULL = 0
+AL.EFFECT_EAXREVERB = 32768
+AL.EFFECT_REVERB = 1
+AL.EFFECT_CHORUS = 2
+AL.EFFECT_DISTORTION = 3
+AL.EFFECT_ECHO = 4
+AL.EFFECT_FLANGER = 5
+AL.EFFECT_FREQUENCY_SHIFTER = 6
+AL.EFFECT_VOCAL_MORPHER = 7
+AL.EFFECT_PITCH_SHIFTER = 8
+AL.EFFECT_RING_MODULATOR = 9
+AL.FFECT_AUTOWAH = 10
+AL.EFFECT_COMPRESSOR = 11
+AL.EFFECT_EQUALIZER = 12
+AL.EFFECTSLOT_EFFECT = 1
+AL.EFFECTSLOT_GAIN = 2
+AL.EFFECTSLOT_AUXILIARY_SEND_AUTO = 3
+AL.LOWPASS_GAIN = 1
+AL.LOWPASS_GAINHF = 2
+AL.HIGHPASS_GAIN = 1
+AL.HIGHPASS_GAINLF = 2
+AL.BANDPASS_GAIN = 1
+AL.BANDPASS_GAINLF = 2
+AL.BANDPASS_GAINHF = 3
+AL.FILTER_FIRST_PARAMETER = 0
+AL.FILTER_LAST_PARAMETER = 32768
+AL.FILTER_TYPE = 32769
+AL.FILTER_NULL = 0
+AL.FILTER_LOWPASS = 1
+AL.FILTER_HIGHPASS = 2
+AL.FILTER_BANDPASS = 3
+
+// Export
+
+exports.default = AL;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/ALC.js

@@ -0,0 +1,110 @@
+// Class: lime.media.openal.ALC
+
+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 ALC = function(){}
+
+// Meta
+
+ALC.__name__ = ["lime","media","openal","ALC"];
+ALC.prototype = {
+	
+};
+ALC.prototype.__class__ = $hxClasses["lime.media.openal.ALC"] = ALC;
+
+// Init
+
+
+
+// Statics
+
+ALC.closeDevice = function(device) {
+	return false;
+}
+ALC.createContext = function(device,attrlist) {
+	return null;
+}
+ALC.destroyContext = function(context) {
+}
+ALC.getContextsDevice = function(context) {
+	return null;
+}
+ALC.getCurrentContext = function() {
+	return null;
+}
+ALC.getError = function(device) {
+	return 0;
+}
+ALC.getErrorString = function(device) {
+	var _g = ALC.getError(device);
+	switch(_g) {
+	case 40961:
+		return "INVALID_DEVICE: Invalid device (or no device?)";
+	case 40962:
+		return "INVALID_CONTEXT: Invalid context (or no context?)";
+	case 40963:
+		return "INVALID_ENUM: Invalid enum value";
+	case 40964:
+		return "INVALID_VALUE: Invalid param value";
+	case 40965:
+		return "OUT_OF_MEMORY: OpenAL has run out of memory";
+	default:
+		return "";
+	}
+}
+ALC.getIntegerv = function(device,param,size) {
+	return null;
+}
+ALC.getString = function(device,param) {
+	return null;
+}
+ALC.makeContextCurrent = function(context) {
+	return false;
+}
+ALC.openDevice = function(deviceName) {
+	return null;
+}
+ALC.pauseDevice = function(device) {
+}
+ALC.processContext = function(context) {
+}
+ALC.resumeDevice = function(device) {
+}
+ALC.suspendContext = function(context) {
+}
+ALC.FALSE = 0
+ALC.TRUE = 1
+ALC.FREQUENCY = 4103
+ALC.REFRESH = 4104
+ALC.SYNC = 4105
+ALC.MONO_SOURCES = 4112
+ALC.STEREO_SOURCES = 4113
+ALC.NO_ERROR = 0
+ALC.INVALID_DEVICE = 40961
+ALC.INVALID_CONTEXT = 40962
+ALC.INVALID_ENUM = 40963
+ALC.INVALID_VALUE = 40964
+ALC.OUT_OF_MEMORY = 40965
+ALC.ATTRIBUTES_SIZE = 4098
+ALC.ALL_ATTRIBUTES = 4099
+ALC.DEFAULT_DEVICE_SPECIFIER = 4100
+ALC.DEVICE_SPECIFIER = 4101
+ALC.EXTENSIONS = 4102
+ALC.ENUMERATE_ALL_EXT = 1
+ALC.DEFAULT_ALL_DEVICES_SPECIFIER = 4114
+ALC.ALL_DEVICES_SPECIFIER = 4115
+
+// Export
+
+exports.default = ALC;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALAuxiliaryEffectSlot/ALAuxiliaryEffectSlot_Impl_.js

@@ -0,0 +1,39 @@
+// Class: lime.media.openal._ALAuxiliaryEffectSlot.ALAuxiliaryEffectSlot_Impl_
+
+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 ALAuxiliaryEffectSlot_Impl_ = function(){}
+
+// Meta
+
+ALAuxiliaryEffectSlot_Impl_.__name__ = ["lime","media","openal","_ALAuxiliaryEffectSlot","ALAuxiliaryEffectSlot_Impl_"];
+ALAuxiliaryEffectSlot_Impl_.prototype = {
+	
+};
+ALAuxiliaryEffectSlot_Impl_.prototype.__class__ = $hxClasses["lime.media.openal._ALAuxiliaryEffectSlot.ALAuxiliaryEffectSlot_Impl_"] = ALAuxiliaryEffectSlot_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ALAuxiliaryEffectSlot_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+
+
+// Export
+
+exports.default = ALAuxiliaryEffectSlot_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALBuffer/ALBuffer_Impl_.js

@@ -0,0 +1,39 @@
+// Class: lime.media.openal._ALBuffer.ALBuffer_Impl_
+
+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 ALBuffer_Impl_ = function(){}
+
+// Meta
+
+ALBuffer_Impl_.__name__ = ["lime","media","openal","_ALBuffer","ALBuffer_Impl_"];
+ALBuffer_Impl_.prototype = {
+	
+};
+ALBuffer_Impl_.prototype.__class__ = $hxClasses["lime.media.openal._ALBuffer.ALBuffer_Impl_"] = ALBuffer_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ALBuffer_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+
+
+// Export
+
+exports.default = ALBuffer_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALContext/ALContext_Impl_.js

@@ -0,0 +1,39 @@
+// Class: lime.media.openal._ALContext.ALContext_Impl_
+
+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 ALContext_Impl_ = function(){}
+
+// Meta
+
+ALContext_Impl_.__name__ = ["lime","media","openal","_ALContext","ALContext_Impl_"];
+ALContext_Impl_.prototype = {
+	
+};
+ALContext_Impl_.prototype.__class__ = $hxClasses["lime.media.openal._ALContext.ALContext_Impl_"] = ALContext_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ALContext_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+
+
+// Export
+
+exports.default = ALContext_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALDevice/ALDevice_Impl_.js

@@ -0,0 +1,39 @@
+// Class: lime.media.openal._ALDevice.ALDevice_Impl_
+
+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 ALDevice_Impl_ = function(){}
+
+// Meta
+
+ALDevice_Impl_.__name__ = ["lime","media","openal","_ALDevice","ALDevice_Impl_"];
+ALDevice_Impl_.prototype = {
+	
+};
+ALDevice_Impl_.prototype.__class__ = $hxClasses["lime.media.openal._ALDevice.ALDevice_Impl_"] = ALDevice_Impl_;
+
+// Init
+
+
+
+// Statics
+
+ALDevice_Impl_._new = function(handle) {
+	var this1 = handle;
+	return this1;
+}
+
+
+// Export
+
+exports.default = ALDevice_Impl_;