First commit

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;