First commit

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

@@ -0,0 +1,127 @@
+// Class: EReg
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function js__$Boot_HaxeError() {return require("./js/_Boot/HaxeError");}
+function HxOverrides() {return require("./HxOverrides");}
+function StringBuf() {return require("./StringBuf");}
+
+// Constructor
+
+var EReg = function(r,opt) {
+	this.r = new RegExp(r,opt.split("u").join(""));
+}
+
+// Meta
+
+EReg.__name__ = ["EReg"];
+EReg.prototype = {
+	match: function(s) {
+		if(this.r.global) {
+			this.r.lastIndex = 0;
+		}
+		this.r.m = this.r.exec(s);
+		this.r.s = s;
+		return this.r.m != null;
+	},
+	matched: function(n) {
+		if(this.r.m != null && n >= 0 && n < this.r.m.length) {
+			return this.r.m[n];
+		} else {
+			throw new (js__$Boot_HaxeError().default)("EReg::matched");
+		}
+	},
+	matchedRight: function() {
+		if(this.r.m == null) {
+			throw new (js__$Boot_HaxeError().default)("No string matched");
+		}
+		var sz = this.r.m.index + this.r.m[0].length;
+		return (HxOverrides().default).substr(this.r.s,sz,this.r.s.length - sz);
+	},
+	matchedPos: function() {
+		if(this.r.m == null) {
+			throw new (js__$Boot_HaxeError().default)("No string matched");
+		}
+		return { pos : this.r.m.index, len : this.r.m[0].length};
+	},
+	matchSub: function(s,pos,len) {
+		if(len == null) {
+			len = -1;
+		}
+		if(this.r.global) {
+			this.r.lastIndex = pos;
+			var tmp = this.r;
+			var tmp1 = len < 0 ? s : (HxOverrides().default).substr(s,0,pos + len);
+			this.r.m = tmp.exec(tmp1);
+			var b = this.r.m != null;
+			if(b) {
+				this.r.s = s;
+			}
+			return b;
+		} else {
+			var b1 = this.match(len < 0 ? (HxOverrides().default).substr(s,pos,null) : (HxOverrides().default).substr(s,pos,len));
+			if(b1) {
+				this.r.s = s;
+				this.r.m.index += pos;
+			}
+			return b1;
+		}
+	},
+	split: function(s) {
+		var d = "#__delim__#";
+		return s.replace(this.r,d).split(d);
+	},
+	replace: function(s,by) {
+		return s.replace(this.r,by);
+	},
+	map: function(s,f) {
+		var offset = 0;
+		var buf = new (StringBuf().default)();
+		while(true) {
+			if(offset >= s.length) {
+				break;
+			} else if(!this.matchSub(s,offset)) {
+				buf.add((HxOverrides().default).substr(s,offset,null));
+				break;
+			}
+			var p = this.matchedPos();
+			buf.add((HxOverrides().default).substr(s,offset,p.pos - offset));
+			buf.add(f(this));
+			if(p.len == 0) {
+				buf.add((HxOverrides().default).substr(s,p.pos,1));
+				offset = p.pos + 1;
+			} else {
+				offset = p.pos + p.len;
+			}
+			if(!this.r.global) {
+				break;
+			}
+		}
+		if(!this.r.global && offset > 0 && offset < s.length) {
+			buf.add((HxOverrides().default).substr(s,offset,null));
+		}
+		return buf.toString();
+	}
+};
+EReg.prototype.__class__ = $hxClasses["EReg"] = EReg;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = EReg;

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

@@ -0,0 +1,95 @@
+// Class: HxOverrides
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function js__$Boot_HaxeError() {return require("./js/_Boot/HaxeError");}
+function js_Lib() {return require("./js/Lib");}
+
+// Constructor
+
+var HxOverrides = function(){}
+
+// Meta
+
+HxOverrides.__name__ = ["HxOverrides"];
+HxOverrides.prototype = {
+	
+};
+HxOverrides.prototype.__class__ = $hxClasses["HxOverrides"] = HxOverrides;
+
+// Init
+
+
+
+// Statics
+
+HxOverrides.strDate = function(s) {
+	var _g = s.length;
+	switch(_g) {
+	case 8:
+		var k = s.split(":");
+		var d = new Date();
+		d["setTime"](0);
+		d["setUTCHours"](k[0]);
+		d["setUTCMinutes"](k[1]);
+		d["setUTCSeconds"](k[2]);
+		return d;
+	case 10:
+		var k1 = s.split("-");
+		return new Date(k1[0],k1[1] - 1,k1[2],0,0,0);
+	case 19:
+		var k2 = s.split(" ");
+		var y = k2[0].split("-");
+		var t = k2[1].split(":");
+		return new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
+	default:
+		throw new (js__$Boot_HaxeError().default)("Invalid date format : " + s);
+	}
+}
+HxOverrides.cca = function(s,index) {
+	var x = s.charCodeAt(index);
+	if(x != x) {
+		return (js_Lib().default).get_undefined();
+	}
+	return x;
+}
+HxOverrides.substr = function(s,pos,len) {
+	if(len == null) {
+		len = s.length;
+	} else if(len < 0) {
+		if(pos == 0) {
+			len = s.length + len;
+		} else {
+			return "";
+		}
+	}
+	return s.substr(pos,len);
+}
+HxOverrides.remove = function(a,obj) {
+	var i = a.indexOf(obj);
+	if(i == -1) {
+		return false;
+	}
+	a.splice(i,1);
+	return true;
+}
+HxOverrides.iter = function(a) {
+	return { cur : 0, arr : a, hasNext : function() {
+		return this.cur < this.arr.length;
+	}, next : function() {
+		return this.arr[this.cur++];
+	}};
+}
+
+
+// Export
+
+exports.default = HxOverrides;

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

@@ -0,0 +1,45 @@
+// Class: Lambda
+
+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 $iterator = require("./iterator_stub").default;
+
+// Constructor
+
+var Lambda = function(){}
+
+// Meta
+
+Lambda.__name__ = ["Lambda"];
+Lambda.prototype = {
+	
+};
+Lambda.prototype.__class__ = $hxClasses["Lambda"] = Lambda;
+
+// Init
+
+
+
+// Statics
+
+Lambda.array = function(it) {
+	var a = [];
+	var i = $iterator(it)();
+	while(i.hasNext()) {
+		var i1 = i.next();
+		a.push(i1);
+	}
+	return a;
+}
+
+
+// Export
+
+exports.default = Lambda;

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

@@ -0,0 +1,91 @@
+// Class: List
+
+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 _$List_ListNode() {return require("./_List/ListNode");}
+function _$List_ListIterator() {return require("./_List/ListIterator");}
+
+// Constructor
+
+var List = function() {
+	this.length = 0;
+}
+
+// Meta
+
+List.__name__ = ["List"];
+List.prototype = {
+	add: function(item) {
+		var x = new (_$List_ListNode().default)(item,null);
+		if(this.h == null) {
+			this.h = x;
+		} else {
+			this.q.next = x;
+		}
+		this.q = x;
+		this.length++;
+	},
+	pop: function() {
+		if(this.h == null) {
+			return null;
+		}
+		var x = this.h.item;
+		this.h = this.h.next;
+		if(this.h == null) {
+			this.q = null;
+		}
+		this.length--;
+		return x;
+	},
+	clear: function() {
+		this.h = null;
+		this.q = null;
+		this.length = 0;
+	},
+	remove: function(v) {
+		var prev = null;
+		var l = this.h;
+		while(l != null) {
+			if(l.item == v) {
+				if(prev == null) {
+					this.h = l.next;
+				} else {
+					prev.next = l.next;
+				}
+				if(this.q == l) {
+					this.q = prev;
+				}
+				this.length--;
+				return true;
+			}
+			prev = l;
+			l = l.next;
+		}
+		return false;
+	},
+	iterator: function() {
+		return new (_$List_ListIterator().default)(this.h);
+	}
+};
+List.prototype.__class__ = $hxClasses["List"] = List;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = List;

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

@@ -0,0 +1,114 @@
+// Class: Reflect
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function js_Boot() {return require("./js/Boot");}
+
+// Constructor
+
+var Reflect = function(){}
+
+// Meta
+
+Reflect.__name__ = ["Reflect"];
+Reflect.prototype = {
+	
+};
+Reflect.prototype.__class__ = $hxClasses["Reflect"] = Reflect;
+
+// Init
+
+
+
+// Statics
+
+Reflect.hasField = function(o,field) {
+	return Object.prototype.hasOwnProperty.call(o,field);
+}
+Reflect.field = function(o,field) {
+	try {
+		return o[field];
+	} catch( e ) {
+		return null;
+	}
+}
+Reflect.setField = function(o,field,value) {
+	o[field] = value;
+}
+Reflect.callMethod = function(o,func,args) {
+	return func.apply(o,args);
+}
+Reflect.fields = function(o) {
+	var a = [];
+	if(o != null) {
+		var hasOwnProperty = Object.prototype.hasOwnProperty;
+		for( var f in o ) {
+		if(f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o,f)) {
+			a.push(f);
+		}
+		}
+	}
+	return a;
+}
+Reflect.isFunction = function(f) {
+	if(typeof(f) == "function") {
+		return !((js_Boot().default).isClass(f) || (js_Boot().default).isEnum(f));
+	} else {
+		return false;
+	}
+}
+Reflect.compare = function(a,b) {
+	if(a == b) {
+		return 0;
+	} else if(a > b) {
+		return 1;
+	} else {
+		return -1;
+	}
+}
+Reflect.compareMethods = function(f1,f2) {
+	if(f1 == f2) {
+		return true;
+	}
+	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) {
+		return false;
+	}
+	if(f1.scope == f2.scope && f1.method == f2.method) {
+		return f1.method != null;
+	} else {
+		return false;
+	}
+}
+Reflect.isEnumValue = function(v) {
+	if(v != null) {
+		return v.__enum__ != null;
+	} else {
+		return false;
+	}
+}
+Reflect.deleteField = function(o,field) {
+	if(!Reflect.hasField(o,field)) {
+		return false;
+	}
+	delete(o[field]);
+	return true;
+}
+Reflect.makeVarArgs = function(f) {
+	return function() {
+		var a = Array.prototype.slice.call(arguments);
+		return f(a);
+	};
+}
+
+
+// Export
+
+exports.default = Reflect;

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

@@ -0,0 +1,75 @@
+// Class: Std
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function js_Boot() {return require("./js/Boot");}
+function HxOverrides() {return require("./HxOverrides");}
+
+// Constructor
+
+var Std = function(){}
+
+// Meta
+
+Std.__name__ = ["Std"];
+Std.prototype = {
+	
+};
+Std.prototype.__class__ = $hxClasses["Std"] = Std;
+
+// Init
+
+{
+	String.prototype.__class__ = $hxClasses["String"] = String
+	String.__name__ = ["String"];
+	$hxClasses["Array"] = Array
+	Array.__name__ = ["Array"];
+	Date.prototype.__class__ = $hxClasses["Date"] = Date;
+	Date.__name__ = ["Date"];
+	var Int = $hxClasses["Int"] = { __name__ : ["Int"]};
+	var Dynamic = $hxClasses["Dynamic"] = { __name__ : ["Dynamic"]};
+	var Float = $hxClasses["Float"] = Number;
+	Float.__name__ = ["Float"];
+	var Bool = $hxClasses["Bool"] = Boolean;
+	Bool.__ename__ = ["Bool"];
+	var Class = $hxClasses["Class"] = { __name__ : ["Class"]};
+	var Enum = { };
+};
+
+// Statics
+
+Std.is = function(v,t) {
+	return (js_Boot().default).__instanceof(v,t);
+}
+Std.string = function(s) {
+	return (js_Boot().default).__string_rec(s,"");
+}
+Std.int = function(x) {
+	return x | 0;
+}
+Std.parseInt = function(x) {
+	var v = parseInt(x,10);
+	if(v == 0 && ((HxOverrides().default).cca(x,1) == 120 || (HxOverrides().default).cca(x,1) == 88)) {
+		v = parseInt(x);
+	}
+	if(isNaN(v)) {
+		return null;
+	}
+	return v;
+}
+Std.parseFloat = function(x) {
+	return parseFloat(x);
+}
+
+
+// Export
+
+exports.default = Std;

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

@@ -0,0 +1,48 @@
+// Class: StringBuf
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function Std() {return require("./Std");}
+
+// Constructor
+
+var StringBuf = function() {
+	this.b = "";
+}
+
+// Meta
+
+StringBuf.__name__ = ["StringBuf"];
+StringBuf.prototype = {
+	add: function(x) {
+		this.b += (Std().default).string(x);
+	},
+	addChar: function(c) {
+		this.b += String.fromCharCode(c);
+	},
+	toString: function() {
+		return this.b;
+	}
+};
+StringBuf.prototype.__class__ = $hxClasses["StringBuf"] = StringBuf;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = StringBuf;

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

@@ -0,0 +1,122 @@
+// Class: StringTools
+
+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 HxOverrides() {return require("./HxOverrides");}
+
+// Constructor
+
+var StringTools = function(){}
+
+// Meta
+
+StringTools.__name__ = ["StringTools"];
+StringTools.prototype = {
+	
+};
+StringTools.prototype.__class__ = $hxClasses["StringTools"] = StringTools;
+
+// Init
+
+
+
+// Statics
+
+StringTools.urlEncode = function(s) {
+	return encodeURIComponent(s);
+}
+StringTools.urlDecode = function(s) {
+	return decodeURIComponent(s.split("+").join(" "));
+}
+StringTools.htmlEscape = function(s,quotes) {
+	s = s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
+	if(quotes) {
+		return s.split("\"").join("&quot;").split("'").join("&#039;");
+	} else {
+		return s;
+	}
+}
+StringTools.startsWith = function(s,start) {
+	if(s.length >= start.length) {
+		return (HxOverrides().default).substr(s,0,start.length) == start;
+	} else {
+		return false;
+	}
+}
+StringTools.endsWith = function(s,end) {
+	var elen = end.length;
+	var slen = s.length;
+	if(slen >= elen) {
+		return (HxOverrides().default).substr(s,slen - elen,elen) == end;
+	} else {
+		return false;
+	}
+}
+StringTools.isSpace = function(s,pos) {
+	var c = (HxOverrides().default).cca(s,pos);
+	if(!(c > 8 && c < 14)) {
+		return c == 32;
+	} else {
+		return true;
+	}
+}
+StringTools.ltrim = function(s) {
+	var l = s.length;
+	var r = 0;
+	while(r < l && StringTools.isSpace(s,r)) ++r;
+	if(r > 0) {
+		return (HxOverrides().default).substr(s,r,l - r);
+	} else {
+		return s;
+	}
+}
+StringTools.rtrim = function(s) {
+	var l = s.length;
+	var r = 0;
+	while(r < l && StringTools.isSpace(s,l - r - 1)) ++r;
+	if(r > 0) {
+		return (HxOverrides().default).substr(s,0,l - r);
+	} else {
+		return s;
+	}
+}
+StringTools.trim = function(s) {
+	return StringTools.ltrim(StringTools.rtrim(s));
+}
+StringTools.replace = function(s,sub,by) {
+	return s.split(sub).join(by);
+}
+StringTools.hex = function(n,digits) {
+	var s = "";
+	var hexChars = "0123456789ABCDEF";
+	while(true) {
+		s = hexChars.charAt(n & 15) + s;
+		n >>>= 4;
+		if(!(n > 0)) {
+			break;
+		}
+	}
+	if(digits != null) {
+		while(s.length < digits) s = "0" + s;
+	}
+	return s;
+}
+StringTools.fastCodeAt = function(s,index) {
+	return s.charCodeAt(index);
+}
+StringTools.isEof = function(c) {
+	return c != c;
+}
+
+
+// Export
+
+exports.default = StringTools;

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

@@ -0,0 +1,177 @@
+// Class: Type
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./hxClasses_stub").default;
+var $import = require("./import_stub").default;
+function js_Boot() {return require("./js/Boot");}
+function js__$Boot_HaxeError() {return require("./js/_Boot/HaxeError");}
+function Reflect() {return require("./Reflect");}
+function ValueType() {return require("./ValueType");}
+
+// Constructor
+
+var Type = function(){}
+
+// Meta
+
+Type.__name__ = ["Type"];
+Type.prototype = {
+	
+};
+Type.prototype.__class__ = $hxClasses["Type"] = Type;
+
+// Init
+
+
+
+// Statics
+
+Type.getClass = function(o) {
+	if(o == null) {
+		return null;
+	} else {
+		return (js_Boot().default).getClass(o);
+	}
+}
+Type.getSuperClass = function(c) {
+	return c.__super__;
+}
+Type.getClassName = function(c) {
+	var a = c.__name__;
+	if(a == null) {
+		return null;
+	}
+	return a.join(".");
+}
+Type.getEnumName = function(e) {
+	var a = e.__ename__;
+	return a.join(".");
+}
+Type.resolveClass = function(name) {
+	var cl = $hxClasses[name];
+	if(cl == null || !(js_Boot().default).isClass(cl)) {
+		return null;
+	}
+	return cl;
+}
+Type.resolveEnum = function(name) {
+	var e = $hxClasses[name];
+	if(e == null || !(js_Boot().default).isEnum(e)) {
+		return null;
+	}
+	return e;
+}
+Type.createInstance = function(cl,args) {
+	var _g = args.length;
+	switch(_g) {
+	case 0:
+		return new cl();
+	case 1:
+		return new cl(args[0]);
+	case 2:
+		return new cl(args[0],args[1]);
+	case 3:
+		return new cl(args[0],args[1],args[2]);
+	case 4:
+		return new cl(args[0],args[1],args[2],args[3]);
+	case 5:
+		return new cl(args[0],args[1],args[2],args[3],args[4]);
+	case 6:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5]);
+	case 7:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
+	case 8:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
+	case 9:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
+	case 10:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
+	case 11:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
+	case 12:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
+	case 13:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
+	case 14:
+		return new cl(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
+	default:
+		throw new (js__$Boot_HaxeError().default)("Too many arguments");
+	}
+}
+Type.createEmptyInstance = function(cl) {
+	function empty() {}; empty.prototype = cl.prototype;
+	return new empty();
+}
+Type.createEnum = function(e,constr,params) {
+	var f = (Reflect().default).field(e,constr);
+	if(f == null) {
+		throw new (js__$Boot_HaxeError().default)("No such constructor " + constr);
+	}
+	if((Reflect().default).isFunction(f)) {
+		if(params == null) {
+			throw new (js__$Boot_HaxeError().default)("Constructor " + constr + " need parameters");
+		}
+		return (Reflect().default).callMethod(e,f,params);
+	}
+	if(params != null && params.length != 0) {
+		throw new (js__$Boot_HaxeError().default)("Constructor " + constr + " does not need parameters");
+	}
+	return f;
+}
+Type.getEnumConstructs = function(e) {
+	return e.__constructs__.slice();
+}
+Type.typeof = function(v) {
+	var _g = typeof(v);
+	switch(_g) {
+	case "boolean":
+		return (ValueType().default).TBool;
+	case "function":
+		if((js_Boot().default).isClass(v) || (js_Boot().default).isEnum(v)) {
+			return (ValueType().default).TObject;
+		}
+		return (ValueType().default).TFunction;
+	case "number":
+		if(Math.ceil(v) == v % 2147483648.0) {
+			return (ValueType().default).TInt;
+		}
+		return (ValueType().default).TFloat;
+	case "object":
+		if(v == null) {
+			return (ValueType().default).TNull;
+		}
+		var e = v.__enum__;
+		if(e != null) {
+			return (ValueType().default).TEnum(e);
+		}
+		var c = (js_Boot().default).getClass(v);
+		if(c != null) {
+			return (ValueType().default).TClass(c);
+		}
+		return (ValueType().default).TObject;
+	case "string":
+		return (ValueType().default).TClass(String);
+	case "undefined":
+		return (ValueType().default).TNull;
+	default:
+		return (ValueType().default).TUnknown;
+	}
+}
+Type.enumParameters = function(e) {
+	return e.slice(2);
+}
+Type.enumIndex = function(e) {
+	return e[1];
+}
+
+
+// Export
+
+exports.default = Type;

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

@@ -0,0 +1,47 @@
+// Enum: ValueType
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./estr_stub").default;
+var $hxClasses = require("./hxClasses_stub").default;
+
+// Definition
+
+var ValueType = $hxClasses["ValueType"] = { __ename__: ["ValueType"], __constructs__: ["TNull","TInt","TFloat","TBool","TObject","TFunction","TClass","TEnum","TUnknown"] }
+
+ValueType.TClass = function(c) { var $x = ["TClass",6,c]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
+ValueType.TNull = ["TNull",0];
+ValueType.TNull.toString = $estr;
+ValueType.TNull.__enum__ = ValueType;
+
+ValueType.TObject = ["TObject",4];
+ValueType.TObject.toString = $estr;
+ValueType.TObject.__enum__ = ValueType;
+
+ValueType.TFunction = ["TFunction",5];
+ValueType.TFunction.toString = $estr;
+ValueType.TFunction.__enum__ = ValueType;
+
+ValueType.TInt = ["TInt",1];
+ValueType.TInt.toString = $estr;
+ValueType.TInt.__enum__ = ValueType;
+
+ValueType.TUnknown = ["TUnknown",8];
+ValueType.TUnknown.toString = $estr;
+ValueType.TUnknown.__enum__ = ValueType;
+
+ValueType.TEnum = function(e) { var $x = ["TEnum",7,e]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; }
+ValueType.TFloat = ["TFloat",2];
+ValueType.TFloat.toString = $estr;
+ValueType.TFloat.__enum__ = ValueType;
+
+ValueType.TBool = ["TBool",3];
+ValueType.TBool.toString = $estr;
+ValueType.TBool.__enum__ = ValueType;
+
+
+exports.default = ValueType;

hGameTest/node_modules/openfl/lib/_gen/_List/ListIterator.js

@@ -0,0 +1,45 @@
+// Class: _List.ListIterator
+
+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 ListIterator = function(head) {
+	this.head = head;
+}
+
+// Meta
+
+ListIterator.__name__ = ["_List","ListIterator"];
+ListIterator.prototype = {
+	hasNext: function() {
+		return this.head != null;
+	},
+	next: function() {
+		var val = this.head.item;
+		this.head = this.head.next;
+		return val;
+	}
+};
+ListIterator.prototype.__class__ = $hxClasses["_List.ListIterator"] = ListIterator;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ListIterator;

hGameTest/node_modules/openfl/lib/_gen/_List/ListNode.js

@@ -0,0 +1,39 @@
+// Class: _List.ListNode
+
+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 ListNode = function(item,next) {
+	this.item = item;
+	this.next = next;
+}
+
+// Meta
+
+ListNode.__name__ = ["_List","ListNode"];
+ListNode.prototype = {
+	
+};
+ListNode.prototype.__class__ = $hxClasses["_List.ListNode"] = ListNode;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ListNode;

hGameTest/node_modules/openfl/lib/_gen/_UInt/UInt_Impl_.js

@@ -0,0 +1,52 @@
+// Class: _UInt.UInt_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+
+// Constructor
+
+var UInt_Impl_ = function(){}
+
+// Meta
+
+UInt_Impl_.__name__ = ["_UInt","UInt_Impl_"];
+UInt_Impl_.prototype = {
+	
+};
+UInt_Impl_.prototype.__class__ = $hxClasses["_UInt.UInt_Impl_"] = UInt_Impl_;
+
+// Init
+
+
+
+// Statics
+
+UInt_Impl_.gt = function(a,b) {
+	var aNeg = a < 0;
+	var bNeg = b < 0;
+	if(aNeg != bNeg) {
+		return aNeg;
+	} else {
+		return a > b;
+	}
+}
+UInt_Impl_.toFloat = function(this1) {
+	var $int = this1;
+	if($int < 0) {
+		return 4294967296.0 + $int;
+	} else {
+		return $int + 0.0;
+	}
+}
+
+
+// Export
+
+exports.default = UInt_Impl_;

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

@@ -0,0 +1,30 @@
+// Haxe uses its own caching bind method.  It's faster, but less standard than Function.bind.
+// This version is slightly modified for compressability, modularization and readability.
+// https://github.com/HaxeFoundation/haxe/issues/1349
+// http://stackoverflow.com/a/17638540/1732990
+
+Object.defineProperty(exports, "__esModule", {value: true});
+
+var $fid = 0;
+
+exports.default = function $bind(obj, method) {
+    var func, mId;
+
+    if( method == null ) { return null; }
+    mId = method._i = method._i || $fid++;
+
+    if( obj._c == null ) {
+        obj._c = {};
+    } else {
+        func = obj._c[mId];
+    }
+    if( func == null ) {
+        func = function(){
+            return func._m.apply(func._s, arguments);
+        };
+        func._s = obj;
+        func._m = method;
+        obj._c[mId] = func;
+    }
+    return func;
+};

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

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, "__esModule", {value: true});
+
+var js_Boot = require('./js/Boot');
+
+exports.default = function $estr() {
+	return js_Boot["__string_rec"](this, '');
+}

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

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, "__esModule", {value: true});
+
+exports.default = function $extend(from, fields) {
+    function Inherit() {};
+    Inherit.prototype = from;
+    var proto = new Inherit();
+    for (var name in fields) proto[name] = fields[name];
+    if(fields.toString !== Object.prototype.toString) proto.toString = fields.toString;
+    return proto;
+};

hGameTest/node_modules/openfl/lib/_gen/haxe/CallStack.js

@@ -0,0 +1,168 @@
+// Class: haxe.CallStack
+
+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 HxOverrides() {return require("./../HxOverrides");}
+function haxe_StackItem() {return require("./../haxe/StackItem");}
+function js__$Boot_HaxeError() {return require("./../js/_Boot/HaxeError");}
+function StringBuf() {return require("./../StringBuf");}
+function Type() {return require("./../Type");}
+function EReg() {return require("./../EReg");}
+function Std() {return require("./../Std");}
+function StringTools() {return require("./../StringTools");}
+
+// Constructor
+
+var CallStack = function(){}
+
+// Meta
+
+CallStack.__name__ = ["haxe","CallStack"];
+CallStack.prototype = {
+	
+};
+CallStack.prototype.__class__ = $hxClasses["haxe.CallStack"] = CallStack;
+
+// Init
+
+
+
+// Statics
+
+CallStack.getStack = function(e) {
+	if(e == null) {
+		return [];
+	}
+	var oldValue = Error.prepareStackTrace;
+	Error.prepareStackTrace = function(error,callsites) {
+		var stack = [];
+		var _g = 0;
+		while(_g < callsites.length) {
+			var site = callsites[_g];
+			++_g;
+			if(CallStack.wrapCallSite != null) {
+				site = CallStack.wrapCallSite(site);
+			}
+			var method = null;
+			var fullName = site.getFunctionName();
+			if(fullName != null) {
+				var idx = fullName.lastIndexOf(".");
+				if(idx >= 0) {
+					var className = (HxOverrides().default).substr(fullName,0,idx);
+					var methodName = (HxOverrides().default).substr(fullName,idx + 1,null);
+					method = (haxe_StackItem().default).Method(className,methodName);
+				}
+			}
+			stack.push((haxe_StackItem().default).FilePos(method,site.getFileName(),site.getLineNumber()));
+		}
+		return stack;
+	};
+	var a = CallStack.makeStack(e.stack);
+	Error.prepareStackTrace = oldValue;
+	return a;
+}
+CallStack.callStack = function() {
+	try {
+		throw new Error();
+	} catch( e ) {
+		if (e instanceof (js__$Boot_HaxeError().default)) e = e.val;
+		var a = CallStack.getStack(e);
+		a.shift();
+		return a;
+	}
+}
+CallStack.exceptionStack = function() {
+	return CallStack.getStack(CallStack.lastException);
+}
+CallStack.toString = function(stack) {
+	var b = new (StringBuf().default)();
+	var _g = 0;
+	while(_g < stack.length) {
+		var s = stack[_g];
+		++_g;
+		b.add("\nCalled from ");
+		CallStack.itemToString(b,s);
+	}
+	return b.toString();
+}
+CallStack.itemToString = function(b,s) {
+	switch((Type().default).enumIndex(s)) {
+	case 0:
+		b.add("a C function");
+		break;
+	case 1:
+		var m = s[2];
+		b.add("module ");
+		b.add(m);
+		break;
+	case 2:
+		var line = s[4];
+		var file = s[3];
+		var s1 = s[2];
+		if(s1 != null) {
+			CallStack.itemToString(b,s1);
+			b.add(" (");
+		}
+		b.add(file);
+		b.add(" line ");
+		b.add(line);
+		if(s1 != null) {
+			b.add(")");
+		}
+		break;
+	case 3:
+		var meth = s[3];
+		var cname = s[2];
+		b.add(cname);
+		b.add(".");
+		b.add(meth);
+		break;
+	case 4:
+		var n = s[2];
+		b.add("local function #");
+		b.add(n);
+		break;
+	}
+}
+CallStack.makeStack = function(s) {
+	if(s == null) {
+		return [];
+	} else if(typeof(s) == "string") {
+		var stack = s.split("\n");
+		if(stack[0] == "Error") {
+			stack.shift();
+		}
+		var m = [];
+		var rie10 = new (EReg().default)("^   at ([A-Za-z0-9_. ]+) \\(([^)]+):([0-9]+):([0-9]+)\\)$","");
+		var _g = 0;
+		while(_g < stack.length) {
+			var line = stack[_g];
+			++_g;
+			if(rie10.match(line)) {
+				var path = rie10.matched(1).split(".");
+				var meth = path.pop();
+				var file = rie10.matched(2);
+				var line1 = (Std().default).parseInt(rie10.matched(3));
+				m.push((haxe_StackItem().default).FilePos(meth == "Anonymous function" ? (haxe_StackItem().default).LocalFunction() : meth == "Global code" ? null : (haxe_StackItem().default).Method(path.join("."),meth),file,line1));
+			} else {
+				m.push((haxe_StackItem().default).Module((StringTools().default).trim(line)));
+			}
+		}
+		return m;
+	} else {
+		return s;
+	}
+}
+
+
+// Export
+
+exports.default = CallStack;

hGameTest/node_modules/openfl/lib/_gen/haxe/IMap.js

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

hGameTest/node_modules/openfl/lib/_gen/haxe/Log.js

@@ -0,0 +1,40 @@
+// Class: haxe.Log
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function js_Boot() {return require("./../js/Boot");}
+
+// Constructor
+
+var Log = function(){}
+
+// Meta
+
+Log.__name__ = ["haxe","Log"];
+Log.prototype = {
+	
+};
+Log.prototype.__class__ = $hxClasses["haxe.Log"] = Log;
+
+// Init
+
+
+
+// Statics
+
+Log.trace = function(v,infos) {
+	(js_Boot().default).__trace(v,infos);
+}
+
+
+// Export
+
+exports.default = Log;

hGameTest/node_modules/openfl/lib/_gen/haxe/Serializer.js

@@ -0,0 +1,345 @@
+// Class: haxe.Serializer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function StringTools() {return require("./../StringTools");}
+function Reflect() {return require("./../Reflect");}
+function Type() {return require("./../Type");}
+function Std() {return require("./../Std");}
+function js__$Boot_HaxeError() {return require("./../js/_Boot/HaxeError");}
+function List() {return require("./../List");}
+function haxe_ds_IntMap() {return require("./../haxe/ds/IntMap");}
+function haxe_ds_ObjectMap() {return require("./../haxe/ds/ObjectMap");}
+function haxe_ds_StringMap() {return require("./../haxe/ds/StringMap");}
+function haxe_io_Bytes() {return require("./../haxe/io/Bytes");}
+function HxOverrides() {return require("./../HxOverrides");}
+function StringBuf() {return require("./../StringBuf");}
+
+// Constructor
+
+var Serializer = function() {
+	this.buf = new (StringBuf().default)();
+	this.cache = [];
+	this.useCache = Serializer.USE_CACHE;
+	this.useEnumIndex = Serializer.USE_ENUM_INDEX;
+	this.shash = new (haxe_ds_StringMap().default)();
+	this.scount = 0;
+}
+
+// Meta
+
+Serializer.__name__ = ["haxe","Serializer"];
+Serializer.prototype = {
+	toString: function() {
+		return this.buf.toString();
+	},
+	serializeString: function(s) {
+		var x = this.shash.get(s);
+		if(x != null) {
+			this.buf.add("R");
+			this.buf.add(x);
+			return;
+		}
+		this.shash.set(s,this.scount++);
+		this.buf.add("y");
+		s = (StringTools().default).urlEncode(s);
+		this.buf.add(s.length);
+		this.buf.add(":");
+		this.buf.add(s);
+	},
+	serializeRef: function(v) {
+		var vt = typeof(v);
+		var _g1 = 0;
+		var _g = this.cache.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			var ci = this.cache[i];
+			if(typeof(ci) == vt && ci == v) {
+				this.buf.add("r");
+				this.buf.add(i);
+				return true;
+			}
+		}
+		this.cache.push(v);
+		return false;
+	},
+	serializeFields: function(v) {
+		var _g = 0;
+		var _g1 = (Reflect().default).fields(v);
+		while(_g < _g1.length) {
+			var f = _g1[_g];
+			++_g;
+			this.serializeString(f);
+			this.serialize((Reflect().default).field(v,f));
+		}
+		this.buf.add("g");
+	},
+	serialize: function(v) {
+		var _g = (Type().default)["typeof"](v);
+		switch((Type().default).enumIndex(_g)) {
+		case 0:
+			this.buf.add("n");
+			break;
+		case 1:
+			var v1 = v;
+			if(v1 == 0) {
+				this.buf.add("z");
+				return;
+			}
+			this.buf.add("i");
+			this.buf.add(v1);
+			break;
+		case 2:
+			var v2 = v;
+			if(isNaN(v2)) {
+				this.buf.add("k");
+			} else if(!isFinite(v2)) {
+				this.buf.add(v2 < 0 ? "m" : "p");
+			} else {
+				this.buf.add("d");
+				this.buf.add(v2);
+			}
+			break;
+		case 3:
+			this.buf.add(v ? "t" : "f");
+			break;
+		case 4:
+			if((Std().default)["is"](v,$hxClasses["Class"])) {
+				var className = (Type().default).getClassName(v);
+				this.buf.add("A");
+				this.serializeString(className);
+			} else if((Std().default)["is"](v,$hxClasses["Enum"])) {
+				this.buf.add("B");
+				this.serializeString((Type().default).getEnumName(v));
+			} else {
+				if(this.useCache && this.serializeRef(v)) {
+					return;
+				}
+				this.buf.add("o");
+				this.serializeFields(v);
+			}
+			break;
+		case 5:
+			throw new (js__$Boot_HaxeError().default)("Cannot serialize function");
+			break;
+		case 6:
+			var c = _g[2];
+			if(c == String) {
+				this.serializeString(v);
+				return;
+			}
+			if(this.useCache && this.serializeRef(v)) {
+				return;
+			}
+			switch(c) {
+			case Array:
+				var ucount = 0;
+				this.buf.add("a");
+				var l = v["length"];
+				var _g1 = 0;
+				var _g2 = l;
+				while(_g1 < _g2) {
+					var i = _g1++;
+					if(v[i] == null) {
+						++ucount;
+					} else {
+						if(ucount > 0) {
+							if(ucount == 1) {
+								this.buf.add("n");
+							} else {
+								this.buf.add("u");
+								this.buf.add(ucount);
+							}
+							ucount = 0;
+						}
+						this.serialize(v[i]);
+					}
+				}
+				if(ucount > 0) {
+					if(ucount == 1) {
+						this.buf.add("n");
+					} else {
+						this.buf.add("u");
+						this.buf.add(ucount);
+					}
+				}
+				this.buf.add("h");
+				break;
+			case Date:
+				var d = v;
+				this.buf.add("v");
+				this.buf.add(d.getTime());
+				break;
+			case (List().default):
+				this.buf.add("l");
+				var v3 = v;
+				var i1 = v3.iterator();
+				while(i1.hasNext()) {
+					var i2 = i1.next();
+					this.serialize(i2);
+				}
+				this.buf.add("h");
+				break;
+			case (haxe_ds_IntMap().default):
+				this.buf.add("q");
+				var v4 = v;
+				var k = v4.keys();
+				while(k.hasNext()) {
+					var k1 = k.next();
+					this.buf.add(":");
+					this.buf.add(k1);
+					this.serialize(v4.get(k1));
+				}
+				this.buf.add("h");
+				break;
+			case (haxe_ds_ObjectMap().default):
+				this.buf.add("M");
+				var v5 = v;
+				var k2 = v5.keys();
+				while(k2.hasNext()) {
+					var k3 = k2.next();
+					var id = (Reflect().default).field(k3,"__id__");
+					(Reflect().default).deleteField(k3,"__id__");
+					this.serialize(k3);
+					(Reflect().default).setField(k3,"__id__",id);
+					this.serialize(v5.get(k3));
+				}
+				this.buf.add("h");
+				break;
+			case (haxe_ds_StringMap().default):
+				this.buf.add("b");
+				var v6 = v;
+				var k4 = v6.keys();
+				while(k4.hasNext()) {
+					var k5 = k4.next();
+					this.serializeString(k5);
+					this.serialize(v6.get(k5));
+				}
+				this.buf.add("h");
+				break;
+			case (haxe_io_Bytes().default):
+				var v7 = v;
+				this.buf.add("s");
+				this.buf.add(Math.ceil(v7.get_length() * 8 / 6));
+				this.buf.add(":");
+				var i3 = 0;
+				var max = v7.get_length() - 2;
+				var b64 = Serializer.BASE64_CODES;
+				if(b64 == null) {
+					var length = Serializer.BASE64.length;
+					var this1 = new Array(length);
+					b64 = this1;
+					var _g11 = 0;
+					var _g3 = Serializer.BASE64.length;
+					while(_g11 < _g3) {
+						var i4 = _g11++;
+						b64[i4] = (HxOverrides().default).cca(Serializer.BASE64,i4);
+					}
+					Serializer.BASE64_CODES = b64;
+				}
+				while(i3 < max) {
+					var b1 = v7.get(i3++);
+					var b2 = v7.get(i3++);
+					var b3 = v7.get(i3++);
+					this.buf.addChar(b64[b1 >> 2]);
+					this.buf.addChar(b64[(b1 << 4 | b2 >> 4) & 63]);
+					this.buf.addChar(b64[(b2 << 2 | b3 >> 6) & 63]);
+					this.buf.addChar(b64[b3 & 63]);
+				}
+				if(i3 == max) {
+					var b11 = v7.get(i3++);
+					var b21 = v7.get(i3++);
+					this.buf.addChar(b64[b11 >> 2]);
+					this.buf.addChar(b64[(b11 << 4 | b21 >> 4) & 63]);
+					this.buf.addChar(b64[b21 << 2 & 63]);
+				} else if(i3 == max + 1) {
+					var b12 = v7.get(i3++);
+					this.buf.addChar(b64[b12 >> 2]);
+					this.buf.addChar(b64[b12 << 4 & 63]);
+				}
+				break;
+			default:
+				if(this.useCache) {
+					this.cache.pop();
+				}
+				if(v.hxSerialize != null) {
+					this.buf.add("C");
+					this.serializeString((Type().default).getClassName(c));
+					if(this.useCache) {
+						this.cache.push(v);
+					}
+					v.hxSerialize(this);
+					this.buf.add("g");
+				} else {
+					this.buf.add("c");
+					this.serializeString((Type().default).getClassName(c));
+					if(this.useCache) {
+						this.cache.push(v);
+					}
+					this.serializeFields(v);
+				}
+			}
+			break;
+		case 7:
+			var e = _g[2];
+			if(this.useCache) {
+				if(this.serializeRef(v)) {
+					return;
+				}
+				this.cache.pop();
+			}
+			this.buf.add(this.useEnumIndex ? "j" : "w");
+			this.serializeString((Type().default).getEnumName(e));
+			if(this.useEnumIndex) {
+				this.buf.add(":");
+				this.buf.add(v[1]);
+			} else {
+				this.serializeString(v[0]);
+			}
+			this.buf.add(":");
+			var l1 = v["length"];
+			this.buf.add(l1 - 2);
+			var _g12 = 2;
+			var _g4 = l1;
+			while(_g12 < _g4) {
+				var i5 = _g12++;
+				this.serialize(v[i5]);
+			}
+			if(this.useCache) {
+				this.cache.push(v);
+			}
+			break;
+		default:
+			throw new (js__$Boot_HaxeError().default)("Cannot serialize " + (Std().default).string(v));
+		}
+	}
+};
+Serializer.prototype.__class__ = $hxClasses["haxe.Serializer"] = Serializer;
+
+// Init
+
+
+
+// Statics
+
+Serializer.run = function(v) {
+	var s = new Serializer();
+	s.serialize(v);
+	return s.toString();
+}
+Serializer.USE_CACHE = false
+Serializer.USE_ENUM_INDEX = false
+Serializer.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789%:"
+Serializer.BASE64_CODES = null
+
+// Export
+
+exports.default = Serializer;

hGameTest/node_modules/openfl/lib/_gen/haxe/StackItem.js

@@ -0,0 +1,25 @@
+// Enum: haxe.StackItem
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../estr_stub").default;
+var $hxClasses = require("./../hxClasses_stub").default;
+
+// Definition
+
+var StackItem = $hxClasses["haxe.StackItem"] = { __ename__: ["haxe","StackItem"], __constructs__: ["CFunction","Module","FilePos","Method","LocalFunction"] }
+
+StackItem.Module = function(m) { var $x = ["Module",1,m]; $x.__enum__ = StackItem; $x.toString = $estr; return $x; }
+StackItem.Method = function(classname,method) { var $x = ["Method",3,classname,method]; $x.__enum__ = StackItem; $x.toString = $estr; return $x; }
+StackItem.LocalFunction = function(v) { var $x = ["LocalFunction",4,v]; $x.__enum__ = StackItem; $x.toString = $estr; return $x; }
+StackItem.FilePos = function(s,file,line) { var $x = ["FilePos",2,s,file,line]; $x.__enum__ = StackItem; $x.toString = $estr; return $x; }
+StackItem.CFunction = ["CFunction",0];
+StackItem.CFunction.toString = $estr;
+StackItem.CFunction.__enum__ = StackItem;
+
+
+exports.default = StackItem;

hGameTest/node_modules/openfl/lib/_gen/haxe/Timer.js

@@ -0,0 +1,68 @@
+// Class: haxe.Timer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function haxe_Log() {return require("./../haxe/Log");}
+function js_Browser() {return require("./../js/Browser");}
+
+// Constructor
+
+var Timer = function(time_ms) {
+	var me = this;
+	this.id = setInterval(function() {
+		me.run();
+	},time_ms);
+}
+
+// Meta
+
+Timer.__name__ = ["haxe","Timer"];
+Timer.prototype = {
+	stop: function() {
+		if(this.id == null) {
+			return;
+		}
+		clearInterval(this.id);
+		this.id = null;
+	},
+	run: function() {
+	}
+};
+Timer.prototype.__class__ = $hxClasses["haxe.Timer"] = Timer;
+
+// Init
+
+
+
+// Statics
+
+Timer.delay = function(f,time_ms) {
+	var t = new Timer(time_ms);
+	t.run = function() {
+		t.stop();
+		f();
+	};
+	return t;
+}
+Timer.measure = function(f,pos) {
+	var t0 = Timer.stamp();
+	var r = f();
+	(haxe_Log().default).trace(Timer.stamp() - t0 + "s",pos);
+	return r;
+}
+Timer.stamp = function() {
+	return (js_Browser().default).get_window().performance.now() / 1000;
+}
+
+
+// Export
+
+exports.default = Timer;

hGameTest/node_modules/openfl/lib/_gen/haxe/Unserializer.js

@@ -0,0 +1,383 @@
+// Class: haxe.Unserializer
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../hxClasses_stub").default;
+var $import = require("./../import_stub").default;
+function haxe__$Unserializer_NullResolver() {return require("./../haxe/_Unserializer/NullResolver");}
+function StringTools() {return require("./../StringTools");}
+function Std() {return require("./../Std");}
+function HxOverrides() {return require("./../HxOverrides");}
+function js__$Boot_HaxeError() {return require("./../js/_Boot/HaxeError");}
+function Reflect() {return require("./../Reflect");}
+function Type() {return require("./../Type");}
+function haxe_ds_ObjectMap() {return require("./../haxe/ds/ObjectMap");}
+function haxe_ds_StringMap() {return require("./../haxe/ds/StringMap");}
+function List() {return require("./../List");}
+function haxe_ds_IntMap() {return require("./../haxe/ds/IntMap");}
+function haxe_io_Bytes() {return require("./../haxe/io/Bytes");}
+function haxe__$Unserializer_DefaultResolver() {return require("./../haxe/_Unserializer/DefaultResolver");}
+
+// Constructor
+
+var Unserializer = function(buf) {
+	this.buf = buf;
+	this.length = buf.length;
+	this.pos = 0;
+	this.scache = [];
+	this.cache = [];
+	var r = Unserializer.DEFAULT_RESOLVER;
+	if(r == null) {
+		r = new (haxe__$Unserializer_DefaultResolver().default)();
+		Unserializer.DEFAULT_RESOLVER = r;
+	}
+	this.resolver = r;
+}
+
+// Meta
+
+Unserializer.__name__ = ["haxe","Unserializer"];
+Unserializer.prototype = {
+	setResolver: function(r) {
+		if(r == null) {
+			this.resolver = (haxe__$Unserializer_NullResolver().default).get_instance();
+		} else {
+			this.resolver = r;
+		}
+	},
+	get: function(p) {
+		return (StringTools().default).fastCodeAt(this.buf,p);
+	},
+	readDigits: function() {
+		var k = 0;
+		var s = false;
+		var fpos = this.pos;
+		while(true) {
+			var c = this.get(this.pos);
+			if((StringTools().default).isEof(c)) {
+				break;
+			}
+			if(c == 45) {
+				if(this.pos != fpos) {
+					break;
+				}
+				s = true;
+				this.pos++;
+				continue;
+			}
+			if(c < 48 || c > 57) {
+				break;
+			}
+			k = k * 10 + (c - 48);
+			this.pos++;
+		}
+		if(s) {
+			k *= -1;
+		}
+		return k;
+	},
+	readFloat: function() {
+		var p1 = this.pos;
+		while(true) {
+			var c = this.get(this.pos);
+			if((StringTools().default).isEof(c)) {
+				break;
+			}
+			if(c >= 43 && c < 58 || c == 101 || c == 69) {
+				this.pos++;
+			} else {
+				break;
+			}
+		}
+		return (Std().default).parseFloat((HxOverrides().default).substr(this.buf,p1,this.pos - p1));
+	},
+	unserializeObject: function(o) {
+		while(true) {
+			if(this.pos >= this.length) {
+				throw new (js__$Boot_HaxeError().default)("Invalid object");
+			}
+			if(this.get(this.pos) == 103) {
+				break;
+			}
+			var k = this.unserialize();
+			if(typeof(k) != "string") {
+				throw new (js__$Boot_HaxeError().default)("Invalid object key");
+			}
+			var v = this.unserialize();
+			(Reflect().default).setField(o,k,v);
+		}
+		this.pos++;
+	},
+	unserializeEnum: function(edecl,tag) {
+		if(this.get(this.pos++) != 58) {
+			throw new (js__$Boot_HaxeError().default)("Invalid enum format");
+		}
+		var nargs = this.readDigits();
+		if(nargs == 0) {
+			return (Type().default).createEnum(edecl,tag);
+		}
+		var args = [];
+		while(nargs-- > 0) args.push(this.unserialize());
+		return (Type().default).createEnum(edecl,tag,args);
+	},
+	unserialize: function() {
+		var _g = this.get(this.pos++);
+		switch(_g) {
+		case 65:
+			var name = this.unserialize();
+			var cl = this.resolver.resolveClass(name);
+			if(cl == null) {
+				throw new (js__$Boot_HaxeError().default)("Class not found " + name);
+			}
+			return cl;
+		case 66:
+			var name1 = this.unserialize();
+			var e = this.resolver.resolveEnum(name1);
+			if(e == null) {
+				throw new (js__$Boot_HaxeError().default)("Enum not found " + name1);
+			}
+			return e;
+		case 67:
+			var name2 = this.unserialize();
+			var cl1 = this.resolver.resolveClass(name2);
+			if(cl1 == null) {
+				throw new (js__$Boot_HaxeError().default)("Class not found " + name2);
+			}
+			var o = (Type().default).createEmptyInstance(cl1);
+			this.cache.push(o);
+			o.hxUnserialize(this);
+			if(this.get(this.pos++) != 103) {
+				throw new (js__$Boot_HaxeError().default)("Invalid custom data");
+			}
+			return o;
+		case 77:
+			var h = new (haxe_ds_ObjectMap().default)();
+			this.cache.push(h);
+			var buf = this.buf;
+			while(this.get(this.pos) != 104) {
+				var s = this.unserialize();
+				h.set(s,this.unserialize());
+			}
+			this.pos++;
+			return h;
+		case 82:
+			var n = this.readDigits();
+			if(n < 0 || n >= this.scache.length) {
+				throw new (js__$Boot_HaxeError().default)("Invalid string reference");
+			}
+			return this.scache[n];
+		case 97:
+			var buf1 = this.buf;
+			var a = [];
+			this.cache.push(a);
+			while(true) {
+				var c = this.get(this.pos);
+				if(c == 104) {
+					this.pos++;
+					break;
+				}
+				if(c == 117) {
+					this.pos++;
+					var n1 = this.readDigits();
+					a[a.length + n1 - 1] = null;
+				} else {
+					a.push(this.unserialize());
+				}
+			}
+			return a;
+		case 98:
+			var h1 = new (haxe_ds_StringMap().default)();
+			this.cache.push(h1);
+			var buf2 = this.buf;
+			while(this.get(this.pos) != 104) {
+				var s1 = this.unserialize();
+				h1.set(s1,this.unserialize());
+			}
+			this.pos++;
+			return h1;
+		case 99:
+			var name3 = this.unserialize();
+			var cl2 = this.resolver.resolveClass(name3);
+			if(cl2 == null) {
+				throw new (js__$Boot_HaxeError().default)("Class not found " + name3);
+			}
+			var o1 = (Type().default).createEmptyInstance(cl2);
+			this.cache.push(o1);
+			this.unserializeObject(o1);
+			return o1;
+		case 100:
+			return this.readFloat();
+		case 102:
+			return false;
+		case 105:
+			return this.readDigits();
+		case 106:
+			var name4 = this.unserialize();
+			var edecl = this.resolver.resolveEnum(name4);
+			if(edecl == null) {
+				throw new (js__$Boot_HaxeError().default)("Enum not found " + name4);
+			}
+			this.pos++;
+			var index = this.readDigits();
+			var tag = (Type().default).getEnumConstructs(edecl)[index];
+			if(tag == null) {
+				throw new (js__$Boot_HaxeError().default)("Unknown enum index " + name4 + "@" + index);
+			}
+			var e1 = this.unserializeEnum(edecl,tag);
+			this.cache.push(e1);
+			return e1;
+		case 107:
+			return NaN;
+		case 108:
+			var l = new (List().default)();
+			this.cache.push(l);
+			var buf3 = this.buf;
+			while(this.get(this.pos) != 104) l.add(this.unserialize());
+			this.pos++;
+			return l;
+		case 109:
+			return -Infinity;
+		case 110:
+			return null;
+		case 111:
+			var o2 = { };
+			this.cache.push(o2);
+			this.unserializeObject(o2);
+			return o2;
+		case 112:
+			return Infinity;
+		case 113:
+			var h2 = new (haxe_ds_IntMap().default)();
+			this.cache.push(h2);
+			var buf4 = this.buf;
+			var c1 = this.get(this.pos++);
+			while(c1 == 58) {
+				var i = this.readDigits();
+				h2.set(i,this.unserialize());
+				c1 = this.get(this.pos++);
+			}
+			if(c1 != 104) {
+				throw new (js__$Boot_HaxeError().default)("Invalid IntMap format");
+			}
+			return h2;
+		case 114:
+			var n2 = this.readDigits();
+			if(n2 < 0 || n2 >= this.cache.length) {
+				throw new (js__$Boot_HaxeError().default)("Invalid reference");
+			}
+			return this.cache[n2];
+		case 115:
+			var len = this.readDigits();
+			var buf5 = this.buf;
+			if(this.get(this.pos++) != 58 || this.length - this.pos < len) {
+				throw new (js__$Boot_HaxeError().default)("Invalid bytes length");
+			}
+			var codes = Unserializer.CODES;
+			if(codes == null) {
+				codes = Unserializer.initCodes();
+				Unserializer.CODES = codes;
+			}
+			var i1 = this.pos;
+			var rest = len & 3;
+			var size = (len >> 2) * 3 + (rest >= 2 ? rest - 1 : 0);
+			var max = i1 + (len - rest);
+			var bytes = (haxe_io_Bytes().default).alloc(size);
+			var bpos = 0;
+			while(i1 < max) {
+				var c11 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				var c2 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				bytes.set(bpos++,c11 << 2 | c2 >> 4);
+				var c3 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				bytes.set(bpos++,c2 << 4 | c3 >> 2);
+				var c4 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				bytes.set(bpos++,c3 << 6 | c4);
+			}
+			if(rest >= 2) {
+				var c12 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				var c21 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+				bytes.set(bpos++,c12 << 2 | c21 >> 4);
+				if(rest == 3) {
+					var c31 = codes[(StringTools().default).fastCodeAt(buf5,i1++)];
+					bytes.set(bpos++,c21 << 4 | c31 >> 2);
+				}
+			}
+			this.pos += len;
+			this.cache.push(bytes);
+			return bytes;
+		case 116:
+			return true;
+		case 118:
+			var d;
+			if(this.get(this.pos) >= 48 && this.get(this.pos) <= 57 && this.get(this.pos + 1) >= 48 && this.get(this.pos + 1) <= 57 && this.get(this.pos + 2) >= 48 && this.get(this.pos + 2) <= 57 && this.get(this.pos + 3) >= 48 && this.get(this.pos + 3) <= 57 && this.get(this.pos + 4) == 45) {
+				d = (HxOverrides().default).strDate((HxOverrides().default).substr(this.buf,this.pos,19));
+				this.pos += 19;
+			} else {
+				var t = this.readFloat();
+				d = new Date(t);
+			}
+			this.cache.push(d);
+			return d;
+		case 119:
+			var name5 = this.unserialize();
+			var edecl1 = this.resolver.resolveEnum(name5);
+			if(edecl1 == null) {
+				throw new (js__$Boot_HaxeError().default)("Enum not found " + name5);
+			}
+			var e2 = this.unserializeEnum(edecl1,this.unserialize());
+			this.cache.push(e2);
+			return e2;
+		case 120:
+			throw (js__$Boot_HaxeError().default).wrap(this.unserialize());
+			break;
+		case 121:
+			var len1 = this.readDigits();
+			if(this.get(this.pos++) != 58 || this.length - this.pos < len1) {
+				throw new (js__$Boot_HaxeError().default)("Invalid string length");
+			}
+			var s2 = (HxOverrides().default).substr(this.buf,this.pos,len1);
+			this.pos += len1;
+			s2 = (StringTools().default).urlDecode(s2);
+			this.scache.push(s2);
+			return s2;
+		case 122:
+			return 0;
+		default:
+		}
+		this.pos--;
+		throw new (js__$Boot_HaxeError().default)("Invalid char " + this.buf.charAt(this.pos) + " at position " + this.pos);
+	}
+};
+Unserializer.prototype.__class__ = $hxClasses["haxe.Unserializer"] = Unserializer;
+
+// Init
+
+
+
+// Statics
+
+Unserializer.initCodes = function() {
+	var codes = [];
+	var _g1 = 0;
+	var _g = Unserializer.BASE64.length;
+	while(_g1 < _g) {
+		var i = _g1++;
+		codes[(StringTools().default).fastCodeAt(Unserializer.BASE64,i)] = i;
+	}
+	return codes;
+}
+Unserializer.run = function(v) {
+	return new Unserializer(v).unserialize();
+}
+Unserializer.DEFAULT_RESOLVER = new (haxe__$Unserializer_DefaultResolver().default)()
+Unserializer.BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789%:"
+Unserializer.CODES = null
+
+// Export
+
+exports.default = Unserializer;

hGameTest/node_modules/openfl/lib/_gen/haxe/Utf8.js

@@ -0,0 +1,40 @@
+// Class: haxe.Utf8
+
+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 HxOverrides() {return require("./../HxOverrides");}
+
+// Constructor
+
+var Utf8 = function(){}
+
+// Meta
+
+Utf8.__name__ = ["haxe","Utf8"];
+Utf8.prototype = {
+	
+};
+Utf8.prototype.__class__ = $hxClasses["haxe.Utf8"] = Utf8;
+
+// Init
+
+
+
+// Statics
+
+Utf8.sub = function(s,pos,len) {
+	return (HxOverrides().default).substr(s,pos,len);
+}
+
+
+// Export
+
+exports.default = Utf8;

hGameTest/node_modules/openfl/lib/_gen/haxe/_Int32/Int32_Impl_.js

@@ -0,0 +1,95 @@
+// Class: haxe._Int32.Int32_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+
+// Constructor
+
+var Int32_Impl_ = function(){}
+
+// Meta
+
+Int32_Impl_.__name__ = ["haxe","_Int32","Int32_Impl_"];
+Int32_Impl_.prototype = {
+	
+};
+Int32_Impl_.prototype.__class__ = $hxClasses["haxe._Int32.Int32_Impl_"] = Int32_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Int32_Impl_.preIncrement = function(this1) {
+	this1 = ++this1 | 0;
+	return this1;
+}
+Int32_Impl_.postIncrement = function(this1) {
+	var ret = this1++;
+	this1 |= 0;
+	return ret;
+}
+Int32_Impl_.preDecrement = function(this1) {
+	this1 = --this1 | 0;
+	return this1;
+}
+Int32_Impl_.postDecrement = function(this1) {
+	var ret = this1--;
+	this1 |= 0;
+	return ret;
+}
+Int32_Impl_.add = function(a,b) {
+	return a + b | 0;
+}
+Int32_Impl_.addInt = function(a,b) {
+	return a + b | 0;
+}
+Int32_Impl_.sub = function(a,b) {
+	return a - b | 0;
+}
+Int32_Impl_.subInt = function(a,b) {
+	return a - b | 0;
+}
+Int32_Impl_.intSub = function(a,b) {
+	return a - b | 0;
+}
+Int32_Impl_.mul = function(a,b) {
+	return a * (b & 65535) + (a * (b >>> 16) << 16 | 0) | 0;
+}
+Int32_Impl_.mulInt = function(a,b) {
+	return Int32_Impl_.mul(a,b);
+}
+Int32_Impl_.toFloat = function(this1) {
+	return this1;
+}
+Int32_Impl_.ucompare = function(a,b) {
+	if(a < 0) {
+		if(b < 0) {
+			return ~b - ~a | 0;
+		} else {
+			return 1;
+		}
+	}
+	if(b < 0) {
+		return -1;
+	} else {
+		return a - b | 0;
+	}
+}
+Int32_Impl_.clamp = function(x) {
+	return x | 0;
+}
+
+
+// Export
+
+exports.default = Int32_Impl_;

hGameTest/node_modules/openfl/lib/_gen/haxe/_Int64/Int64_Impl_.js

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

hGameTest/node_modules/openfl/lib/_gen/haxe/_Int64/___Int64.js

@@ -0,0 +1,39 @@
+// Class: haxe._Int64.___Int64
+
+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 ___Int64 = function(high,low) {
+	this.high = high;
+	this.low = low;
+}
+
+// Meta
+
+___Int64.__name__ = ["haxe","_Int64","___Int64"];
+___Int64.prototype = {
+	
+};
+___Int64.prototype.__class__ = $hxClasses["haxe._Int64.___Int64"] = ___Int64;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ___Int64;

hGameTest/node_modules/openfl/lib/_gen/haxe/_Unserializer/DefaultResolver.js

@@ -0,0 +1,44 @@
+// Class: haxe._Unserializer.DefaultResolver
+
+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 Type() {return require("./../../Type");}
+
+// Constructor
+
+var DefaultResolver = function() {
+}
+
+// Meta
+
+DefaultResolver.__name__ = ["haxe","_Unserializer","DefaultResolver"];
+DefaultResolver.prototype = {
+	resolveClass: function(name) {
+		return (Type().default).resolveClass(name);
+	},
+	resolveEnum: function(name) {
+		return (Type().default).resolveEnum(name);
+	}
+};
+DefaultResolver.prototype.__class__ = $hxClasses["haxe._Unserializer.DefaultResolver"] = DefaultResolver;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = DefaultResolver;

hGameTest/node_modules/openfl/lib/_gen/haxe/_Unserializer/NullResolver.js

@@ -0,0 +1,48 @@
+// Class: haxe._Unserializer.NullResolver
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+
+// Constructor
+
+var NullResolver = function() {
+}
+
+// Meta
+
+NullResolver.__name__ = ["haxe","_Unserializer","NullResolver"];
+NullResolver.prototype = {
+	resolveClass: function(name) {
+		return null;
+	},
+	resolveEnum: function(name) {
+		return null;
+	}
+};
+NullResolver.prototype.__class__ = $hxClasses["haxe._Unserializer.NullResolver"] = NullResolver;
+
+// Init
+
+
+
+// Statics
+
+NullResolver.get_instance = function() {
+	if(NullResolver.instance == null) {
+		NullResolver.instance = new NullResolver();
+	}
+	return NullResolver.instance;
+}
+
+
+// Export
+
+exports.default = NullResolver;

hGameTest/node_modules/openfl/lib/_gen/haxe/crypto/Base64.js

@@ -0,0 +1,68 @@
+// Class: haxe.crypto.Base64
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../haxe/io/Bytes");}
+function haxe_crypto_BaseCode() {return require("./../../haxe/crypto/BaseCode");}
+function HxOverrides() {return require("./../../HxOverrides");}
+
+// Constructor
+
+var Base64 = function(){}
+
+// Meta
+
+Base64.__name__ = ["haxe","crypto","Base64"];
+Base64.prototype = {
+	
+};
+Base64.prototype.__class__ = $hxClasses["haxe.crypto.Base64"] = Base64;
+
+// Init
+
+
+
+// Statics
+
+Base64.encode = function(bytes,complement) {
+	if(complement == null) {
+		complement = true;
+	}
+	var str = new (haxe_crypto_BaseCode().default)(Base64.BYTES).encodeBytes(bytes).toString();
+	if(complement) {
+		var _g = bytes.get_length() % 3;
+		switch(_g) {
+		case 1:
+			str += "==";
+			break;
+		case 2:
+			str += "=";
+			break;
+		default:
+		}
+	}
+	return str;
+}
+Base64.decode = function(str,complement) {
+	if(complement == null) {
+		complement = true;
+	}
+	if(complement) {
+		while((HxOverrides().default).cca(str,str.length - 1) == 61) str = (HxOverrides().default).substr(str,0,-1);
+	}
+	return new (haxe_crypto_BaseCode().default)(Base64.BYTES).decodeBytes((haxe_io_Bytes().default).ofString(str));
+}
+Base64.CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+Base64.BYTES = (haxe_io_Bytes().default).ofString(Base64.CHARS)
+
+// Export
+
+exports.default = Base64;

hGameTest/node_modules/openfl/lib/_gen/haxe/crypto/BaseCode.js

@@ -0,0 +1,115 @@
+// Class: haxe.crypto.BaseCode
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Std() {return require("./../../Std");}
+function haxe_io_Bytes() {return require("./../../haxe/io/Bytes");}
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var BaseCode = function(base) {
+	var len = base.get_length();
+	var nbits = 1;
+	while(len > 1 << nbits) ++nbits;
+	if(nbits > 8 || len != 1 << nbits) {
+		throw new (js__$Boot_HaxeError().default)("BaseCode : base length must be a power of two.");
+	}
+	this.base = base;
+	this.nbits = nbits;
+}
+
+// Meta
+
+BaseCode.__name__ = ["haxe","crypto","BaseCode"];
+BaseCode.prototype = {
+	encodeBytes: function(b) {
+		var nbits = this.nbits;
+		var base = this.base;
+		var size = (Std().default)["int"](b.get_length() * 8 / nbits);
+		var out = (haxe_io_Bytes().default).alloc(size + (b.get_length() * 8 % nbits == 0 ? 0 : 1));
+		var buf = 0;
+		var curbits = 0;
+		var mask = (1 << nbits) - 1;
+		var pin = 0;
+		var pout = 0;
+		while(pout < size) {
+			while(curbits < nbits) {
+				curbits += 8;
+				buf <<= 8;
+				buf |= b.get(pin++);
+			}
+			curbits -= nbits;
+			out.set(pout++,base.get(buf >> curbits & mask));
+		}
+		if(curbits > 0) {
+			out.set(pout++,base.get(buf << nbits - curbits & mask));
+		}
+		return out;
+	},
+	initTable: function() {
+		var tbl = [];
+		var _g = 0;
+		while(_g < 256) {
+			var i = _g++;
+			tbl[i] = -1;
+		}
+		var _g1 = 0;
+		var _g2 = this.base.get_length();
+		while(_g1 < _g2) {
+			var i1 = _g1++;
+			tbl[this.base.get(i1)] = i1;
+		}
+		this.tbl = tbl;
+	},
+	decodeBytes: function(b) {
+		var nbits = this.nbits;
+		var base = this.base;
+		if(this.tbl == null) {
+			this.initTable();
+		}
+		var tbl = this.tbl;
+		var size = b.get_length() * nbits >> 3;
+		var out = (haxe_io_Bytes().default).alloc(size);
+		var buf = 0;
+		var curbits = 0;
+		var pin = 0;
+		var pout = 0;
+		while(pout < size) {
+			while(curbits < 8) {
+				curbits += nbits;
+				buf <<= nbits;
+				var i = tbl[b.get(pin++)];
+				if(i == -1) {
+					throw new (js__$Boot_HaxeError().default)("BaseCode : invalid encoded char");
+				}
+				buf |= i;
+			}
+			curbits -= 8;
+			out.set(pout++,buf >> curbits & 255);
+		}
+		return out;
+	}
+};
+BaseCode.prototype.__class__ = $hxClasses["haxe.crypto.BaseCode"] = BaseCode;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = BaseCode;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/BalancedTree.js

@@ -0,0 +1,189 @@
+// Class: haxe.ds.BalancedTree
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+function js_Boot() {return require("./../../js/Boot");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function haxe_ds_TreeNode() {return require("./../../haxe/ds/TreeNode");}
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var BalancedTree = function() {
+}
+
+// Meta
+
+BalancedTree.__name__ = ["haxe","ds","BalancedTree"];
+BalancedTree.prototype = {
+	set: function(key,value) {
+		this.root = this.setLoop(key,value,this.root);
+	},
+	get: function(key) {
+		var node = this.root;
+		while(node != null) {
+			var c = this.compare(key,node.key);
+			if(c == 0) {
+				return node.value;
+			}
+			if(c < 0) {
+				node = node.left;
+			} else {
+				node = node.right;
+			}
+		}
+		return null;
+	},
+	remove: function(key) {
+		try {
+			this.root = this.removeLoop(key,this.root);
+			return true;
+		} catch( e ) {
+			if (e instanceof (js__$Boot_HaxeError().default)) e = e.val;
+			if( (js_Boot().default).__instanceof(e,String) ) {
+				return false;
+			} else throw(e);
+		}
+	},
+	exists: function(key) {
+		var node = this.root;
+		while(node != null) {
+			var c = this.compare(key,node.key);
+			if(c == 0) {
+				return true;
+			} else if(c < 0) {
+				node = node.left;
+			} else {
+				node = node.right;
+			}
+		}
+		return false;
+	},
+	iterator: function() {
+		var ret = [];
+		this.iteratorLoop(this.root,ret);
+		return (HxOverrides().default).iter(ret);
+	},
+	keys: function() {
+		var ret = [];
+		this.keysLoop(this.root,ret);
+		return (HxOverrides().default).iter(ret);
+	},
+	setLoop: function(k,v,node) {
+		if(node == null) {
+			return new (haxe_ds_TreeNode().default)(null,k,v,null);
+		}
+		var c = this.compare(k,node.key);
+		if(c == 0) {
+			return new (haxe_ds_TreeNode().default)(node.left,k,v,node.right,node == null ? 0 : node._height);
+		} else if(c < 0) {
+			var nl = this.setLoop(k,v,node.left);
+			return this.balance(nl,node.key,node.value,node.right);
+		} else {
+			var nr = this.setLoop(k,v,node.right);
+			return this.balance(node.left,node.key,node.value,nr);
+		}
+	},
+	removeLoop: function(k,node) {
+		if(node == null) {
+			throw new (js__$Boot_HaxeError().default)("Not_found");
+		}
+		var c = this.compare(k,node.key);
+		if(c == 0) {
+			return this.merge(node.left,node.right);
+		} else if(c < 0) {
+			return this.balance(this.removeLoop(k,node.left),node.key,node.value,node.right);
+		} else {
+			return this.balance(node.left,node.key,node.value,this.removeLoop(k,node.right));
+		}
+	},
+	iteratorLoop: function(node,acc) {
+		if(node != null) {
+			this.iteratorLoop(node.left,acc);
+			acc.push(node.value);
+			this.iteratorLoop(node.right,acc);
+		}
+	},
+	keysLoop: function(node,acc) {
+		if(node != null) {
+			this.keysLoop(node.left,acc);
+			acc.push(node.key);
+			this.keysLoop(node.right,acc);
+		}
+	},
+	merge: function(t1,t2) {
+		if(t1 == null) {
+			return t2;
+		}
+		if(t2 == null) {
+			return t1;
+		}
+		var t = this.minBinding(t2);
+		return this.balance(t1,t.key,t.value,this.removeMinBinding(t2));
+	},
+	minBinding: function(t) {
+		if(t == null) {
+			throw new (js__$Boot_HaxeError().default)("Not_found");
+		} else if(t.left == null) {
+			return t;
+		} else {
+			return this.minBinding(t.left);
+		}
+	},
+	removeMinBinding: function(t) {
+		if(t.left == null) {
+			return t.right;
+		} else {
+			return this.balance(this.removeMinBinding(t.left),t.key,t.value,t.right);
+		}
+	},
+	balance: function(l,k,v,r) {
+		var hl = l == null ? 0 : l._height;
+		var hr = r == null ? 0 : r._height;
+		if(hl > hr + 2) {
+			var _this = l.left;
+			var _this1 = l.right;
+			if((_this == null ? 0 : _this._height) >= (_this1 == null ? 0 : _this1._height)) {
+				return new (haxe_ds_TreeNode().default)(l.left,l.key,l.value,new (haxe_ds_TreeNode().default)(l.right,k,v,r));
+			} else {
+				return new (haxe_ds_TreeNode().default)(new (haxe_ds_TreeNode().default)(l.left,l.key,l.value,l.right.left),l.right.key,l.right.value,new (haxe_ds_TreeNode().default)(l.right.right,k,v,r));
+			}
+		} else if(hr > hl + 2) {
+			var _this2 = r.right;
+			var _this3 = r.left;
+			if((_this2 == null ? 0 : _this2._height) > (_this3 == null ? 0 : _this3._height)) {
+				return new (haxe_ds_TreeNode().default)(new (haxe_ds_TreeNode().default)(l,k,v,r.left),r.key,r.value,r.right);
+			} else {
+				return new (haxe_ds_TreeNode().default)(new (haxe_ds_TreeNode().default)(l,k,v,r.left.left),r.left.key,r.left.value,new (haxe_ds_TreeNode().default)(r.left.right,r.key,r.value,r.right));
+			}
+		} else {
+			return new (haxe_ds_TreeNode().default)(l,k,v,r,(hl > hr ? hl : hr) + 1);
+		}
+	},
+	compare: function(k1,k2) {
+		return (Reflect().default).compare(k1,k2);
+	}
+};
+BalancedTree.prototype.__class__ = $hxClasses["haxe.ds.BalancedTree"] = BalancedTree;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = BalancedTree;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/EnumValueMap.js

@@ -0,0 +1,82 @@
+// Class: haxe.ds.EnumValueMap
+
+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 haxe_IMap() {return require("./../../haxe/IMap");}
+function haxe_ds_BalancedTree() {return require("./../../haxe/ds/BalancedTree");}
+function Type() {return require("./../../Type");}
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var EnumValueMap = function() {
+	(haxe_ds_BalancedTree().default).call(this);
+}
+
+// Meta
+
+EnumValueMap.__name__ = ["haxe","ds","EnumValueMap"];
+EnumValueMap.__interfaces__ = [(haxe_IMap().default)];
+EnumValueMap.__super__ = (haxe_ds_BalancedTree().default);
+EnumValueMap.prototype = $extend((haxe_ds_BalancedTree().default).prototype, {
+	compare: function(k1,k2) {
+		var d = (Type().default).enumIndex(k1) - (Type().default).enumIndex(k2);
+		if(d != 0) {
+			return d;
+		}
+		var p1 = (Type().default).enumParameters(k1);
+		var p2 = (Type().default).enumParameters(k2);
+		if(p1.length == 0 && p2.length == 0) {
+			return 0;
+		}
+		return this.compareArgs(p1,p2);
+	},
+	compareArgs: function(a1,a2) {
+		var ld = a1.length - a2.length;
+		if(ld != 0) {
+			return ld;
+		}
+		var _g1 = 0;
+		var _g = a1.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			var d = this.compareArg(a1[i],a2[i]);
+			if(d != 0) {
+				return d;
+			}
+		}
+		return 0;
+	},
+	compareArg: function(v1,v2) {
+		if((Reflect().default).isEnumValue(v1) && (Reflect().default).isEnumValue(v2)) {
+			return this.compare(v1,v2);
+		} else if((v1 instanceof Array) && v1.__enum__ == null && ((v2 instanceof Array) && v2.__enum__ == null)) {
+			return this.compareArgs(v1,v2);
+		} else {
+			return (Reflect().default).compare(v1,v2);
+		}
+	}
+});
+EnumValueMap.prototype.__class__ = $hxClasses["haxe.ds.EnumValueMap"] = EnumValueMap;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = EnumValueMap;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/IntMap.js

@@ -0,0 +1,72 @@
+// Class: haxe.ds.IntMap
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function haxe_IMap() {return require("./../../haxe/IMap");}
+function HxOverrides() {return require("./../../HxOverrides");}
+
+// Constructor
+
+var IntMap = function() {
+	this.h = { };
+}
+
+// Meta
+
+IntMap.__name__ = ["haxe","ds","IntMap"];
+IntMap.__interfaces__ = [(haxe_IMap().default)];
+IntMap.prototype = {
+	set: function(key,value) {
+		this.h[key] = value;
+	},
+	get: function(key) {
+		return this.h[key];
+	},
+	exists: function(key) {
+		return this.h.hasOwnProperty(key);
+	},
+	remove: function(key) {
+		if(!this.h.hasOwnProperty(key)) {
+			return false;
+		}
+		delete(this.h[key]);
+		return true;
+	},
+	keys: function() {
+		var a = [];
+		for( var key in this.h ) if(this.h.hasOwnProperty(key)) {
+			a.push(key | 0);
+		}
+		return (HxOverrides().default).iter(a);
+	},
+	iterator: function() {
+		return { ref : this.h, it : this.keys(), hasNext : function() {
+			return this.it.hasNext();
+		}, next : function() {
+			var i = this.it.next();
+			return this.ref[i];
+		}};
+	}
+};
+IntMap.prototype.__class__ = $hxClasses["haxe.ds.IntMap"] = IntMap;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = IntMap;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/ObjectMap.js

@@ -0,0 +1,102 @@
+// Class: haxe.ds.ObjectMap
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function haxe_IMap() {return require("./../../haxe/IMap");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function StringBuf() {return require("./../../StringBuf");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var ObjectMap = function() {
+	this.h = { __keys__ : { }};
+}
+
+// Meta
+
+ObjectMap.__name__ = ["haxe","ds","ObjectMap"];
+ObjectMap.__interfaces__ = [(haxe_IMap().default)];
+ObjectMap.prototype = {
+	set: function(key,value) {
+		var id = ObjectMap.getId(key) || ObjectMap.assignId(key);
+		this.h[id] = value;
+		this.h.__keys__[id] = key;
+	},
+	get: function(key) {
+		return this.h[ObjectMap.getId(key)];
+	},
+	exists: function(key) {
+		return this.h.__keys__[ObjectMap.getId(key)] != null;
+	},
+	remove: function(key) {
+		var id = ObjectMap.getId(key);
+		if(this.h.__keys__[id] == null) {
+			return false;
+		}
+		delete(this.h[id]);
+		delete(this.h.__keys__[id]);
+		return true;
+	},
+	keys: function() {
+		var a = [];
+		for( var key in this.h.__keys__ ) {
+		if(this.h.hasOwnProperty(key)) {
+			a.push(this.h.__keys__[key]);
+		}
+		}
+		return (HxOverrides().default).iter(a);
+	},
+	iterator: function() {
+		return { ref : this.h, it : this.keys(), hasNext : function() {
+			return this.it.hasNext();
+		}, next : function() {
+			var i = this.it.next();
+			return this.ref[ObjectMap.getId(i)];
+		}};
+	},
+	toString: function() {
+		var s = new (StringBuf().default)();
+		s.add("{");
+		var it = this.keys();
+		var i = it;
+		while(i.hasNext()) {
+			var i1 = i.next();
+			s.add((Std().default).string(i1));
+			s.add(" => ");
+			s.add((Std().default).string(this.get(i1)));
+			if(it.hasNext()) {
+				s.add(", ");
+			}
+		}
+		s.add("}");
+		return s.toString();
+	}
+};
+ObjectMap.prototype.__class__ = $hxClasses["haxe.ds.ObjectMap"] = ObjectMap;
+
+// Init
+
+
+
+// Statics
+
+ObjectMap.assignId = function(obj) {
+	return obj.__id__ = ++ObjectMap.count;
+}
+ObjectMap.getId = function(obj) {
+	return obj.__id__;
+}
+ObjectMap.count = 0
+
+// Export
+
+exports.default = ObjectMap;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/StringMap.js

@@ -0,0 +1,142 @@
+// Class: haxe.ds.StringMap
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function haxe_IMap() {return require("./../../haxe/IMap");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function haxe_ds__$StringMap_StringMapIterator() {return require("./../../haxe/ds/_StringMap/StringMapIterator");}
+function StringBuf() {return require("./../../StringBuf");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var StringMap = function() {
+	this.h = { };
+}
+
+// Meta
+
+StringMap.__name__ = ["haxe","ds","StringMap"];
+StringMap.__interfaces__ = [(haxe_IMap().default)];
+StringMap.prototype = {
+	isReserved: function(key) {
+		return __map_reserved[key] != null;
+	},
+	set: function(key,value) {
+		if(this.isReserved(key)) {
+			this.setReserved(key,value);
+		} else {
+			this.h[key] = value;
+		}
+	},
+	get: function(key) {
+		if(this.isReserved(key)) {
+			return this.getReserved(key);
+		}
+		return this.h[key];
+	},
+	exists: function(key) {
+		if(this.isReserved(key)) {
+			return this.existsReserved(key);
+		}
+		return this.h.hasOwnProperty(key);
+	},
+	setReserved: function(key,value) {
+		if(this.rh == null) {
+			this.rh = { };
+		}
+		this.rh["$" + key] = value;
+	},
+	getReserved: function(key) {
+		if(this.rh == null) {
+			return null;
+		} else {
+			return this.rh["$" + key];
+		}
+	},
+	existsReserved: function(key) {
+		if(this.rh == null) {
+			return false;
+		}
+		return this.rh.hasOwnProperty("$" + key);
+	},
+	remove: function(key) {
+		if(this.isReserved(key)) {
+			key = "$" + key;
+			if(this.rh == null || !this.rh.hasOwnProperty(key)) {
+				return false;
+			}
+			delete(this.rh[key]);
+			return true;
+		} else {
+			if(!this.h.hasOwnProperty(key)) {
+				return false;
+			}
+			delete(this.h[key]);
+			return true;
+		}
+	},
+	keys: function() {
+		return (HxOverrides().default).iter(this.arrayKeys());
+	},
+	arrayKeys: function() {
+		var out = [];
+		for( var key in this.h ) {
+		if(this.h.hasOwnProperty(key)) {
+			out.push(key);
+		}
+		}
+		if(this.rh != null) {
+			for( var key in this.rh ) {
+			if(key.charCodeAt(0) == 36) {
+				out.push(key.substr(1));
+			}
+			}
+		}
+		return out;
+	},
+	iterator: function() {
+		return new (haxe_ds__$StringMap_StringMapIterator().default)(this,this.arrayKeys());
+	},
+	toString: function() {
+		var s = new (StringBuf().default)();
+		s.add("{");
+		var keys = this.arrayKeys();
+		var _g1 = 0;
+		var _g = keys.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			var k = keys[i];
+			s.add(k);
+			s.add(" => ");
+			s.add((Std().default).string(this.get(k)));
+			if(i < keys.length - 1) {
+				s.add(", ");
+			}
+		}
+		s.add("}");
+		return s.toString();
+	}
+};
+StringMap.prototype.__class__ = $hxClasses["haxe.ds.StringMap"] = StringMap;
+
+// Init
+
+var __map_reserved = {};;
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = StringMap;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/TreeNode.js

@@ -0,0 +1,67 @@
+// Class: haxe.ds.TreeNode
+
+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 TreeNode = function(l,k,v,r,h) {
+	if(h == null) {
+		h = -1;
+	}
+	this.left = l;
+	this.key = k;
+	this.value = v;
+	this.right = r;
+	if(h == -1) {
+		var tmp;
+		var _this = this.left;
+		var _this1 = this.right;
+		if((_this == null ? 0 : _this._height) > (_this1 == null ? 0 : _this1._height)) {
+			var _this2 = this.left;
+			if(_this2 == null) {
+				tmp = 0;
+			} else {
+				tmp = _this2._height;
+			}
+		} else {
+			var _this3 = this.right;
+			if(_this3 == null) {
+				tmp = 0;
+			} else {
+				tmp = _this3._height;
+			}
+		}
+		this._height = tmp + 1;
+	} else {
+		this._height = h;
+	}
+}
+
+// Meta
+
+TreeNode.__name__ = ["haxe","ds","TreeNode"];
+TreeNode.prototype = {
+	
+};
+TreeNode.prototype.__class__ = $hxClasses["haxe.ds.TreeNode"] = TreeNode;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = TreeNode;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/_StringMap/StringMapIterator.js

@@ -0,0 +1,46 @@
+// Class: haxe.ds._StringMap.StringMapIterator
+
+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 StringMapIterator = function(map,keys) {
+	this.map = map;
+	this.keys = keys;
+	this.index = 0;
+	this.count = keys.length;
+}
+
+// Meta
+
+StringMapIterator.__name__ = ["haxe","ds","_StringMap","StringMapIterator"];
+StringMapIterator.prototype = {
+	hasNext: function() {
+		return this.index < this.count;
+	},
+	next: function() {
+		return this.map.get(this.keys[this.index++]);
+	}
+};
+StringMapIterator.prototype.__class__ = $hxClasses["haxe.ds._StringMap.StringMapIterator"] = StringMapIterator;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = StringMapIterator;

hGameTest/node_modules/openfl/lib/_gen/haxe/ds/_Vector/Vector_Impl_.js

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

hGameTest/node_modules/openfl/lib/_gen/haxe/io/Bytes.js

@@ -0,0 +1,241 @@
+// Class: haxe.io.Bytes
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+function haxe_io_Error() {return require("./../../haxe/io/Error");}
+function haxe__$Int64__$_$_$Int64() {return require("./../../haxe/_Int64/___Int64");}
+function StringBuf() {return require("./../../StringBuf");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function StringTools() {return require("./../../StringTools");}
+
+// Constructor
+
+var Bytes = function(data) {
+	this.set_length(data.byteLength);
+	this.b = new Uint8Array(data);
+	this.b.bufferValue = data;
+	data.hxBytes = this;
+	data.bytes = this.b;
+}
+
+// Meta
+
+Bytes.__name__ = ["haxe","io","Bytes"];
+Bytes.prototype = {
+	get: function(pos) {
+		return this.b[pos];
+	},
+	set: function(pos,v) {
+		this.b[pos] = v & 255;
+	},
+	blit: function(pos,src,srcpos,len) {
+		if(pos < 0 || srcpos < 0 || len < 0 || pos + len > this.get_length() || srcpos + len > src.get_length()) {
+			throw new (js__$Boot_HaxeError().default)((haxe_io_Error().default).OutsideBounds);
+		}
+		if(srcpos == 0 && len == src.b.byteLength) {
+			this.b.set(src.b,pos);
+		} else {
+			this.b.set(src.b.subarray(srcpos,srcpos + len),pos);
+		}
+	},
+	fill: function(pos,len,value) {
+		var _g1 = 0;
+		var _g = len;
+		while(_g1 < _g) {
+			var i = _g1++;
+			this.set(pos++,value);
+		}
+	},
+	sub: function(pos,len) {
+		if(pos < 0 || len < 0 || pos + len > this.get_length()) {
+			throw new (js__$Boot_HaxeError().default)((haxe_io_Error().default).OutsideBounds);
+		}
+		return new Bytes(this.b.buffer.slice(pos + this.b.byteOffset,pos + this.b.byteOffset + len));
+	},
+	compare: function(other) {
+		var b1 = this.b;
+		var b2 = other.b;
+		var len = this.get_length() < other.get_length() ? this.get_length() : other.get_length();
+		var _g1 = 0;
+		var _g = len;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(b1[i] != b2[i]) {
+				return b1[i] - b2[i];
+			}
+		}
+		return this.get_length() - other.get_length();
+	},
+	initData: function() {
+		if(this.data == null) {
+			this.data = new DataView(this.b.buffer,this.b.byteOffset,this.b.byteLength);
+		}
+	},
+	getDouble: function(pos) {
+		this.initData();
+		return this.data.getFloat64(pos,true);
+	},
+	getFloat: function(pos) {
+		this.initData();
+		return this.data.getFloat32(pos,true);
+	},
+	setDouble: function(pos,v) {
+		this.initData();
+		this.data.setFloat64(pos,v,true);
+	},
+	setFloat: function(pos,v) {
+		this.initData();
+		this.data.setFloat32(pos,v,true);
+	},
+	getUInt16: function(pos) {
+		this.initData();
+		return this.data.getUint16(pos,true);
+	},
+	setUInt16: function(pos,v) {
+		this.initData();
+		this.data.setUint16(pos,v,true);
+	},
+	getInt32: function(pos) {
+		this.initData();
+		return this.data.getInt32(pos,true);
+	},
+	setInt32: function(pos,v) {
+		this.initData();
+		this.data.setInt32(pos,v,true);
+	},
+	getInt64: function(pos) {
+		var this1 = new (haxe__$Int64__$_$_$Int64().default)(this.getInt32(pos + 4),this.getInt32(pos));
+		return this1;
+	},
+	setInt64: function(pos,v) {
+		this.setInt32(pos,v.low);
+		this.setInt32(pos + 4,v.high);
+	},
+	getString: function(pos,len) {
+		if(pos < 0 || len < 0 || pos + len > this.get_length()) {
+			throw new (js__$Boot_HaxeError().default)((haxe_io_Error().default).OutsideBounds);
+		}
+		var s = "";
+		var b = this.b;
+		var fcc = String.fromCharCode;
+		var i = pos;
+		var max = pos + len;
+		while(i < max) {
+			var c = b[i++];
+			if(c < 128) {
+				if(c == 0) {
+					break;
+				}
+				s += fcc(c);
+			} else if(c < 224) {
+				s += fcc((c & 63) << 6 | b[i++] & 127);
+			} else if(c < 240) {
+				var c2 = b[i++];
+				s += fcc((c & 31) << 12 | (c2 & 127) << 6 | b[i++] & 127);
+			} else {
+				var c21 = b[i++];
+				var c3 = b[i++];
+				var u = (c & 15) << 18 | (c21 & 127) << 12 | (c3 & 127) << 6 | b[i++] & 127;
+				s += fcc((u >> 10) + 55232);
+				s += fcc(u & 1023 | 56320);
+			}
+		}
+		return s;
+	},
+	readString: function(pos,len) {
+		return this.getString(pos,len);
+	},
+	toString: function() {
+		return this.getString(0,this.get_length());
+	},
+	toHex: function() {
+		var s = new (StringBuf().default)();
+		var chars = [];
+		var str = "0123456789abcdef";
+		var _g1 = 0;
+		var _g = str.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			chars.push((HxOverrides().default).cca(str,i));
+		}
+		var _g11 = 0;
+		var _g2 = this.get_length();
+		while(_g11 < _g2) {
+			var i1 = _g11++;
+			var c = this.get(i1);
+			s.addChar(chars[c >> 4]);
+			s.addChar(chars[c & 15]);
+		}
+		return s.toString();
+	},
+	getData: function() {
+		return this.b.bufferValue;
+	},
+	get_length: function() {
+		return this.l;
+	},
+	set_length: function(v) {
+		return this.l = v;
+	}
+};
+Bytes.prototype.__class__ = $hxClasses["haxe.io.Bytes"] = Bytes;
+
+// Init
+
+
+
+// Statics
+
+Bytes.alloc = function(length) {
+	return new Bytes(new ArrayBuffer(length));
+}
+Bytes.ofString = function(s) {
+	var a = [];
+	var i = 0;
+	while(i < s.length) {
+		var c = (StringTools().default).fastCodeAt(s,i++);
+		if(55296 <= c && c <= 56319) {
+			c = c - 55232 << 10 | (StringTools().default).fastCodeAt(s,i++) & 1023;
+		}
+		if(c <= 127) {
+			a.push(c);
+		} else if(c <= 2047) {
+			a.push(192 | c >> 6);
+			a.push(128 | c & 63);
+		} else if(c <= 65535) {
+			a.push(224 | c >> 12);
+			a.push(128 | c >> 6 & 63);
+			a.push(128 | c & 63);
+		} else {
+			a.push(240 | c >> 18);
+			a.push(128 | c >> 12 & 63);
+			a.push(128 | c >> 6 & 63);
+			a.push(128 | c & 63);
+		}
+	}
+	return new Bytes(new Uint8Array(a).buffer);
+}
+Bytes.ofData = function(b) {
+	var hb = b.hxBytes;
+	if(hb != null) {
+		return hb;
+	}
+	return new Bytes(b);
+}
+Bytes.fastGet = function(b,pos) {
+	return b.bytes[pos];
+}
+
+
+// Export
+
+exports.default = Bytes;

hGameTest/node_modules/openfl/lib/_gen/haxe/io/Eof.js

@@ -0,0 +1,38 @@
+// Class: haxe.io.Eof
+
+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 Eof = function(){}
+
+// Meta
+
+Eof.__name__ = ["haxe","io","Eof"];
+Eof.prototype = {
+	toString: function() {
+		return "Eof";
+	}
+};
+Eof.prototype.__class__ = $hxClasses["haxe.io.Eof"] = Eof;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Eof;

hGameTest/node_modules/openfl/lib/_gen/haxe/io/Error.js

@@ -0,0 +1,30 @@
+// Enum: haxe.io.Error
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+// Imports
+
+var $estr = require("./../../estr_stub").default;
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Definition
+
+var Error = $hxClasses["haxe.io.Error"] = { __ename__: ["haxe","io","Error"], __constructs__: ["Blocked","Overflow","OutsideBounds","Custom"] }
+
+Error.Custom = function(e) { var $x = ["Custom",3,e]; $x.__enum__ = Error; $x.toString = $estr; return $x; }
+Error.Blocked = ["Blocked",0];
+Error.Blocked.toString = $estr;
+Error.Blocked.__enum__ = Error;
+
+Error.Overflow = ["Overflow",1];
+Error.Overflow.toString = $estr;
+Error.Overflow.__enum__ = Error;
+
+Error.OutsideBounds = ["OutsideBounds",2];
+Error.OutsideBounds.toString = $estr;
+Error.OutsideBounds.__enum__ = Error;
+
+
+exports.default = Error;

hGameTest/node_modules/openfl/lib/_gen/haxe/io/FPHelper.js

@@ -0,0 +1,104 @@
+// Class: haxe.io.FPHelper
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function haxe__$Int64__$_$_$Int64() {return require("./../../haxe/_Int64/___Int64");}
+function Std() {return require("./../../Std");}
+
+// Constructor
+
+var FPHelper = function(){}
+
+// Meta
+
+FPHelper.__name__ = ["haxe","io","FPHelper"];
+FPHelper.prototype = {
+	
+};
+FPHelper.prototype.__class__ = $hxClasses["haxe.io.FPHelper"] = FPHelper;
+
+// Init
+
+
+
+// Statics
+
+FPHelper.i32ToFloat = function(i) {
+	var sign = 1 - (i >>> 31 << 1);
+	var exp = i >>> 23 & 255;
+	var sig = i & 8388607;
+	if(sig == 0 && exp == 0) {
+		return 0.0;
+	}
+	return sign * (1 + Math.pow(2,-23) * sig) * Math.pow(2,exp - 127);
+}
+FPHelper.floatToI32 = function(f) {
+	if(f == 0) {
+		return 0;
+	}
+	var af = f < 0 ? -f : f;
+	var exp = Math.floor(Math.log(af) / 0.6931471805599453);
+	if(exp < -127) {
+		exp = -127;
+	} else if(exp > 128) {
+		exp = 128;
+	}
+	var sig = Math.round((af / Math.pow(2,exp) - 1) * 8388608);
+	if(sig == 8388608 && exp < 128) {
+		sig = 0;
+		++exp;
+	}
+	return (f < 0 ? -2147483648 : 0) | exp + 127 << 23 | sig;
+}
+FPHelper.i64ToDouble = function(low,high) {
+	var sign = 1 - (high >>> 31 << 1);
+	var exp = (high >> 20 & 2047) - 1023;
+	var sig = (high & 1048575) * 4294967296. + (low >>> 31) * 2147483648. + (low & 2147483647);
+	if(sig == 0 && exp == -1023) {
+		return 0.0;
+	}
+	return sign * (1.0 + Math.pow(2,-52) * sig) * Math.pow(2,exp);
+}
+FPHelper.doubleToI64 = function(v) {
+	var i64 = FPHelper.i64tmp;
+	if(v == 0) {
+		i64.low = 0;
+		i64.high = 0;
+	} else if(!isFinite(v)) {
+		if(v > 0) {
+			i64.low = 0;
+			i64.high = 2146435072;
+		} else {
+			i64.low = 0;
+			i64.high = -1048576;
+		}
+	} else {
+		var av = v < 0 ? -v : v;
+		var exp = Math.floor(Math.log(av) / 0.6931471805599453);
+		var sig = Math.round((av / Math.pow(2,exp) - 1) * 4503599627370496.);
+		var sig_l = (Std().default)["int"](sig);
+		var sig_h = (Std().default)["int"](sig / 4294967296.0);
+		i64.low = sig_l;
+		i64.high = (v < 0 ? -2147483648 : 0) | exp + 1023 << 20 | sig_h;
+	}
+	return i64;
+}
+FPHelper.i64tmp = (function($this) {
+	var $r;
+	var this1 = new (haxe__$Int64__$_$_$Int64().default)(0,0);
+	$r = this1;
+	return $r;
+}(this))
+FPHelper.LN2 = 0.6931471805599453
+
+// Export
+
+exports.default = FPHelper;

hGameTest/node_modules/openfl/lib/_gen/haxe/io/Path.js

@@ -0,0 +1,85 @@
+// Class: haxe.io.Path
+
+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 HxOverrides() {return require("./../../HxOverrides");}
+
+// Constructor
+
+var Path = function(path) {
+	switch(path) {
+	case ".":case "..":
+		this.dir = path;
+		this.file = "";
+		return;
+	}
+	var c1 = path.lastIndexOf("/");
+	var c2 = path.lastIndexOf("\\");
+	if(c1 < c2) {
+		this.dir = (HxOverrides().default).substr(path,0,c2);
+		path = (HxOverrides().default).substr(path,c2 + 1,null);
+		this.backslash = true;
+	} else if(c2 < c1) {
+		this.dir = (HxOverrides().default).substr(path,0,c1);
+		path = (HxOverrides().default).substr(path,c1 + 1,null);
+	} else {
+		this.dir = null;
+	}
+	var cp = path.lastIndexOf(".");
+	if(cp != -1) {
+		this.ext = (HxOverrides().default).substr(path,cp + 1,null);
+		this.file = (HxOverrides().default).substr(path,0,cp);
+	} else {
+		this.ext = null;
+		this.file = path;
+	}
+}
+
+// Meta
+
+Path.__name__ = ["haxe","io","Path"];
+Path.prototype = {
+	toString: function() {
+		return (this.dir == null ? "" : this.dir + (this.backslash ? "\\" : "/")) + this.file + (this.ext == null ? "" : "." + this.ext);
+	}
+};
+Path.prototype.__class__ = $hxClasses["haxe.io.Path"] = Path;
+
+// Init
+
+
+
+// Statics
+
+Path.withoutDirectory = function(path) {
+	var s = new Path(path);
+	s.dir = null;
+	return s.toString();
+}
+Path.directory = function(path) {
+	var s = new Path(path);
+	if(s.dir == null) {
+		return "";
+	}
+	return s.dir;
+}
+Path.extension = function(path) {
+	var s = new Path(path);
+	if(s.ext == null) {
+		return "";
+	}
+	return s.ext;
+}
+
+
+// Export
+
+exports.default = Path;

hGameTest/node_modules/openfl/lib/_gen/haxe/lang/Iterable.js

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

hGameTest/node_modules/openfl/lib/_gen/haxe/lang/Iterator.js

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

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

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, "__esModule", {value: true});
+
+exports.default = {
+	Enum: {}
+};

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

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, "__esModule", {value: true});
+
+// exports.default = function $import(obj) {
+// 	if(obj && obj.__esModule) {
+// 		// if(!obj.hasOwnProperty('default')) obj.default = obj;
+// 		return obj;
+// 	} else { 
+// 		var newObj = {};
+// 		if (obj != null) {
+// 			for (var key in obj) {
+// 				if (Object.prototype.hasOwnProperty.call(obj, key))
+// 					newObj[key] = obj[key];
+// 			}
+// 		} 
+// 		newObj.default = obj;
+// 		return newObj;
+// 	}
+// }
+exports.default = function $import(obj) {
+	return obj && obj.__esModule ? obj : {default: obj};
+}

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

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, "__esModule", {value: true});
+
+var $bind = require('./bind_stub').default;
+var HxOverrides = require('./HxOverrides');
+
+exports.default = function $iterator(o) {
+    if( o instanceof Array ) {
+        return function() {
+            return HxOverrides.default.iter(o);
+        };
+    }
+    return typeof(o.iterator) == 'function' ? $bind(o,o.iterator) : o.iterator;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,40 @@
+// Class: lime._backend.html5.GameDeviceData
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var GameDeviceData = function() {
+	this.connected = true;
+	this.buttons = [];
+	this.axes = [];
+}
+
+// Meta
+
+GameDeviceData.__name__ = ["lime","_backend","html5","GameDeviceData"];
+GameDeviceData.prototype = {
+	
+};
+GameDeviceData.prototype.__class__ = $hxClasses["lime._backend.html5.GameDeviceData"] = GameDeviceData;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = GameDeviceData;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,87 @@
+// Class: lime.app.Event
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var Event = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+Event.__name__ = ["lime","app","Event"];
+Event.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	}
+};
+Event.prototype.__class__ = $hxClasses["lime.app.Event"] = Event;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = Event;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Array_String__Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Array_String__Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Array_String__Void.__name__ = ["lime","app","_Event_Array_String__Void"];
+_Event_Array_String__Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Array_String__Void.prototype.__class__ = $hxClasses["lime.app._Event_Array_String__Void"] = _Event_Array_String__Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Array_String__Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Dynamic_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Dynamic_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Dynamic_Void.__name__ = ["lime","app","_Event_Dynamic_Void"];
+_Event_Dynamic_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Dynamic_Void.prototype.__class__ = $hxClasses["lime.app._Event_Dynamic_Void"] = _Event_Dynamic_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Dynamic_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Float_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Float_Void.__name__ = ["lime","app","_Event_Float_Float_Float_Void"];
+_Event_Float_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Float_Void"] = _Event_Float_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Float_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Int_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Int_Void.__name__ = ["lime","app","_Event_Float_Float_Int_Void"];
+_Event_Float_Float_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Int_Void"] = _Event_Float_Float_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Int_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Float_Float_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Float_Float_Void.__name__ = ["lime","app","_Event_Float_Float_Void"];
+_Event_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Float_Float_Void"] = _Event_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Float_Float_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Float_Float_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Float_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Float_Float_Void.__name__ = ["lime","app","_Event_Int_Float_Float_Void"];
+_Event_Int_Float_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Float_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Float_Float_Void"] = _Event_Int_Float_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Float_Float_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Float_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Float_Void.__name__ = ["lime","app","_Event_Int_Float_Void"];
+_Event_Int_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Float_Void"] = _Event_Int_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Float_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Int_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Int_Void.__name__ = ["lime","app","_Event_Int_Int_Void"];
+_Event_Int_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Int_Void"] = _Event_Int_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Int_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_Void.__name__ = ["lime","app","_Event_Int_Void"];
+_Event_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_Void"] = _Event_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Int_lime_ui_JoystickHatPosition_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Int_lime_ui_JoystickHatPosition_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Int_lime_ui_JoystickHatPosition_Void.__name__ = ["lime","app","_Event_Int_lime_ui_JoystickHatPosition_Void"];
+_Event_Int_lime_ui_JoystickHatPosition_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Int_lime_ui_JoystickHatPosition_Void.prototype.__class__ = $hxClasses["lime.app._Event_Int_lime_ui_JoystickHatPosition_Void"] = _Event_Int_lime_ui_JoystickHatPosition_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Int_lime_ui_JoystickHatPosition_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_String_Int_Int_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_String_Int_Int_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_String_Int_Int_Void.__name__ = ["lime","app","_Event_String_Int_Int_Void"];
+_Event_String_Int_Int_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1,a2) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1,a2);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_String_Int_Int_Void.prototype.__class__ = $hxClasses["lime.app._Event_String_Int_Int_Void"] = _Event_String_Int_Int_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_String_Int_Int_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_String_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_String_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_String_Void.__name__ = ["lime","app","_Event_String_Void"];
+_Event_String_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_String_Void.prototype.__class__ = $hxClasses["lime.app._Event_String_Void"] = _Event_String_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_String_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_Void_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_Void_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_Void_Void.__name__ = ["lime","app","_Event_Void_Void"];
+_Event_Void_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function() {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i]();
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_Void_Void.prototype.__class__ = $hxClasses["lime.app._Event_Void_Void"] = _Event_Void_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_Void_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_haxe_Function_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_haxe_Function_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_haxe_Function_Void.__name__ = ["lime","app","_Event_haxe_Function_Void"];
+_Event_haxe_Function_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_haxe_Function_Void.prototype.__class__ = $hxClasses["lime.app._Event_haxe_Function_Void"] = _Event_haxe_Function_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_haxe_Function_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_graphics_RenderContext_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_graphics_RenderContext_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_graphics_RenderContext_Void.__name__ = ["lime","app","_Event_lime_graphics_RenderContext_Void"];
+_Event_lime_graphics_RenderContext_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_graphics_RenderContext_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_graphics_RenderContext_Void"] = _Event_lime_graphics_RenderContext_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_graphics_RenderContext_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_GamepadAxis_Float_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_GamepadAxis_Float_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_GamepadAxis_Float_Void.__name__ = ["lime","app","_Event_lime_ui_GamepadAxis_Float_Void"];
+_Event_lime_ui_GamepadAxis_Float_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_GamepadAxis_Float_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_GamepadAxis_Float_Void"] = _Event_lime_ui_GamepadAxis_Float_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_GamepadAxis_Float_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_GamepadButton_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_GamepadButton_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_GamepadButton_Void.__name__ = ["lime","app","_Event_lime_ui_GamepadButton_Void"];
+_Event_lime_ui_GamepadButton_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_GamepadButton_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_GamepadButton_Void"] = _Event_lime_ui_GamepadButton_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_GamepadButton_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Gamepad_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Gamepad_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Gamepad_Void.__name__ = ["lime","app","_Event_lime_ui_Gamepad_Void"];
+_Event_lime_ui_Gamepad_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Gamepad_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Gamepad_Void"] = _Event_lime_ui_Gamepad_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Gamepad_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Joystick_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Joystick_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Joystick_Void.__name__ = ["lime","app","_Event_lime_ui_Joystick_Void"];
+_Event_lime_ui_Joystick_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Joystick_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Joystick_Void"] = _Event_lime_ui_Joystick_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Joystick_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.__name__ = ["lime","app","_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void"];
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a,a1) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a,a1);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void"] = _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_ui_Touch_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_ui_Touch_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_ui_Touch_Void.__name__ = ["lime","app","_Event_lime_ui_Touch_Void"];
+_Event_lime_ui_Touch_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_ui_Touch_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_ui_Touch_Void"] = _Event_lime_ui_Touch_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_ui_Touch_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_lime_utils_Resource_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_lime_utils_Resource_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_lime_utils_Resource_Void.__name__ = ["lime","app","_Event_lime_utils_Resource_Void"];
+_Event_lime_utils_Resource_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_lime_utils_Resource_Void.prototype.__class__ = $hxClasses["lime.app._Event_lime_utils_Resource_Void"] = _Event_lime_utils_Resource_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_lime_utils_Resource_Void;

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

@@ -0,0 +1,104 @@
+// Class: lime.app._Event_ofEvents_T_Void
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var _Event_ofEvents_T_Void = function() {
+	this.canceled = false;
+	this.__listeners = [];
+	this.__priorities = [];
+	this.__repeat = [];
+}
+
+// Meta
+
+_Event_ofEvents_T_Void.__name__ = ["lime","app","_Event_ofEvents_T_Void"];
+_Event_ofEvents_T_Void.prototype = {
+	add: function(listener,once,priority) {
+		if(priority == null) {
+			priority = 0;
+		}
+		if(once == null) {
+			once = false;
+		}
+		var _g1 = 0;
+		var _g = this.__priorities.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			if(priority > this.__priorities[i]) {
+				this.__listeners.splice(i,0,listener);
+				this.__priorities.splice(i,0,priority);
+				this.__repeat.splice(i,0,!once);
+				return;
+			}
+		}
+		this.__listeners.push(listener);
+		this.__priorities.push(priority);
+		this.__repeat.push(!once);
+	},
+	cancel: function() {
+		this.canceled = true;
+	},
+	has: function(listener) {
+		var _g = 0;
+		var _g1 = this.__listeners;
+		while(_g < _g1.length) {
+			var l = _g1[_g];
+			++_g;
+			if((Reflect().default).compareMethods(l,listener)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	remove: function(listener) {
+		var i = this.__listeners.length;
+		while(--i >= 0) if((Reflect().default).compareMethods(this.__listeners[i],listener)) {
+			this.__listeners.splice(i,1);
+			this.__priorities.splice(i,1);
+			this.__repeat.splice(i,1);
+		}
+	},
+	dispatch: function(a) {
+		this.canceled = false;
+		var listeners = this.__listeners;
+		var repeat = this.__repeat;
+		var i = 0;
+		while(i < listeners.length) {
+			listeners[i](a);
+			if(!repeat[i]) {
+				this.remove(listeners[i]);
+			} else {
+				++i;
+			}
+			if(this.canceled) {
+				break;
+			}
+		}
+	}
+};
+_Event_ofEvents_T_Void.prototype.__class__ = $hxClasses["lime.app._Event_ofEvents_T_Void"] = _Event_ofEvents_T_Void;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = _Event_ofEvents_T_Void;

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

@@ -0,0 +1,62 @@
+// Class: lime.app._Future.FutureWork
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_system_ThreadPool() {return require("./../../../lime/system/ThreadPool");}
+function js__$Boot_HaxeError() {return require("./../../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var FutureWork = function(){}
+
+// Meta
+
+FutureWork.__name__ = ["lime","app","_Future","FutureWork"];
+FutureWork.prototype = {
+	
+};
+FutureWork.prototype.__class__ = $hxClasses["lime.app._Future.FutureWork"] = FutureWork;
+
+// Init
+
+
+
+// Statics
+
+FutureWork.queue = function(state) {
+	if(FutureWork.threadPool == null) {
+		FutureWork.threadPool = new (lime_system_ThreadPool().default)();
+		FutureWork.threadPool.doWork.add(FutureWork.threadPool_doWork);
+		FutureWork.threadPool.onComplete.add(FutureWork.threadPool_onComplete);
+		FutureWork.threadPool.onError.add(FutureWork.threadPool_onError);
+	}
+	FutureWork.threadPool.queue(state);
+}
+FutureWork.threadPool_doWork = function(state) {
+	try {
+		var result = state.work();
+		FutureWork.threadPool.sendComplete({ promise : state.promise, result : result});
+	} catch( e ) {
+		if (e instanceof (js__$Boot_HaxeError().default)) e = e.val;
+		FutureWork.threadPool.sendError({ promise : state.promise, error : e});
+	}
+}
+FutureWork.threadPool_onComplete = function(state) {
+	state.promise.complete(state.result);
+}
+FutureWork.threadPool_onError = function(state) {
+	state.promise.error(state.error);
+}
+
+
+// Export
+
+exports.default = FutureWork;

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

@@ -0,0 +1,83 @@
+// Class: lime.graphics.ConsoleRenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_graphics_console_IndexBuffer() {return require("./../../lime/graphics/console/IndexBuffer");}
+function lime_graphics_console_VertexBuffer() {return require("./../../lime/graphics/console/VertexBuffer");}
+function lime_graphics_console_Shader() {return require("./../../lime/graphics/console/Shader");}
+
+// Constructor
+
+var ConsoleRenderContext = function() {
+}
+
+// Meta
+
+ConsoleRenderContext.__name__ = ["lime","graphics","ConsoleRenderContext"];
+ConsoleRenderContext.prototype = {
+	createIndexBuffer: function(indices,count) {
+		return new (lime_graphics_console_IndexBuffer().default)();
+	},
+	createVertexBuffer: function(decl,count) {
+		return new (lime_graphics_console_VertexBuffer().default)();
+	},
+	lookupShader: function(name) {
+		return new (lime_graphics_console_Shader().default)();
+	},
+	clear: function(r,g,b,a,depth,stencil) {
+		if(stencil == null) {
+			stencil = 0;
+		}
+		if(depth == null) {
+			depth = 1.0;
+		}
+	},
+	bindShader: function(shader) {
+	},
+	setViewport: function(x,y,width,height,nearPlane,farPlane) {
+		if(farPlane == null) {
+			farPlane = 1.0;
+		}
+		if(nearPlane == null) {
+			nearPlane = 0.0;
+		}
+	},
+	setVertexShaderConstantF: function(startRegister,vec4,vec4count) {
+	},
+	setVertexSource: function(vb) {
+	},
+	setIndexSource: function(ib) {
+	},
+	draw: function(primitive,startVertex,primitiveCount) {
+	},
+	drawIndexed: function(primitive,vertexCount,startIndex,primitiveCount) {
+	},
+	get_width: function() {
+		return 0;
+	},
+	get_height: function() {
+		return 0;
+	}
+};
+ConsoleRenderContext.prototype.__class__ = $hxClasses["lime.graphics.ConsoleRenderContext"] = ConsoleRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ConsoleRenderContext;

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

@@ -0,0 +1,154 @@
+// Class: lime.graphics.FlashRenderContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Constructor
+
+var FlashRenderContext = function() {
+}
+
+// Meta
+
+FlashRenderContext.__name__ = ["lime","graphics","FlashRenderContext"];
+FlashRenderContext.prototype = {
+	addChild: function(child) {
+		return null;
+	},
+	addChildAt: function(child,index) {
+		return null;
+	},
+	addEventListener: function(type,listener,useCapture,priority,useWeakReference) {
+		if(useWeakReference == null) {
+			useWeakReference = false;
+		}
+		if(priority == null) {
+			priority = 0;
+		}
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	areInaccessibleObjectsUnderPoint: function(point) {
+		return false;
+	},
+	contains: function(child) {
+		return false;
+	},
+	dispatchEvent: function(event) {
+		return false;
+	},
+	getBounds: function(targetCoordinateSpace) {
+		return null;
+	},
+	getChildAt: function(index) {
+		return null;
+	},
+	getChildByName: function(name) {
+		return null;
+	},
+	getChildIndex: function(child) {
+		return 0;
+	},
+	getObjectsUnderPoint: function(point) {
+		return null;
+	},
+	getRect: function(targetCoordinateSpace) {
+		return null;
+	},
+	globalToLocal: function(point) {
+		return null;
+	},
+	globalToLocal3D: function(point) {
+		return null;
+	},
+	hasEventListener: function(type) {
+		return false;
+	},
+	hitTestObject: function(obj) {
+		return false;
+	},
+	hitTestPoint: function(x,y,shapeFlag) {
+		if(shapeFlag == null) {
+			shapeFlag = false;
+		}
+		return false;
+	},
+	local3DToGlobal: function(point3d) {
+		return null;
+	},
+	localToGlobal: function(point) {
+		return null;
+	},
+	removeChild: function(child) {
+		return null;
+	},
+	removeChildAt: function(index) {
+		return null;
+	},
+	removeChildren: function(beginIndex,endIndex) {
+		if(endIndex == null) {
+			endIndex = 2147483647;
+		}
+		if(beginIndex == null) {
+			beginIndex = 0;
+		}
+	},
+	removeEventListener: function(type,listener,useCapture) {
+		if(useCapture == null) {
+			useCapture = false;
+		}
+	},
+	requestSoftKeyboard: function() {
+		return false;
+	},
+	setChildIndex: function(child,index) {
+	},
+	startDrag: function(lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	startTouchDrag: function(touchPointID,lockCenter,bounds) {
+		if(lockCenter == null) {
+			lockCenter = false;
+		}
+	},
+	stopAllMovieClips: function() {
+	},
+	stopDrag: function() {
+	},
+	stopTouchDrag: function(touchPointID) {
+	},
+	swapChildren: function(child1,child2) {
+	},
+	swapChildrenAt: function(index1,index2) {
+	},
+	toString: function() {
+		return null;
+	},
+	willTrigger: function(type) {
+		return false;
+	}
+};
+FlashRenderContext.prototype.__class__ = $hxClasses["lime.graphics.FlashRenderContext"] = FlashRenderContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = FlashRenderContext;