First commit

hGameTest/node_modules/openfl/lib/_gen/lime/utils/AssetCache.js

@@ -0,0 +1,119 @@
+// Class: lime.utils.AssetCache
+
+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 lime_graphics_Image() {return require("./../../lime/graphics/Image");}
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+function lime_media_AudioBuffer() {return require("./../../lime/media/AudioBuffer");}
+function haxe_ds_StringMap() {return require("./../../haxe/ds/StringMap");}
+function StringTools() {return require("./../../StringTools");}
+
+// Constructor
+
+var AssetCache = function() {
+	this.enabled = true;
+	this.audio = new (haxe_ds_StringMap().default)();
+	this.font = new (haxe_ds_StringMap().default)();
+	this.image = new (haxe_ds_StringMap().default)();
+	this.version = 0;
+}
+
+// Meta
+
+AssetCache.__name__ = ["lime","utils","AssetCache"];
+AssetCache.prototype = {
+	exists: function(id,type) {
+		if(type == "IMAGE" || type == null) {
+			if(this.image.exists(id)) {
+				return true;
+			}
+		}
+		if(type == "FONT" || type == null) {
+			if(this.font.exists(id)) {
+				return true;
+			}
+		}
+		if(type == "SOUND" || type == "MUSIC" || type == null) {
+			if(this.audio.exists(id)) {
+				return true;
+			}
+		}
+		return false;
+	},
+	set: function(id,type,asset) {
+		switch(type) {
+		case "FONT":
+			this.font.set(id,asset);
+			break;
+		case "IMAGE":
+			if(!(Std().default)["is"](asset,(lime_graphics_Image().default))) {
+				throw new (js__$Boot_HaxeError().default)("Cannot cache non-Image asset: " + (Std().default).string(asset) + " as Image");
+			}
+			this.image.set(id,asset);
+			break;
+		case "MUSIC":case "SOUND":
+			if(!(Std().default)["is"](asset,(lime_media_AudioBuffer().default))) {
+				throw new (js__$Boot_HaxeError().default)("Cannot cache non-AudioBuffer asset: " + (Std().default).string(asset) + " as AudioBuffer");
+			}
+			this.audio.set(id,asset);
+			break;
+		default:
+			throw new (js__$Boot_HaxeError().default)(type + " assets are not cachable");
+		}
+	},
+	clear: function(prefix) {
+		if(prefix == null) {
+			this.audio = new (haxe_ds_StringMap().default)();
+			this.font = new (haxe_ds_StringMap().default)();
+			this.image = new (haxe_ds_StringMap().default)();
+		} else {
+			var keys = this.audio.keys();
+			var key = keys;
+			while(key.hasNext()) {
+				var key1 = key.next();
+				if((StringTools().default).startsWith(key1,prefix)) {
+					this.audio.remove(key1);
+				}
+			}
+			var keys1 = this.font.keys();
+			var key2 = keys1;
+			while(key2.hasNext()) {
+				var key3 = key2.next();
+				if((StringTools().default).startsWith(key3,prefix)) {
+					this.font.remove(key3);
+				}
+			}
+			var keys2 = this.image.keys();
+			var key4 = keys2;
+			while(key4.hasNext()) {
+				var key5 = key4.next();
+				if((StringTools().default).startsWith(key5,prefix)) {
+					this.image.remove(key5);
+				}
+			}
+		}
+	}
+};
+AssetCache.prototype.__class__ = $hxClasses["lime.utils.AssetCache"] = AssetCache;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = AssetCache;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/AssetLibrary.js

@@ -0,0 +1,587 @@
+// Class: lime.utils.AssetLibrary
+
+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_Boot() {return require("./../../js/Boot");}
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+function lime_media_AudioBuffer() {return require("./../../lime/media/AudioBuffer");}
+function Type() {return require("./../../Type");}
+function haxe_io_Bytes() {return require("./../../haxe/io/Bytes");}
+function lime_utils__$Bytes_Bytes_$Impl_$() {return require("./../../lime/utils/_Bytes/Bytes_Impl_");}
+function lime_text_Font() {return require("./../../lime/text/Font");}
+function lime_graphics_Image() {return require("./../../lime/graphics/Image");}
+function lime_app_Future() {return require("./../../lime/app/Future");}
+function lime_app_Promise() {return require("./../../lime/app/Promise");}
+function haxe_ds_StringMap() {return require("./../../haxe/ds/StringMap");}
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+function lime_net__$HTTPRequest_$String() {return require("./../../lime/net/_HTTPRequest_String");}
+function Reflect() {return require("./../../Reflect");}
+function Std() {return require("./../../Std");}
+function lime_utils_AssetManifest() {return require("./../../lime/utils/AssetManifest");}
+function lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+
+// Constructor
+
+var AssetLibrary = function() {
+	this.types = new (haxe_ds_StringMap().default)();
+	this.sizes = new (haxe_ds_StringMap().default)();
+	this.preload = new (haxe_ds_StringMap().default)();
+	this.paths = new (haxe_ds_StringMap().default)();
+	this.pathGroups = new (haxe_ds_StringMap().default)();
+	this.classTypes = new (haxe_ds_StringMap().default)();
+	this.cachedText = new (haxe_ds_StringMap().default)();
+	this.cachedImages = new (haxe_ds_StringMap().default)();
+	this.cachedFonts = new (haxe_ds_StringMap().default)();
+	this.cachedBytes = new (haxe_ds_StringMap().default)();
+	this.cachedAudioBuffers = new (haxe_ds_StringMap().default)();
+	this.onChange = new (lime_app__$Event_$Void_$Void().default)();
+	this.bytesLoaded = 0;
+	this.bytesTotal = 0;
+}
+
+// Meta
+
+AssetLibrary.__name__ = ["lime","utils","AssetLibrary"];
+AssetLibrary.prototype = {
+	exists: function(id,type) {
+		var requestedType = type != null ? (js_Boot().default).__cast(type , String) : null;
+		var assetType = this.types.get(id);
+		if(assetType != null) {
+			if(assetType == requestedType || (requestedType == "SOUND" || requestedType == "MUSIC") && (assetType == "MUSIC" || assetType == "SOUND")) {
+				return true;
+			}
+			if(requestedType == "BINARY" || requestedType == null || assetType == "BINARY" && requestedType == "TEXT") {
+				return true;
+			}
+		}
+		return false;
+	},
+	getAsset: function(id,type) {
+		switch(type) {
+		case "BINARY":
+			return this.getBytes(id);
+		case "FONT":
+			return this.getFont(id);
+		case "IMAGE":
+			return this.getImage(id);
+		case "MUSIC":case "SOUND":
+			return this.getAudioBuffer(id);
+		case "TEMPLATE":
+			throw new (js__$Boot_HaxeError().default)("Not sure how to get template: " + id);
+			break;
+		case "TEXT":
+			return this.getText(id);
+		default:
+			throw new (js__$Boot_HaxeError().default)("Unknown asset type: " + type);
+		}
+	},
+	getAudioBuffer: function(id) {
+		if(this.cachedAudioBuffers.exists(id)) {
+			return this.cachedAudioBuffers.get(id);
+		} else if(this.classTypes.exists(id)) {
+			return (lime_media_AudioBuffer().default).fromBytes((js_Boot().default).__cast((Type().default).createInstance(this.classTypes.get(id),[]) , (haxe_io_Bytes().default)));
+		} else {
+			return (lime_media_AudioBuffer().default).fromFile(this.paths.get(id));
+		}
+	},
+	getBytes: function(id) {
+		if(this.cachedBytes.exists(id)) {
+			return this.cachedBytes.get(id);
+		} else if(this.cachedText.exists(id)) {
+			var bytes = (lime_utils__$Bytes_Bytes_$Impl_$().default).ofString(this.cachedText.get(id));
+			this.cachedBytes.set(id,bytes);
+			return bytes;
+		} else if(this.classTypes.exists(id)) {
+			return (js_Boot().default).__cast((Type().default).createInstance(this.classTypes.get(id),[]) , (haxe_io_Bytes().default));
+		} else {
+			return (lime_utils__$Bytes_Bytes_$Impl_$().default).fromFile(this.paths.get(id));
+		}
+	},
+	getFont: function(id) {
+		if(this.cachedFonts.exists(id)) {
+			return this.cachedFonts.get(id);
+		} else if(this.classTypes.exists(id)) {
+			return (js_Boot().default).__cast((Type().default).createInstance(this.classTypes.get(id),[]) , (lime_text_Font().default));
+		} else {
+			return (lime_text_Font().default).fromFile(this.paths.get(id));
+		}
+	},
+	getImage: function(id) {
+		if(this.cachedImages.exists(id)) {
+			return this.cachedImages.get(id);
+		} else if(this.classTypes.exists(id)) {
+			return (js_Boot().default).__cast((Type().default).createInstance(this.classTypes.get(id),[]) , (lime_graphics_Image().default));
+		} else {
+			return (lime_graphics_Image().default).fromFile(this.paths.get(id));
+		}
+	},
+	getPath: function(id) {
+		return this.paths.get(id);
+	},
+	getText: function(id) {
+		if(this.cachedText.exists(id)) {
+			return this.cachedText.get(id);
+		} else {
+			var bytes = this.getBytes(id);
+			if(bytes == null) {
+				return null;
+			} else {
+				return bytes.getString(0,bytes.get_length());
+			}
+		}
+	},
+	isLocal: function(id,type) {
+		if(this.classTypes.exists(id)) {
+			return true;
+		}
+		var requestedType = type != null ? (js_Boot().default).__cast(type , String) : null;
+		switch(requestedType) {
+		case "FONT":
+			return this.cachedFonts.exists(id);
+		case "IMAGE":
+			return this.cachedImages.exists(id);
+		case "MUSIC":case "SOUND":
+			return this.cachedAudioBuffers.exists(id);
+		default:
+			if(!this.cachedBytes.exists(id)) {
+				return this.cachedText.exists(id);
+			} else {
+				return true;
+			}
+		}
+	},
+	list: function(type) {
+		var requestedType = type != null ? (js_Boot().default).__cast(type , String) : null;
+		var items = [];
+		var id = this.types.keys();
+		while(id.hasNext()) {
+			var id1 = id.next();
+			if(requestedType == null || this.exists(id1,type)) {
+				items.push(id1);
+			}
+		}
+		return items;
+	},
+	loadAsset: function(id,type) {
+		switch(type) {
+		case "BINARY":
+			return this.loadBytes(id);
+		case "FONT":
+			return this.loadFont(id);
+		case "IMAGE":
+			return this.loadImage(id);
+		case "MUSIC":case "SOUND":
+			return this.loadAudioBuffer(id);
+		case "TEMPLATE":
+			throw new (js__$Boot_HaxeError().default)("Not sure how to load template: " + id);
+			break;
+		case "TEXT":
+			return this.loadText(id);
+		default:
+			throw new (js__$Boot_HaxeError().default)("Unknown asset type: " + type);
+		}
+	},
+	load: function() {
+		if(this.loaded) {
+			return (lime_app_Future().default).withValue(this);
+		}
+		if(this.promise == null) {
+			this.promise = new (lime_app_Promise().default)();
+			this.bytesLoadedCache = new (haxe_ds_StringMap().default)();
+			this.assetsLoaded = 0;
+			this.assetsTotal = 1;
+			var id = this.preload.keys();
+			while(id.hasNext()) {
+				var id1 = id.next();
+				if(!this.preload.get(id1)) {
+					continue;
+				}
+				(lime_utils_Log().default).verbose("Preloading asset: " + id1 + " [" + this.types.get(id1) + "]",{ fileName : "AssetLibrary.hx", lineNumber : 440, className : "lime.utils.AssetLibrary", methodName : "load"});
+				var _g = this.types.get(id1);
+				if(_g != null) {
+					switch(_g) {
+					case "BINARY":
+						this.assetsTotal++;
+						var future = this.loadBytes(id1);
+						future.onProgress((function(id2,f) {
+							return function(a1,a2) {
+								f[0](id2[0],a1,a2);
+							};
+						})([id1],[$bind(this,this.load_onProgress)]));
+						future.onError((function(id3,f1) {
+							return function(a11) {
+								f1[0](id3[0],a11);
+							};
+						})([id1],[$bind(this,this.load_onError)]));
+						future.onComplete((function(id4,f2) {
+							return function(a12) {
+								f2[0](id4[0],a12);
+							};
+						})([id1],[$bind(this,this.loadBytes_onComplete)]));
+						break;
+					case "FONT":
+						this.assetsTotal++;
+						var future1 = this.loadFont(id1);
+						future1.onProgress((function(id5,f3) {
+							return function(a13,a21) {
+								f3[0](id5[0],a13,a21);
+							};
+						})([id1],[$bind(this,this.load_onProgress)]));
+						future1.onError((function(id6,f4) {
+							return function(a14) {
+								f4[0](id6[0],a14);
+							};
+						})([id1],[$bind(this,this.load_onError)]));
+						future1.onComplete((function(id7,f5) {
+							return function(a15) {
+								f5[0](id7[0],a15);
+							};
+						})([id1],[$bind(this,this.loadFont_onComplete)]));
+						break;
+					case "IMAGE":
+						this.assetsTotal++;
+						var future2 = this.loadImage(id1);
+						future2.onProgress((function(id8,f6) {
+							return function(a16,a22) {
+								f6[0](id8[0],a16,a22);
+							};
+						})([id1],[$bind(this,this.load_onProgress)]));
+						future2.onError((function(id9,f7) {
+							return function(a17) {
+								f7[0](id9[0],a17);
+							};
+						})([id1],[$bind(this,this.load_onError)]));
+						future2.onComplete((function(id10,f8) {
+							return function(a18) {
+								f8[0](id10[0],a18);
+							};
+						})([id1],[$bind(this,this.loadImage_onComplete)]));
+						break;
+					case "MUSIC":case "SOUND":
+						this.assetsTotal++;
+						var future3 = this.loadAudioBuffer(id1);
+						future3.onProgress((function(id11,f9) {
+							return function(a19,a23) {
+								f9[0](id11[0],a19,a23);
+							};
+						})([id1],[$bind(this,this.load_onProgress)]));
+						future3.onError((function(id12,f10) {
+							return function(a110) {
+								f10[0](id12[0],a110);
+							};
+						})([id1],[$bind(this,this.load_onError)]));
+						future3.onComplete((function(id13,f11) {
+							return function(a111) {
+								f11[0](id13[0],a111);
+							};
+						})([id1],[$bind(this,this.loadAudioBuffer_onComplete)]));
+						break;
+					case "TEXT":
+						this.assetsTotal++;
+						var future4 = this.loadText(id1);
+						future4.onProgress((function(id14,f12) {
+							return function(a112,a24) {
+								f12[0](id14[0],a112,a24);
+							};
+						})([id1],[$bind(this,this.load_onProgress)]));
+						future4.onError((function(id15,f13) {
+							return function(a113) {
+								f13[0](id15[0],a113);
+							};
+						})([id1],[$bind(this,this.load_onError)]));
+						future4.onComplete((function(id16,f14) {
+							return function(a114) {
+								f14[0](id16[0],a114);
+							};
+						})([id1],[$bind(this,this.loadText_onComplete)]));
+						break;
+					default:
+					}
+				}
+			}
+			this.__assetLoaded(null);
+		}
+		return this.promise.future;
+	},
+	loadAudioBuffer: function(id) {
+		if(this.cachedAudioBuffers.exists(id)) {
+			return (lime_app_Future().default).withValue(this.cachedAudioBuffers.get(id));
+		} else if(this.classTypes.exists(id)) {
+			return (lime_app_Future().default).withValue((Type().default).createInstance(this.classTypes.get(id),[]));
+		} else if(this.pathGroups.exists(id)) {
+			return (lime_media_AudioBuffer().default).loadFromFiles(this.pathGroups.get(id));
+		} else {
+			return (lime_media_AudioBuffer().default).loadFromFile(this.paths.get(id));
+		}
+	},
+	loadBytes: function(id) {
+		if(this.cachedBytes.exists(id)) {
+			return (lime_app_Future().default).withValue(this.cachedBytes.get(id));
+		} else if(this.classTypes.exists(id)) {
+			return (lime_app_Future().default).withValue((Type().default).createInstance(this.classTypes.get(id),[]));
+		} else {
+			return (lime_utils__$Bytes_Bytes_$Impl_$().default).loadFromFile(this.paths.get(id));
+		}
+	},
+	loadFont: function(id) {
+		if(this.cachedFonts.exists(id)) {
+			return (lime_app_Future().default).withValue(this.cachedFonts.get(id));
+		} else if(this.classTypes.exists(id)) {
+			var font = (Type().default).createInstance(this.classTypes.get(id),[]);
+			return font.__loadFromName(font.name);
+		} else {
+			return (lime_text_Font().default).loadFromName(this.paths.get(id));
+		}
+	},
+	loadImage: function(id) {
+		if(this.cachedImages.exists(id)) {
+			return (lime_app_Future().default).withValue(this.cachedImages.get(id));
+		} else if(this.classTypes.exists(id)) {
+			return (lime_app_Future().default).withValue((Type().default).createInstance(this.classTypes.get(id),[]));
+		} else {
+			return (lime_graphics_Image().default).loadFromFile(this.paths.get(id));
+		}
+	},
+	loadText: function(id) {
+		if(this.cachedText.exists(id)) {
+			return (lime_app_Future().default).withValue(this.cachedText.get(id));
+		} else if(this.cachedBytes.exists(id) || this.classTypes.exists(id)) {
+			var bytes = this.getBytes(id);
+			if(bytes == null) {
+				return (lime_app_Future().default).withValue(null);
+			} else {
+				var text = bytes.getString(0,bytes.get_length());
+				this.cachedText.set(id,text);
+				return (lime_app_Future().default).withValue(text);
+			}
+		} else {
+			var request = new (lime_net__$HTTPRequest_$String().default)();
+			return request.load(this.paths.get(id));
+		}
+	},
+	unload: function() {
+	},
+	__assetLoaded: function(id) {
+		this.assetsLoaded++;
+		if(id != null) {
+			(lime_utils_Log().default).verbose("Loaded asset: " + id + " [" + this.types.get(id) + "] (" + (this.assetsLoaded - 1) + "/" + (this.assetsTotal - 1) + ")",{ fileName : "AssetLibrary.hx", lineNumber : 686, className : "lime.utils.AssetLibrary", methodName : "__assetLoaded"});
+		}
+		if(id != null) {
+			var size = this.sizes.get(id);
+			if(!this.bytesLoadedCache.exists(id)) {
+				this.bytesLoaded += size;
+			} else {
+				var cache = this.bytesLoadedCache.get(id);
+				if(cache < size) {
+					this.bytesLoaded += size - cache;
+				}
+			}
+			this.bytesLoadedCache.set(id,size);
+		}
+		if(this.assetsLoaded < this.assetsTotal) {
+			this.promise.progress(this.bytesLoaded,this.bytesTotal);
+		} else {
+			this.loaded = true;
+			this.promise.progress(this.bytesTotal,this.bytesTotal);
+			this.promise.complete(this);
+		}
+	},
+	__cacheBreak: function(path) {
+		return path;
+	},
+	__fromManifest: function(manifest) {
+		var hasSize = manifest.version >= 2;
+		var size;
+		var id;
+		var pathGroup;
+		var classRef;
+		var basePath = manifest.rootPath;
+		if(basePath == null) {
+			basePath = "";
+		}
+		if(basePath != "") {
+			basePath += "/";
+		}
+		var _g = 0;
+		var _g1 = manifest.assets;
+		while(_g < _g1.length) {
+			var asset = _g1[_g];
+			++_g;
+			if(hasSize) {
+				size = asset.size;
+			} else {
+				size = 100;
+			}
+			id = asset.id;
+			if((Reflect().default).hasField(asset,"path")) {
+				this.paths.set(id,this.__cacheBreak(basePath + (Std().default).string((Reflect().default).field(asset,"path"))));
+			}
+			if((Reflect().default).hasField(asset,"pathGroup")) {
+				pathGroup = (Reflect().default).field(asset,"pathGroup");
+				var _g3 = 0;
+				var _g2 = pathGroup.length;
+				while(_g3 < _g2) {
+					var i = _g3++;
+					pathGroup[i] = this.__cacheBreak(basePath + pathGroup[i]);
+				}
+				this.pathGroups.set(id,pathGroup);
+			}
+			this.sizes.set(id,size);
+			this.types.set(id,asset.type);
+			if((Reflect().default).hasField(asset,"preload")) {
+				this.preload.set(id,(Reflect().default).field(asset,"preload"));
+			}
+			if((Reflect().default).hasField(asset,"className")) {
+				classRef = (Type().default).resolveClass((Reflect().default).field(asset,"className"));
+				this.classTypes.set(id,classRef);
+			}
+		}
+		this.bytesTotal = 0;
+		var _g4 = 0;
+		var _g11 = manifest.assets;
+		while(_g4 < _g11.length) {
+			var asset1 = _g11[_g4];
+			++_g4;
+			id = asset1.id;
+			if(this.preload.exists(id) && this.preload.get(id)) {
+				this.bytesTotal += this.sizes.get(id);
+			}
+		}
+	},
+	loadAudioBuffer_onComplete: function(id,audioBuffer) {
+		this.cachedAudioBuffers.set(id,audioBuffer);
+		if(this.pathGroups.exists(id)) {
+			var pathGroup = this.pathGroups.get(id);
+			var otherID = this.pathGroups.keys();
+			while(otherID.hasNext()) {
+				var otherID1 = otherID.next();
+				if(otherID1 == id) {
+					continue;
+				}
+				var _g = 0;
+				while(_g < pathGroup.length) {
+					var path = pathGroup[_g];
+					++_g;
+					if(this.pathGroups.get(otherID1).indexOf(path) > -1) {
+						this.cachedAudioBuffers.set(otherID1,audioBuffer);
+						break;
+					}
+				}
+			}
+		}
+		this.__assetLoaded(id);
+	},
+	loadBytes_onComplete: function(id,bytes) {
+		this.cachedBytes.set(id,bytes);
+		this.__assetLoaded(id);
+	},
+	loadFont_onComplete: function(id,font) {
+		this.cachedFonts.set(id,font);
+		this.__assetLoaded(id);
+	},
+	loadImage_onComplete: function(id,image) {
+		this.cachedImages.set(id,image);
+		this.__assetLoaded(id);
+	},
+	loadText_onComplete: function(id,text) {
+		this.cachedText.set(id,text);
+		this.__assetLoaded(id);
+	},
+	load_onError: function(id,message) {
+		if(message != null && message != "") {
+			this.promise.error("Error loading asset \"" + id + "\": " + (Std().default).string(message));
+		} else {
+			this.promise.error("Error loading asset \"" + id + "\"");
+		}
+	},
+	load_onProgress: function(id,bytesLoaded,bytesTotal) {
+		if(bytesLoaded > 0) {
+			var size = this.sizes.get(id);
+			var percent;
+			if(bytesTotal > 0) {
+				percent = bytesLoaded / bytesTotal;
+				if(percent > 1) {
+					percent = 1;
+				}
+				bytesLoaded = Math.floor(percent * size);
+			} else if(bytesLoaded > size) {
+				bytesLoaded = size;
+			}
+			if(this.bytesLoadedCache.exists(id)) {
+				var cache = this.bytesLoadedCache.get(id);
+				if(bytesLoaded != cache) {
+					this.bytesLoaded += bytesLoaded - cache;
+				}
+			} else {
+				this.bytesLoaded += bytesLoaded;
+			}
+			this.bytesLoadedCache.set(id,bytesLoaded);
+			this.promise.progress(this.bytesLoaded,this.bytesTotal);
+		}
+	}
+};
+AssetLibrary.prototype.__class__ = $hxClasses["lime.utils.AssetLibrary"] = AssetLibrary;
+
+// Init
+
+
+
+// Statics
+
+AssetLibrary.fromBytes = function(bytes,rootPath) {
+	return AssetLibrary.fromManifest((lime_utils_AssetManifest().default).fromBytes(bytes,rootPath));
+}
+AssetLibrary.fromFile = function(path,rootPath) {
+	return AssetLibrary.fromManifest((lime_utils_AssetManifest().default).fromFile(path,rootPath));
+}
+AssetLibrary.fromManifest = function(manifest) {
+	if(manifest == null) {
+		return null;
+	}
+	var library = null;
+	if(manifest.libraryType == null) {
+		library = new AssetLibrary();
+	} else {
+		var libraryClass = (Type().default).resolveClass(manifest.libraryType);
+		if(libraryClass != null) {
+			library = (Type().default).createInstance(libraryClass,manifest.libraryArgs);
+		} else {
+			(lime_utils_Log().default).warn("Could not find library type: " + manifest.libraryType,{ fileName : "AssetLibrary.hx", lineNumber : 140, className : "lime.utils.AssetLibrary", methodName : "fromManifest"});
+			return null;
+		}
+	}
+	library.__fromManifest(manifest);
+	return library;
+}
+AssetLibrary.loadFromBytes = function(bytes,rootPath) {
+	return (lime_utils_AssetManifest().default).loadFromBytes(bytes,rootPath).then(function(manifest) {
+		return AssetLibrary.loadFromManifest(manifest);
+	});
+}
+AssetLibrary.loadFromFile = function(path,rootPath) {
+	return (lime_utils_AssetManifest().default).loadFromFile(path,rootPath).then(function(manifest) {
+		return AssetLibrary.loadFromManifest(manifest);
+	});
+}
+AssetLibrary.loadFromManifest = function(manifest) {
+	var library = AssetLibrary.fromManifest(manifest);
+	if(library != null) {
+		return library.load();
+	} else {
+		return (lime_app_Future().default).withError("Could not load asset manifest");
+	}
+}
+
+
+// Export
+
+exports.default = AssetLibrary;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/AssetManifest.js

@@ -0,0 +1,144 @@
+// Class: lime.utils.AssetManifest
+
+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_Serializer() {return require("./../../haxe/Serializer");}
+function lime_utils__$Bytes_Bytes_$Impl_$() {return require("./../../lime/utils/_Bytes/Bytes_Impl_");}
+function lime_app_Future() {return require("./../../lime/app/Future");}
+function haxe_Unserializer() {return require("./../../haxe/Unserializer");}
+function HxOverrides() {return require("./../../HxOverrides");}
+function StringTools() {return require("./../../StringTools");}
+function haxe_io_Path() {return require("./../../haxe/io/Path");}
+
+// Constructor
+
+var AssetManifest = function() {
+	this.assets = [];
+	this.libraryArgs = [];
+	this.version = 2;
+}
+
+// Meta
+
+AssetManifest.__name__ = ["lime","utils","AssetManifest"];
+AssetManifest.prototype = {
+	serialize: function() {
+		var manifestData = { };
+		manifestData.version = this.version;
+		manifestData.libraryType = this.libraryType;
+		manifestData.libraryArgs = this.libraryArgs;
+		manifestData.name = this.name;
+		manifestData.assets = (haxe_Serializer().default).run(this.assets);
+		return JSON.stringify(manifestData);
+	}
+};
+AssetManifest.prototype.__class__ = $hxClasses["lime.utils.AssetManifest"] = AssetManifest;
+
+// Init
+
+
+
+// Statics
+
+AssetManifest.fromBytes = function(bytes,rootPath) {
+	if(bytes != null) {
+		return AssetManifest.parse(bytes.getString(0,bytes.get_length()),rootPath);
+	} else {
+		return null;
+	}
+}
+AssetManifest.fromFile = function(path,rootPath) {
+	path = AssetManifest.__resolvePath(path);
+	rootPath = AssetManifest.__resolveRootPath(rootPath,path);
+	if(path == null) {
+		return null;
+	}
+	return AssetManifest.fromBytes((lime_utils__$Bytes_Bytes_$Impl_$().default).fromFile(path),rootPath);
+}
+AssetManifest.loadFromBytes = function(bytes,rootPath) {
+	return (lime_app_Future().default).withValue(AssetManifest.fromBytes(bytes,rootPath));
+}
+AssetManifest.loadFromFile = function(path,rootPath) {
+	path = AssetManifest.__resolvePath(path);
+	rootPath = AssetManifest.__resolveRootPath(rootPath,path);
+	if(path == null) {
+		return null;
+	}
+	return (lime_utils__$Bytes_Bytes_$Impl_$().default).loadFromFile(path).then(function(bytes) {
+		return (lime_app_Future().default).withValue(AssetManifest.fromBytes(bytes,rootPath));
+	});
+}
+AssetManifest.parse = function(data,rootPath) {
+	if(data == null || data == "") {
+		return null;
+	}
+	var manifestData = JSON.parse(data);
+	var manifest = new AssetManifest();
+	manifest.name = manifestData.name;
+	manifest.libraryType = manifestData.libraryType;
+	manifest.libraryArgs = manifestData.libraryArgs;
+	manifest.assets = (haxe_Unserializer().default).run(manifestData.assets);
+	if(rootPath != null) {
+		manifest.rootPath = rootPath;
+	}
+	return manifest;
+}
+AssetManifest.__resolvePath = function(path) {
+	if(path == null) {
+		return null;
+	}
+	var queryIndex = path.indexOf("?");
+	var basePath;
+	if(queryIndex > -1) {
+		basePath = (HxOverrides().default).substr(path,0,queryIndex);
+	} else {
+		basePath = path;
+	}
+	(StringTools().default).replace(basePath,"\\","/");
+	while((StringTools().default).endsWith(basePath,"/")) basePath = (HxOverrides().default).substr(basePath,0,basePath.length - 1);
+	if((StringTools().default).endsWith(basePath,".bundle")) {
+		if(queryIndex > -1) {
+			return basePath + "/library.json" + (HxOverrides().default).substr(path,queryIndex,null);
+		} else {
+			return basePath + "/library.json";
+		}
+	} else {
+		return path;
+	}
+}
+AssetManifest.__resolveRootPath = function(rootPath,path) {
+	if(rootPath != null) {
+		return rootPath;
+	}
+	var queryIndex = path.indexOf("?");
+	if(queryIndex > -1) {
+		rootPath = (HxOverrides().default).substr(path,0,queryIndex);
+	} else {
+		rootPath = path;
+	}
+	(StringTools().default).replace(rootPath,"\\","/");
+	while((StringTools().default).endsWith(rootPath,"/")) {
+		if(rootPath == "/") {
+			return rootPath;
+		}
+		rootPath = (HxOverrides().default).substr(rootPath,0,rootPath.length - 1);
+	}
+	if((StringTools().default).endsWith(rootPath,".bundle")) {
+		return rootPath;
+	} else {
+		return (haxe_io_Path().default).directory(rootPath);
+	}
+}
+
+
+// Export
+
+exports.default = AssetManifest;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/Assets.js

@@ -0,0 +1,341 @@
+// Class: lime.utils.Assets
+
+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_AssetCache() {return require("./../../lime/utils/AssetCache");}
+function lime_app__$Event_$Void_$Void() {return require("./../../lime/app/_Event_Void_Void");}
+function haxe_ds_StringMap() {return require("./../../haxe/ds/StringMap");}
+function lime_utils__$Assets_LibrarySymbol() {return require("./../../lime/utils/_Assets/LibrarySymbol");}
+function js__$Boot_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+function lime_app_Future() {return require("./../../lime/app/Future");}
+function lime_app_Promise() {return require("./../../lime/app/Promise");}
+function StringTools() {return require("./../../StringTools");}
+function lime_utils_AssetManifest() {return require("./../../lime/utils/AssetManifest");}
+function lime_utils_AssetLibrary() {return require("./../../lime/utils/AssetLibrary");}
+function lime_app_Application() {return require("./../../lime/app/Application");}
+
+// Constructor
+
+var Assets = function(){}
+
+// Meta
+
+Assets.__name__ = ["lime","utils","Assets"];
+Assets.prototype = {
+	
+};
+Assets.prototype.__class__ = $hxClasses["lime.utils.Assets"] = Assets;
+
+// Init
+
+
+
+// Statics
+
+Assets.exists = function(id,type) {
+	if(type == null) {
+		type = "BINARY";
+	}
+	var symbol = new (lime_utils__$Assets_LibrarySymbol().default)(id);
+	if(symbol.library != null) {
+		return symbol.exists(type);
+	}
+	return false;
+}
+Assets.getAsset = function(id,type,useCache) {
+	if(useCache && Assets.cache.enabled) {
+		switch(type) {
+		case "BINARY":case "TEXT":
+			useCache = false;
+			break;
+		case "FONT":
+			var font = Assets.cache.font.get(id);
+			if(font != null) {
+				return font;
+			}
+			break;
+		case "IMAGE":
+			var image = Assets.cache.image.get(id);
+			if(Assets.isValidImage(image)) {
+				return image;
+			}
+			break;
+		case "MUSIC":case "SOUND":
+			var audio = Assets.cache.audio.get(id);
+			if(Assets.isValidAudio(audio)) {
+				return audio;
+			}
+			break;
+		case "TEMPLATE":
+			throw new (js__$Boot_HaxeError().default)("Not sure how to get template: " + id);
+			break;
+		default:
+			return null;
+		}
+	}
+	var symbol = new (lime_utils__$Assets_LibrarySymbol().default)(id);
+	if(symbol.library != null) {
+		if(symbol.exists(type)) {
+			if(symbol.isLocal(type)) {
+				var asset = symbol.library.getAsset(symbol.symbolName,type);
+				if(useCache && Assets.cache.enabled) {
+					Assets.cache.set(id,type,asset);
+				}
+				return asset;
+			} else {
+				(lime_utils_Log().default).error(type + " asset \"" + id + "\" exists, but only asynchronously",{ fileName : "Assets.hx", lineNumber : 160, className : "lime.utils.Assets", methodName : "getAsset"});
+			}
+		} else {
+			(lime_utils_Log().default).error("There is no " + type + " asset with an ID of \"" + id + "\"",{ fileName : "Assets.hx", lineNumber : 166, className : "lime.utils.Assets", methodName : "getAsset"});
+		}
+	} else {
+		(lime_utils_Log().default).error(Assets.__libraryNotFound(symbol.libraryName),{ fileName : "Assets.hx", lineNumber : 172, className : "lime.utils.Assets", methodName : "getAsset"});
+	}
+	return null;
+}
+Assets.getAudioBuffer = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.getAsset(id,"SOUND",useCache);
+}
+Assets.getBytes = function(id) {
+	return Assets.getAsset(id,"BINARY",false);
+}
+Assets.getFont = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.getAsset(id,"FONT",useCache);
+}
+Assets.getImage = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.getAsset(id,"IMAGE",useCache);
+}
+Assets.getLibrary = function(name) {
+	if(name == null || name == "") {
+		name = "default";
+	}
+	return Assets.libraries.get(name);
+}
+Assets.getPath = function(id) {
+	var symbol = new (lime_utils__$Assets_LibrarySymbol().default)(id);
+	if(symbol.library != null) {
+		if(symbol.exists()) {
+			return symbol.library.getPath(symbol.symbolName);
+		} else {
+			(lime_utils_Log().default).error("There is no asset with an ID of \"" + id + "\"",{ fileName : "Assets.hx", lineNumber : 269, className : "lime.utils.Assets", methodName : "getPath"});
+		}
+	} else {
+		(lime_utils_Log().default).error(Assets.__libraryNotFound(symbol.libraryName),{ fileName : "Assets.hx", lineNumber : 275, className : "lime.utils.Assets", methodName : "getPath"});
+	}
+	return null;
+}
+Assets.getText = function(id) {
+	return Assets.getAsset(id,"TEXT",false);
+}
+Assets.hasLibrary = function(name) {
+	if(name == null || name == "") {
+		name = "default";
+	}
+	return Assets.libraries.exists(name);
+}
+Assets.isLocal = function(id,type,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	if(useCache && Assets.cache.enabled) {
+		if(Assets.cache.exists(id,type)) {
+			return true;
+		}
+	}
+	var symbol = new (lime_utils__$Assets_LibrarySymbol().default)(id);
+	if(symbol.library != null) {
+		return symbol.isLocal(type);
+	} else {
+		return false;
+	}
+}
+Assets.isValidAudio = function(buffer) {
+	return buffer != null;
+}
+Assets.isValidImage = function(image) {
+	if(image != null) {
+		return image.buffer != null;
+	} else {
+		return false;
+	}
+}
+Assets.list = function(type) {
+	var items = [];
+	var library = Assets.libraries.iterator();
+	while(library.hasNext()) {
+		var library1 = library.next();
+		var libraryItems = library1.list(type);
+		if(libraryItems != null) {
+			items = items.concat(libraryItems);
+		}
+	}
+	return items;
+}
+Assets.loadAsset = function(id,type,useCache) {
+	if(useCache && Assets.cache.enabled) {
+		switch(type) {
+		case "BINARY":case "TEXT":
+			useCache = false;
+			break;
+		case "FONT":
+			var font = Assets.cache.font.get(id);
+			if(font != null) {
+				return (lime_app_Future().default).withValue(font);
+			}
+			break;
+		case "IMAGE":
+			var image = Assets.cache.image.get(id);
+			if(Assets.isValidImage(image)) {
+				return (lime_app_Future().default).withValue(image);
+			}
+			break;
+		case "MUSIC":case "SOUND":
+			var audio = Assets.cache.audio.get(id);
+			if(Assets.isValidAudio(audio)) {
+				return (lime_app_Future().default).withValue(audio);
+			}
+			break;
+		case "TEMPLATE":
+			throw new (js__$Boot_HaxeError().default)("Not sure how to get template: " + id);
+			break;
+		default:
+			return null;
+		}
+	}
+	var symbol = new (lime_utils__$Assets_LibrarySymbol().default)(id);
+	if(symbol.library != null) {
+		if(symbol.exists(type)) {
+			var future = symbol.library.loadAsset(symbol.symbolName,type);
+			if(useCache && Assets.cache.enabled) {
+				future.onComplete(function(asset) {
+					Assets.cache.set(id,type,asset);
+				});
+			}
+			return future;
+		} else {
+			return (lime_app_Future().default).withError("There is no " + type + " asset with an ID of \"" + id + "\"");
+		}
+	} else {
+		return (lime_app_Future().default).withError(Assets.__libraryNotFound(symbol.libraryName));
+	}
+}
+Assets.loadAudioBuffer = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.loadAsset(id,"SOUND",useCache);
+}
+Assets.loadBytes = function(id) {
+	return Assets.loadAsset(id,"BINARY",false);
+}
+Assets.loadFont = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.loadAsset(id,"FONT",useCache);
+}
+Assets.loadImage = function(id,useCache) {
+	if(useCache == null) {
+		useCache = true;
+	}
+	return Assets.loadAsset(id,"IMAGE",useCache);
+}
+Assets.loadLibrary = function(id) {
+	var promise = new (lime_app_Promise().default)();
+	var library = Assets.getLibrary(id);
+	if(library != null) {
+		return library.load();
+	}
+	var path = id;
+	var rootPath = null;
+	if(Assets.libraryPaths.exists(id)) {
+		path = Assets.libraryPaths.get(id);
+		rootPath = Assets.defaultRootPath;
+	} else if((StringTools().default).endsWith(path,".bundle")) {
+		path += "/library.json";
+	}
+	(lime_utils_AssetManifest().default).loadFromFile(path,rootPath).onComplete(function(manifest) {
+		if(manifest == null) {
+			promise.error("Cannot parse asset manifest for library \"" + id + "\"");
+			return;
+		}
+		var library1 = (lime_utils_AssetLibrary().default).fromManifest(manifest);
+		if(library1 == null) {
+			promise.error("Cannot open library \"" + id + "\"");
+		} else {
+			Assets.libraries.set(id,library1);
+			library1.onChange.add(($_=Assets.onChange,$bind($_,$_.dispatch)));
+			var tmp = library1.load();
+			promise.completeWith(tmp);
+		}
+	}).onError(function(_) {
+		promise.error("There is no asset library with an ID of \"" + id + "\"");
+	});
+	return promise.future;
+}
+Assets.loadText = function(id) {
+	return Assets.loadAsset(id,"TEXT",false);
+}
+Assets.registerLibrary = function(name,library) {
+	if(Assets.libraries.exists(name)) {
+		if(Assets.libraries.get(name) == library) {
+			return;
+		} else {
+			Assets.unloadLibrary(name);
+		}
+	}
+	if(library != null) {
+		library.onChange.add(Assets.library_onChange);
+	}
+	Assets.libraries.set(name,library);
+}
+Assets.unloadLibrary = function(name) {
+	var library = Assets.libraries.get(name);
+	if(library != null) {
+		Assets.cache.clear(name + ":");
+		library.onChange.remove(Assets.library_onChange);
+		library.unload();
+	}
+	Assets.libraries.remove(name);
+}
+Assets.__libraryNotFound = function(name) {
+	if(name == null || name == "") {
+		name = "default";
+	}
+	if((lime_app_Application().default).current != null && (lime_app_Application().default).current.get_preloader() != null && !(lime_app_Application().default).current.get_preloader().complete) {
+		return "There is no asset library named \"" + name + "\", or it is not yet preloaded";
+	} else {
+		return "There is no asset library named \"" + name + "\"";
+	}
+}
+Assets.library_onChange = function() {
+	Assets.cache.clear();
+	Assets.onChange.dispatch();
+}
+Assets.cache = new (lime_utils_AssetCache().default)()
+Assets.onChange = new (lime_app__$Event_$Void_$Void().default)()
+Assets.libraries = new (haxe_ds_StringMap().default)()
+Assets.libraryPaths = new (haxe_ds_StringMap().default)()
+
+// Export
+
+exports.default = Assets;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/BytePointerData.js

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

hGameTest/node_modules/openfl/lib/_gen/lime/utils/DataPointerObject.js

@@ -0,0 +1,52 @@
+// Class: lime.utils.DataPointerObject
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_utils_DataPointerObjectType() {return require("./../../lime/utils/DataPointerObjectType");}
+
+// Constructor
+
+var DataPointerObject = function(bufferView,buffer,offset) {
+	if(offset == null) {
+		offset = 0;
+	}
+	if(bufferView != null) {
+		this.bufferView = bufferView;
+		this.type = (lime_utils_DataPointerObjectType().default).BUFFER_VIEW;
+	} else if(buffer != null) {
+		this.buffer = buffer;
+		this.type = (lime_utils_DataPointerObjectType().default).BUFFER;
+	} else {
+		this.type = (lime_utils_DataPointerObjectType().default).VALUE;
+	}
+	this.offset = offset;
+}
+
+// Meta
+
+DataPointerObject.__name__ = ["lime","utils","DataPointerObject"];
+DataPointerObject.prototype = {
+	
+};
+DataPointerObject.prototype.__class__ = $hxClasses["lime.utils.DataPointerObject"] = DataPointerObject;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = DataPointerObject;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/DataPointerObjectType.js

@@ -0,0 +1,29 @@
+// Enum: lime.utils.DataPointerObjectType
+
+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 DataPointerObjectType = $hxClasses["lime.utils.DataPointerObjectType"] = { __ename__: ["lime","utils","DataPointerObjectType"], __constructs__: ["BUFFER","BUFFER_VIEW","VALUE"] }
+
+DataPointerObjectType.VALUE = ["VALUE",2];
+DataPointerObjectType.VALUE.toString = $estr;
+DataPointerObjectType.VALUE.__enum__ = DataPointerObjectType;
+
+DataPointerObjectType.BUFFER = ["BUFFER",0];
+DataPointerObjectType.BUFFER.toString = $estr;
+DataPointerObjectType.BUFFER.__enum__ = DataPointerObjectType;
+
+DataPointerObjectType.BUFFER_VIEW = ["BUFFER_VIEW",1];
+DataPointerObjectType.BUFFER_VIEW.toString = $estr;
+DataPointerObjectType.BUFFER_VIEW.__enum__ = DataPointerObjectType;
+
+
+exports.default = DataPointerObjectType;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/GLUtils.js

@@ -0,0 +1,73 @@
+// Class: lime.utils.GLUtils
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_graphics_opengl_GL() {return require("./../../lime/graphics/opengl/GL");}
+function lime_utils_Log() {return require("./../../lime/utils/Log");}
+
+// Constructor
+
+var GLUtils = function(){}
+
+// Meta
+
+GLUtils.__name__ = ["lime","utils","GLUtils"];
+GLUtils.prototype = {
+	
+};
+GLUtils.prototype.__class__ = $hxClasses["lime.utils.GLUtils"] = GLUtils;
+
+// Init
+
+
+
+// Statics
+
+GLUtils.compileShader = function(source,type) {
+	var shader = (lime_graphics_opengl_GL().default).createShader(type);
+	(lime_graphics_opengl_GL().default).shaderSource(shader,source);
+	(lime_graphics_opengl_GL().default).compileShader(shader);
+	if((lime_graphics_opengl_GL().default).getShaderParameter(shader,35713) == 0) {
+		var message;
+		switch(type) {
+		case 35632:
+			message = "Error compiling fragment shader";
+			break;
+		case 35633:
+			message = "Error compiling vertex shader";
+			break;
+		default:
+			message = "Error compiling unknown shader type";
+		}
+		message += "\n" + (lime_graphics_opengl_GL().default).getShaderInfoLog(shader);
+		(lime_utils_Log().default).error(message,{ fileName : "GLUtils.hx", lineNumber : 35, className : "lime.utils.GLUtils", methodName : "compileShader"});
+	}
+	return shader;
+}
+GLUtils.createProgram = function(vertexSource,fragmentSource) {
+	var vertexShader = GLUtils.compileShader(vertexSource,35633);
+	var fragmentShader = GLUtils.compileShader(fragmentSource,35632);
+	var program = (lime_graphics_opengl_GL().default).createProgram();
+	(lime_graphics_opengl_GL().default).attachShader(program,vertexShader);
+	(lime_graphics_opengl_GL().default).attachShader(program,fragmentShader);
+	(lime_graphics_opengl_GL().default).linkProgram(program);
+	if((lime_graphics_opengl_GL().default).getProgramParameter(program,35714) == 0) {
+		var message = "Unable to initialize the shader program";
+		message += "\n" + (lime_graphics_opengl_GL().default).getProgramInfoLog(program);
+		(lime_utils_Log().default).error(message,{ fileName : "GLUtils.hx", lineNumber : 58, className : "lime.utils.GLUtils", methodName : "createProgram"});
+	}
+	return program;
+}
+
+
+// Export
+
+exports.default = GLUtils;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/Log.js

@@ -0,0 +1,82 @@
+// Class: lime.utils.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_HaxeError() {return require("./../../js/_Boot/HaxeError");}
+
+// Constructor
+
+var Log = function(){}
+
+// Meta
+
+Log.__name__ = ["lime","utils","Log"];
+Log.prototype = {
+	
+};
+Log.prototype.__class__ = $hxClasses["lime.utils.Log"] = Log;
+
+// Init
+
+{
+	Log.level = 3;
+	if(typeof console == "undefined") {
+		console = {}
+	}
+	if(console.log == null) {
+		console.log = function() {
+		};
+	}
+};
+
+// Statics
+
+Log.debug = function(message,info) {
+	if(Log.level >= 4) {
+		console.debug("[" + info.className + "] " + message);
+	}
+}
+Log.error = function(message,info) {
+	if(Log.level >= 1) {
+		var message1 = "[" + info.className + "] ERROR: " + message;
+		if(Log.throwErrors) {
+			throw new (js__$Boot_HaxeError().default)(message1);
+		} else {
+			console.error(message1);
+		}
+	}
+}
+Log.info = function(message,info) {
+	if(Log.level >= 3) {
+		console.info("[" + info.className + "] " + message);
+	}
+}
+Log.print = function(message) {
+	console.log(message);
+}
+Log.println = function(message) {
+	console.log(message);
+}
+Log.verbose = function(message,info) {
+	if(Log.level >= 5) {
+		Log.println("[" + info.className + "] " + message);
+	}
+}
+Log.warn = function(message,info) {
+	if(Log.level >= 2) {
+		console.warn("[" + info.className + "] WARNING: " + message);
+	}
+}
+Log.throwErrors = true
+
+// Export
+
+exports.default = Log;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/ObjectPool.js

@@ -0,0 +1,191 @@
+// Class: lime.utils.ObjectPool
+
+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_ds_ObjectMap() {return require("./../../haxe/ds/ObjectMap");}
+function List() {return require("./../../List");}
+
+// Constructor
+
+var ObjectPool = function(create,clean,size) {
+	if(create != null) {
+		this.create = create;
+	}
+	if(clean != null) {
+		this.clean = clean;
+	}
+	if(size != null) {
+		this.set_size(size);
+	}
+	this.__pool = new (haxe_ds_ObjectMap().default)();
+	this.activeObjects = 0;
+	this.inactiveObjects = 0;
+	this.__inactiveObject0 = null;
+	this.__inactiveObject1 = null;
+	this.__inactiveObjectList = new (List().default)();
+}
+
+// Meta
+
+ObjectPool.__name__ = ["lime","utils","ObjectPool"];
+ObjectPool.prototype = {
+	add: function(object) {
+		if(!this.__pool.exists(object)) {
+			this.__pool.set(object,false);
+			this.clean(object);
+			this.__addInactive(object);
+		}
+	},
+	clean: function(object) {
+	},
+	clear: function() {
+		this.__pool = new (haxe_ds_ObjectMap().default)();
+		this.activeObjects = 0;
+		this.inactiveObjects = 0;
+		this.__inactiveObject0 = null;
+		this.__inactiveObject1 = null;
+		this.__inactiveObjectList.clear();
+	},
+	create: function() {
+		return null;
+	},
+	get: function() {
+		var object = null;
+		if(this.inactiveObjects > 0) {
+			object = this.__getInactive();
+		} else if(this.__size == null || this.activeObjects < this.__size) {
+			object = this.create();
+			if(object != null) {
+				this.__pool.set(object,true);
+				this.activeObjects++;
+			}
+		}
+		return object;
+	},
+	release: function(object) {
+		this.activeObjects--;
+		if(this.__size == null || this.activeObjects + this.inactiveObjects < this.__size) {
+			this.clean(object);
+			this.__addInactive(object);
+		} else {
+			this.__pool.remove(object);
+		}
+	},
+	__addInactive: function(object) {
+		if(this.__inactiveObject0 == null) {
+			this.__inactiveObject0 = object;
+		} else if(this.__inactiveObject1 == null) {
+			this.__inactiveObject1 = object;
+		} else {
+			this.__inactiveObjectList.add(object);
+		}
+		this.inactiveObjects++;
+	},
+	__getInactive: function() {
+		var object = null;
+		if(this.__inactiveObject0 != null) {
+			object = this.__inactiveObject0;
+			this.__inactiveObject0 = null;
+		} else if(this.__inactiveObject1 != null) {
+			object = this.__inactiveObject1;
+			this.__inactiveObject1 = null;
+		} else {
+			object = this.__inactiveObjectList.pop();
+			if(this.__inactiveObjectList.length > 0) {
+				this.__inactiveObject0 = this.__inactiveObjectList.pop();
+			}
+			if(this.__inactiveObjectList.length > 0) {
+				this.__inactiveObject1 = this.__inactiveObjectList.pop();
+			}
+		}
+		this.inactiveObjects--;
+		this.activeObjects++;
+		return object;
+	},
+	__removeInactive: function(count) {
+		if(count <= 0 || this.inactiveObjects == 0) {
+			return;
+		}
+		if(this.__inactiveObject0 != null) {
+			this.__pool.remove(this.__inactiveObject0);
+			this.__inactiveObject0 = null;
+			this.inactiveObjects--;
+			--count;
+		}
+		if(count == 0 || this.inactiveObjects == 0) {
+			return;
+		}
+		if(this.__inactiveObject1 != null) {
+			this.__pool.remove(this.__inactiveObject1);
+			this.__inactiveObject1 = null;
+			this.inactiveObjects--;
+			--count;
+		}
+		if(count == 0 || this.inactiveObjects == 0) {
+			return;
+		}
+		var object = this.__inactiveObjectList.iterator();
+		while(object.hasNext()) {
+			var object1 = object.next();
+			this.__pool.remove(object1);
+			this.__inactiveObjectList.remove(object1);
+			this.inactiveObjects--;
+			--count;
+			if(count == 0 || this.inactiveObjects == 0) {
+				return;
+			}
+		}
+	},
+	get_size: function() {
+		return this.__size;
+	},
+	set_size: function(value) {
+		if(value == null) {
+			this.__size = null;
+		} else {
+			var current = this.inactiveObjects + this.activeObjects;
+			this.__size = value;
+			if(current > value) {
+				this.__removeInactive(current - value);
+			} else if(value > current) {
+				var object;
+				var _g1 = 0;
+				var _g = value - current;
+				while(_g1 < _g) {
+					var i = _g1++;
+					object = this.create();
+					if(object != null) {
+						this.__pool.set(object,false);
+						this.__inactiveObjectList.add(object);
+						this.inactiveObjects++;
+					} else {
+						break;
+					}
+				}
+			}
+		}
+		return value;
+	}
+};
+ObjectPool.prototype.__class__ = $hxClasses["lime.utils.ObjectPool"] = ObjectPool;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = ObjectPool;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/TAError.js

@@ -0,0 +1,21 @@
+// Enum: lime.utils.TAError
+
+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 TAError = $hxClasses["lime.utils.TAError"] = { __ename__: ["lime","utils","TAError"], __constructs__: ["RangeError"] }
+
+TAError.RangeError = ["RangeError",0];
+TAError.RangeError.toString = $estr;
+TAError.RangeError.__enum__ = TAError;
+
+
+exports.default = TAError;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Assets/LibrarySymbol.js

@@ -0,0 +1,48 @@
+// Class: lime.utils._Assets.LibrarySymbol
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_utils_Assets() {return require("./../../../lime/utils/Assets");}
+
+// Constructor
+
+var LibrarySymbol = function(id) {
+	var colonIndex = id.indexOf(":");
+	this.libraryName = id.substring(0,colonIndex);
+	this.symbolName = id.substring(colonIndex + 1);
+	this.library = (lime_utils_Assets().default).getLibrary(this.libraryName);
+}
+
+// Meta
+
+LibrarySymbol.__name__ = ["lime","utils","_Assets","LibrarySymbol"];
+LibrarySymbol.prototype = {
+	isLocal: function(type) {
+		return this.library.isLocal(this.symbolName,type);
+	},
+	exists: function(type) {
+		return this.library.exists(this.symbolName,type);
+	}
+};
+LibrarySymbol.prototype.__class__ = $hxClasses["lime.utils._Assets.LibrarySymbol"] = LibrarySymbol;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = LibrarySymbol;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_BytePointer/BytePointer_Impl_.js

@@ -0,0 +1,223 @@
+// Class: lime.utils._BytePointer.BytePointer_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_utils_BytePointerData() {return require("./../../../lime/utils/BytePointerData");}
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function lime_utils__$Bytes_Bytes_$Impl_$() {return require("./../../../lime/utils/_Bytes/Bytes_Impl_");}
+function Std() {return require("./../../../Std");}
+
+// Constructor
+
+var BytePointer_Impl_ = function(){}
+
+// Meta
+
+BytePointer_Impl_.__name__ = ["lime","utils","_BytePointer","BytePointer_Impl_"];
+BytePointer_Impl_.prototype = {
+	
+};
+BytePointer_Impl_.prototype.__class__ = $hxClasses["lime.utils._BytePointer.BytePointer_Impl_"] = BytePointer_Impl_;
+
+// Init
+
+
+
+// Statics
+
+BytePointer_Impl_._new = function(bytes,offset) {
+	if(offset == null) {
+		offset = 0;
+	}
+	var this1 = new (lime_utils_BytePointerData().default)(bytes,offset);
+	return this1;
+}
+BytePointer_Impl_.set = function(this1,bytes,bufferView,buffer,offset) {
+	if(buffer != null) {
+		bytes = (haxe_io_Bytes().default).ofData(buffer);
+	}
+	if(bytes != null || bufferView == null) {
+		this1.bytes = bytes;
+		this1.offset = offset != null ? offset : 0;
+	} else {
+		this1.bytes = (haxe_io_Bytes().default).ofData(bufferView.buffer);
+		this1.offset = offset != null ? bufferView.byteOffset + offset : bufferView.byteOffset;
+	}
+}
+BytePointer_Impl_.__arrayGet = function(this1,index) {
+	if(this1.bytes != null) {
+		return this1.bytes.get(index + this1.offset);
+	} else {
+		return 0;
+	}
+}
+BytePointer_Impl_.__arraySet = function(this1,index,value) {
+	if(this1.bytes == null) {
+		this1.bytes.set(index + this1.offset,value);
+	}
+	return value;
+}
+BytePointer_Impl_.fromArrayBufferView = function(arrayBufferView) {
+	if(arrayBufferView == null) {
+		return null;
+	}
+	return new (lime_utils_BytePointerData().default)((haxe_io_Bytes().default).ofData(arrayBufferView.buffer),arrayBufferView.byteOffset);
+}
+BytePointer_Impl_.fromArrayBuffer = function(buffer) {
+	if(buffer == null) {
+		return null;
+	}
+	return new (lime_utils_BytePointerData().default)((haxe_io_Bytes().default).ofData(buffer),0);
+}
+BytePointer_Impl_.fromBytes = function(bytes) {
+	return new (lime_utils_BytePointerData().default)(bytes,0);
+}
+BytePointer_Impl_.fromBytesData = function(bytesData) {
+	if(bytesData == null) {
+		return new (lime_utils_BytePointerData().default)(null,0);
+	} else {
+		return new (lime_utils_BytePointerData().default)((haxe_io_Bytes().default).ofData(bytesData),0);
+	}
+}
+BytePointer_Impl_.fromFile = function(path) {
+	return new (lime_utils_BytePointerData().default)((lime_utils__$Bytes_Bytes_$Impl_$().default).fromFile(path),0);
+}
+BytePointer_Impl_.fromLimeBytes = function(bytes) {
+	return new (lime_utils_BytePointerData().default)(bytes,0);
+}
+BytePointer_Impl_.toUInt8Array = function(bytePointer) {
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 8);
+	var this1;
+	if(buffer != null) {
+		this1 = new Uint8Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toUInt8ClampedArray = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 8);
+	var this1;
+	if(buffer != null) {
+		this1 = new Uint8ClampedArray(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toInt8Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 8);
+	var this1;
+	if(buffer != null) {
+		this1 = new Int8Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toUInt16Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 16);
+	var this1;
+	if(buffer != null) {
+		this1 = new Uint16Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toInt16Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 16);
+	var this1;
+	if(buffer != null) {
+		this1 = new Int16Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toUInt32Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 32);
+	var this1;
+	if(buffer != null) {
+		this1 = new Uint32Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toInt32Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 32);
+	var this1;
+	if(buffer != null) {
+		this1 = new Int32Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toFloat32Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 32);
+	var this1;
+	if(buffer != null) {
+		this1 = new Float32Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+BytePointer_Impl_.toFloat64Array = function(bytePointer) {
+	if(bytePointer == null || bytePointer.bytes == null) {
+		return null;
+	}
+	var buffer = bytePointer.bytes.getData();
+	var byteoffset = (Std().default)["int"](bytePointer.offset / 64);
+	var this1;
+	if(buffer != null) {
+		this1 = new Float64Array(buffer,byteoffset);
+	} else {
+		this1 = null;
+	}
+	return this1;
+}
+
+
+// Export
+
+exports.default = BytePointer_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Bytes/Bytes_Impl_.js

@@ -0,0 +1,74 @@
+// Class: lime.utils._Bytes.Bytes_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function lime_app_Future() {return require("./../../../lime/app/Future");}
+function lime_net__$HTTPRequest_$lime_$utils_$Bytes() {return require("./../../../lime/net/_HTTPRequest_lime_utils_Bytes");}
+
+// Constructor
+
+var Bytes_Impl_ = function(){}
+
+// Meta
+
+Bytes_Impl_.__name__ = ["lime","utils","_Bytes","Bytes_Impl_"];
+Bytes_Impl_.prototype = {
+	
+};
+Bytes_Impl_.prototype.__class__ = $hxClasses["lime.utils._Bytes.Bytes_Impl_"] = Bytes_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Bytes_Impl_._new = function(length,bytesData) {
+	var this1 = new (haxe_io_Bytes().default)(bytesData);
+	return this1;
+}
+Bytes_Impl_.alloc = function(length) {
+	var bytes = (haxe_io_Bytes().default).alloc(length);
+	return Bytes_Impl_._new(bytes.get_length(),bytes.getData());
+}
+Bytes_Impl_.fastGet = function(b,pos) {
+	return (haxe_io_Bytes().default).fastGet(b,pos);
+}
+Bytes_Impl_.fromBytes = function(bytes) {
+	if(bytes == null) {
+		return null;
+	}
+	return Bytes_Impl_._new(bytes.get_length(),bytes.getData());
+}
+Bytes_Impl_.fromFile = function(path) {
+	return null;
+}
+Bytes_Impl_.loadFromBytes = function(bytes) {
+	return (lime_app_Future().default).withValue(Bytes_Impl_.fromBytes(bytes));
+}
+Bytes_Impl_.loadFromFile = function(path) {
+	var request = new (lime_net__$HTTPRequest_$lime_$utils_$Bytes().default)();
+	return request.load(path);
+}
+Bytes_Impl_.ofData = function(b) {
+	var bytes = (haxe_io_Bytes().default).ofData(b);
+	return Bytes_Impl_._new(bytes.get_length(),bytes.getData());
+}
+Bytes_Impl_.ofString = function(s) {
+	var bytes = (haxe_io_Bytes().default).ofString(s);
+	return Bytes_Impl_._new(bytes.get_length(),bytes.getData());
+}
+
+
+// Export
+
+exports.default = Bytes_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_DataPointer/DataPointer_Impl_.js

@@ -0,0 +1,438 @@
+// Class: lime.utils._DataPointer.DataPointer_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function lime_utils_DataPointerObject() {return require("./../../../lime/utils/DataPointerObject");}
+function Std() {return require("./../../../Std");}
+function Type() {return require("./../../../Type");}
+function lime_system__$CFFIPointer_CFFIPointer_$Impl_$() {return require("./../../../lime/system/_CFFIPointer/CFFIPointer_Impl_");}
+
+// Constructor
+
+var DataPointer_Impl_ = function(){}
+
+// Meta
+
+DataPointer_Impl_.__name__ = ["lime","utils","_DataPointer","DataPointer_Impl_"];
+DataPointer_Impl_.prototype = {
+	
+};
+DataPointer_Impl_.prototype.__class__ = $hxClasses["lime.utils._DataPointer.DataPointer_Impl_"] = DataPointer_Impl_;
+
+// Init
+
+
+
+// Statics
+
+DataPointer_Impl_._new = function(data) {
+	var this1 = data;
+	return this1;
+}
+DataPointer_Impl_.fromInt = function(value) {
+	return DataPointer_Impl_._new(new (lime_utils_DataPointerObject().default)(null,null,value));
+}
+DataPointer_Impl_.fromFloat = function(value) {
+	return DataPointer_Impl_._new(new (lime_utils_DataPointerObject().default)(null,null,(Std().default)["int"](value)));
+}
+DataPointer_Impl_.fromBytesPointer = function(pointer) {
+	return DataPointer_Impl_._new(new (lime_utils_DataPointerObject().default)(null,pointer.bytes.getData(),pointer.offset));
+}
+DataPointer_Impl_.fromArrayBufferView = function(arrayBufferView) {
+	return DataPointer_Impl_._new(new (lime_utils_DataPointerObject().default)(arrayBufferView));
+}
+DataPointer_Impl_.fromArrayBuffer = function(buffer) {
+	return DataPointer_Impl_._new(new (lime_utils_DataPointerObject().default)(null,buffer));
+}
+DataPointer_Impl_.fromBytes = function(bytes) {
+	return DataPointer_Impl_.fromArrayBuffer(bytes.getData());
+}
+DataPointer_Impl_.fromBytesData = function(bytesData) {
+	return DataPointer_Impl_.fromArrayBuffer(bytesData);
+}
+DataPointer_Impl_.fromLimeBytes = function(bytes) {
+	return DataPointer_Impl_.fromBytes(bytes);
+}
+DataPointer_Impl_.fromCFFIPointer = function(pointer) {
+	return null;
+}
+DataPointer_Impl_.fromFile = function(path) {
+	return null;
+}
+DataPointer_Impl_.toBufferOrBufferView = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		if(data.offset == 0 && length == data.buffer.byteLength) {
+			return data.buffer;
+		} else {
+			var buffer = data.buffer;
+			var byteoffset = data.offset;
+			var this2;
+			if(buffer != null) {
+				if(length == null) {
+					this2 = new Uint8Array(buffer,byteoffset);
+				} else {
+					this2 = new Uint8Array(buffer,byteoffset,length);
+				}
+			} else {
+				this2 = null;
+			}
+			return this2;
+		}
+		break;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength) {
+			return data.bufferView;
+		} else {
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var this3;
+			if(buffer1 != null) {
+				if(length == null) {
+					this3 = new Uint8Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Uint8Array(buffer1,byteoffset1,length);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toBufferView = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		var buffer = data.buffer;
+		var byteoffset = data.offset;
+		var this2;
+		if(buffer != null) {
+			if(length == null) {
+				this2 = new Uint8Array(buffer,byteoffset);
+			} else {
+				this2 = new Uint8Array(buffer,byteoffset,length);
+			}
+		} else {
+			this2 = null;
+		}
+		return this2;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength) {
+			return data.bufferView;
+		} else {
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var this3;
+			if(buffer1 != null) {
+				if(length == null) {
+					this3 = new Uint8Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Uint8Array(buffer1,byteoffset1,length);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toFloat32Array = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		var buffer = data.buffer;
+		var byteoffset = data.offset;
+		var len = (Std().default)["int"](length / 4);
+		var this2;
+		if(buffer != null) {
+			if(len == null) {
+				this2 = new Float32Array(buffer,byteoffset);
+			} else {
+				this2 = new Float32Array(buffer,byteoffset,len);
+			}
+		} else {
+			this2 = null;
+		}
+		return this2;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength && data.bufferView.constructor == Float32Array) {
+			return data.bufferView;
+		} else {
+			if(length > data.bufferView.byteLength) {
+				length = data.bufferView.byteLength;
+			}
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var len1 = (Std().default)["int"](length / 4);
+			var this3;
+			if(buffer1 != null) {
+				if(len1 == null) {
+					this3 = new Float32Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Float32Array(buffer1,byteoffset1,len1);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toInt32Array = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		var buffer = data.buffer;
+		var byteoffset = data.offset;
+		var len = (Std().default)["int"](length / 4);
+		var this2;
+		if(buffer != null) {
+			if(len == null) {
+				this2 = new Int32Array(buffer,byteoffset);
+			} else {
+				this2 = new Int32Array(buffer,byteoffset,len);
+			}
+		} else {
+			this2 = null;
+		}
+		return this2;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength && data.bufferView.constructor == Int32Array) {
+			return data.bufferView;
+		} else {
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var len1 = (Std().default)["int"](length / 4);
+			var this3;
+			if(buffer1 != null) {
+				if(len1 == null) {
+					this3 = new Int32Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Int32Array(buffer1,byteoffset1,len1);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toUInt8Array = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		var buffer = data.buffer;
+		var byteoffset = data.offset;
+		var this2;
+		if(buffer != null) {
+			if(length == null) {
+				this2 = new Uint8Array(buffer,byteoffset);
+			} else {
+				this2 = new Uint8Array(buffer,byteoffset,length);
+			}
+		} else {
+			this2 = null;
+		}
+		return this2;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength && data.bufferView.constructor == Uint8Array) {
+			return data.bufferView;
+		} else {
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var this3;
+			if(buffer1 != null) {
+				if(length == null) {
+					this3 = new Uint8Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Uint8Array(buffer1,byteoffset1,length);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toUInt32Array = function(this1,length) {
+	var data = this1;
+	if (!data) return null;
+	var _g = data.type;
+	switch((Type().default).enumIndex(_g)) {
+	case 0:
+		if(length == null) {
+			length = data.buffer.byteLength;
+		}
+		var buffer = data.buffer;
+		var byteoffset = data.offset;
+		var len = (Std().default)["int"](length / 4);
+		var this2;
+		if(buffer != null) {
+			if(len == null) {
+				this2 = new Uint32Array(buffer,byteoffset);
+			} else {
+				this2 = new Uint32Array(buffer,byteoffset,len);
+			}
+		} else {
+			this2 = null;
+		}
+		return this2;
+	case 1:
+		if(length == null) {
+			length = data.bufferView.byteLength;
+		}
+		if(data.offset == 0 && length == data.bufferView.byteLength && data.bufferView.constructor == Uint32Array) {
+			return data.bufferView;
+		} else {
+			var buffer1 = data.bufferView.buffer;
+			var byteoffset1 = data.bufferView.byteOffset + data.offset;
+			var len1 = (Std().default)["int"](length / 4);
+			var this3;
+			if(buffer1 != null) {
+				if(len1 == null) {
+					this3 = new Uint32Array(buffer1,byteoffset1);
+				} else {
+					this3 = new Uint32Array(buffer1,byteoffset1,len1);
+				}
+			} else {
+				this3 = null;
+			}
+			return this3;
+		}
+		break;
+	default:
+		return null;
+	}
+}
+DataPointer_Impl_.toValue = function(this1) {
+	var data = this1;
+	if (!data) return 0;
+	if (typeof data === 'number') return data;
+	var _g = data.type;
+	if((Type().default).enumIndex(_g) == 2) {
+		return data.offset;
+	} else {
+		return 0;
+	}
+}
+DataPointer_Impl_.__withOffset = function(data,offset) {
+	return null;
+}
+DataPointer_Impl_.equals = function(a,b) {
+	return a == b;
+}
+DataPointer_Impl_.equalsPointer = function(a,b) {
+	return a == b;
+}
+DataPointer_Impl_.greaterThan = function(a,b) {
+	return a > b;
+}
+DataPointer_Impl_.greaterThanPointer = function(a,b) {
+	return (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(a) > (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(b);
+}
+DataPointer_Impl_.greaterThanOrEqual = function(a,b) {
+	return a >= b;
+}
+DataPointer_Impl_.greaterThanOrEqualPointer = function(a,b) {
+	return (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(a) >= (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(b);
+}
+DataPointer_Impl_.lessThan = function(a,b) {
+	return a < b;
+}
+DataPointer_Impl_.lessThanPointer = function(a,b) {
+	return (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(a) < (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(b);
+}
+DataPointer_Impl_.lessThanOrEqual = function(a,b) {
+	return a <= b;
+}
+DataPointer_Impl_.lessThanOrEqualPointer = function(a,b) {
+	return (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(a) <= (lime_system__$CFFIPointer_CFFIPointer_$Impl_$().default).get(b);
+}
+DataPointer_Impl_.notEquals = function(a,b) {
+	return a != b;
+}
+DataPointer_Impl_.notEqualsPointer = function(a,b) {
+	return a != b;
+}
+DataPointer_Impl_.plus = function(a,b) {
+	return DataPointer_Impl_.__withOffset(a,b);
+}
+DataPointer_Impl_.plusPointer = function(a,b) {
+	return DataPointer_Impl_.__withOffset(a,(Std().default)["int"](b));
+}
+DataPointer_Impl_.minus = function(a,b) {
+	return DataPointer_Impl_.__withOffset(a,-b);
+}
+DataPointer_Impl_.minusPointer = function(a,b) {
+	return DataPointer_Impl_.__withOffset(a,-(Std().default)["int"](b));
+}
+
+
+// Export
+
+exports.default = DataPointer_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Float32Array/Float32Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._Float32Array.Float32Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Float32Array_Impl_ = function(){}
+
+// Meta
+
+Float32Array_Impl_.__name__ = ["lime","utils","_Float32Array","Float32Array_Impl_"];
+Float32Array_Impl_.prototype = {
+	
+};
+Float32Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._Float32Array.Float32Array_Impl_"] = Float32Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Float32Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Float32Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Float32Array(bytes.getData(),byteOffset);
+	}
+	return new Float32Array(bytes.getData(),byteOffset,len);
+}
+Float32Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+Float32Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "Float32Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+Float32Array_Impl_.BYTES_PER_ELEMENT = 4
+
+// Export
+
+exports.default = Float32Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Float64Array/Float64Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._Float64Array.Float64Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Float64Array_Impl_ = function(){}
+
+// Meta
+
+Float64Array_Impl_.__name__ = ["lime","utils","_Float64Array","Float64Array_Impl_"];
+Float64Array_Impl_.prototype = {
+	
+};
+Float64Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._Float64Array.Float64Array_Impl_"] = Float64Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Float64Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Float64Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Float64Array(bytes.getData(),byteOffset);
+	}
+	return new Float64Array(bytes.getData(),byteOffset,len);
+}
+Float64Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+Float64Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "Float64Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+Float64Array_Impl_.BYTES_PER_ELEMENT = 8
+
+// Export
+
+exports.default = Float64Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Int16Array/Int16Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._Int16Array.Int16Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Int16Array_Impl_ = function(){}
+
+// Meta
+
+Int16Array_Impl_.__name__ = ["lime","utils","_Int16Array","Int16Array_Impl_"];
+Int16Array_Impl_.prototype = {
+	
+};
+Int16Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._Int16Array.Int16Array_Impl_"] = Int16Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Int16Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Int16Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Int16Array(bytes.getData(),byteOffset);
+	}
+	return new Int16Array(bytes.getData(),byteOffset,len);
+}
+Int16Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+Int16Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "Int16Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+Int16Array_Impl_.BYTES_PER_ELEMENT = 2
+
+// Export
+
+exports.default = Int16Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Int32Array/Int32Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._Int32Array.Int32Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Int32Array_Impl_ = function(){}
+
+// Meta
+
+Int32Array_Impl_.__name__ = ["lime","utils","_Int32Array","Int32Array_Impl_"];
+Int32Array_Impl_.prototype = {
+	
+};
+Int32Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._Int32Array.Int32Array_Impl_"] = Int32Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Int32Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Int32Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Int32Array(bytes.getData(),byteOffset);
+	}
+	return new Int32Array(bytes.getData(),byteOffset,len);
+}
+Int32Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+Int32Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "Int32Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+Int32Array_Impl_.BYTES_PER_ELEMENT = 4
+
+// Export
+
+exports.default = Int32Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Int8Array/Int8Array_Impl_.js

@@ -0,0 +1,53 @@
+// Class: lime.utils._Int8Array.Int8Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Int8Array_Impl_ = function(){}
+
+// Meta
+
+Int8Array_Impl_.__name__ = ["lime","utils","_Int8Array","Int8Array_Impl_"];
+Int8Array_Impl_.prototype = {
+	
+};
+Int8Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._Int8Array.Int8Array_Impl_"] = Int8Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Int8Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	return new Int8Array(bytes.getData(),byteOffset,len);
+}
+Int8Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+Int8Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "Int8Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+Int8Array_Impl_.BYTES_PER_ELEMENT = 1
+
+// Export
+
+exports.default = Int8Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Log/LogLevel_Impl_.js

@@ -0,0 +1,52 @@
+// Class: lime.utils._Log.LogLevel_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 LogLevel_Impl_ = function(){}
+
+// Meta
+
+LogLevel_Impl_.__name__ = ["lime","utils","_Log","LogLevel_Impl_"];
+LogLevel_Impl_.prototype = {
+	
+};
+LogLevel_Impl_.prototype.__class__ = $hxClasses["lime.utils._Log.LogLevel_Impl_"] = LogLevel_Impl_;
+
+// Init
+
+
+
+// Statics
+
+LogLevel_Impl_.gt = function(a,b) {
+	return a > b;
+}
+LogLevel_Impl_.gte = function(a,b) {
+	return a >= b;
+}
+LogLevel_Impl_.lt = function(a,b) {
+	return a < b;
+}
+LogLevel_Impl_.lte = function(a,b) {
+	return a <= b;
+}
+LogLevel_Impl_.NONE = 0
+LogLevel_Impl_.ERROR = 1
+LogLevel_Impl_.WARN = 2
+LogLevel_Impl_.INFO = 3
+LogLevel_Impl_.DEBUG = 4
+LogLevel_Impl_.VERBOSE = 5
+
+// Export
+
+exports.default = LogLevel_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_Resource/Resource_Impl_.js

@@ -0,0 +1,50 @@
+// Class: lime.utils._Resource.Resource_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var Resource_Impl_ = function(){}
+
+// Meta
+
+Resource_Impl_.__name__ = ["lime","utils","_Resource","Resource_Impl_"];
+Resource_Impl_.prototype = {
+	
+};
+Resource_Impl_.prototype.__class__ = $hxClasses["lime.utils._Resource.Resource_Impl_"] = Resource_Impl_;
+
+// Init
+
+
+
+// Statics
+
+Resource_Impl_._new = function(size) {
+	if(size == null) {
+		size = 0;
+	}
+	var this1 = (haxe_io_Bytes().default).alloc(size);
+	return this1;
+}
+Resource_Impl_.__fromString = function(value) {
+	return (haxe_io_Bytes().default).ofString(value);
+}
+Resource_Impl_.__toString = function(value) {
+	return value.toString();
+}
+
+
+// Export
+
+exports.default = Resource_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_UInt16Array/UInt16Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._UInt16Array.UInt16Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var UInt16Array_Impl_ = function(){}
+
+// Meta
+
+UInt16Array_Impl_.__name__ = ["lime","utils","_UInt16Array","UInt16Array_Impl_"];
+UInt16Array_Impl_.prototype = {
+	
+};
+UInt16Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._UInt16Array.UInt16Array_Impl_"] = UInt16Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+UInt16Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Uint16Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Uint16Array(bytes.getData(),byteOffset);
+	}
+	return new Uint16Array(bytes.getData(),byteOffset,len);
+}
+UInt16Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+UInt16Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "UInt16Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+UInt16Array_Impl_.BYTES_PER_ELEMENT = 2
+
+// Export
+
+exports.default = UInt16Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_UInt32Array/UInt32Array_Impl_.js

@@ -0,0 +1,59 @@
+// Class: lime.utils._UInt32Array.UInt32Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var UInt32Array_Impl_ = function(){}
+
+// Meta
+
+UInt32Array_Impl_.__name__ = ["lime","utils","_UInt32Array","UInt32Array_Impl_"];
+UInt32Array_Impl_.prototype = {
+	
+};
+UInt32Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._UInt32Array.UInt32Array_Impl_"] = UInt32Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+UInt32Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Uint32Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Uint32Array(bytes.getData(),byteOffset);
+	}
+	return new Uint32Array(bytes.getData(),byteOffset,len);
+}
+UInt32Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+UInt32Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "UInt32Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+UInt32Array_Impl_.BYTES_PER_ELEMENT = 4
+
+// Export
+
+exports.default = UInt32Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_UInt8Array/UInt8Array_Impl_.js

@@ -0,0 +1,56 @@
+// Class: lime.utils._UInt8Array.UInt8Array_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+
+// Constructor
+
+var UInt8Array_Impl_ = function(){}
+
+// Meta
+
+UInt8Array_Impl_.__name__ = ["lime","utils","_UInt8Array","UInt8Array_Impl_"];
+UInt8Array_Impl_.prototype = {
+	
+};
+UInt8Array_Impl_.prototype.__class__ = $hxClasses["lime.utils._UInt8Array.UInt8Array_Impl_"] = UInt8Array_Impl_;
+
+// Init
+
+
+
+// Statics
+
+UInt8Array_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		return new Uint8Array(bytes.getData());
+	}
+	if(len == null) {
+		return new Uint8Array(bytes.getData(),byteOffset);
+	}
+	return new Uint8Array(bytes.getData(),byteOffset,len);
+}
+UInt8Array_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+UInt8Array_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "UInt8Array [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+UInt8Array_Impl_.BYTES_PER_ELEMENT = 1
+
+// Export
+
+exports.default = UInt8Array_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/_UInt8ClampedArray/UInt8ClampedArray_Impl_.js

@@ -0,0 +1,73 @@
+// Class: lime.utils._UInt8ClampedArray.UInt8ClampedArray_Impl_
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+var $import = require("./../../../import_stub").default;
+function haxe_io_Bytes() {return require("./../../../haxe/io/Bytes");}
+function Std() {return require("./../../../Std");}
+
+// Constructor
+
+var UInt8ClampedArray_Impl_ = function(){}
+
+// Meta
+
+UInt8ClampedArray_Impl_.__name__ = ["lime","utils","_UInt8ClampedArray","UInt8ClampedArray_Impl_"];
+UInt8ClampedArray_Impl_.prototype = {
+	
+};
+UInt8ClampedArray_Impl_.prototype.__class__ = $hxClasses["lime.utils._UInt8ClampedArray.UInt8ClampedArray_Impl_"] = UInt8ClampedArray_Impl_;
+
+// Init
+
+
+
+// Statics
+
+UInt8ClampedArray_Impl_.fromBytes = function(bytes,byteOffset,len) {
+	if(byteOffset == null) {
+		byteOffset = 0;
+	}
+	if(byteOffset == null) {
+		return new Uint8ClampedArray(bytes.getData());
+	}
+	if(len == null) {
+		return new Uint8ClampedArray(bytes.getData(),byteOffset);
+	}
+	return new Uint8ClampedArray(bytes.getData(),byteOffset,len);
+}
+UInt8ClampedArray_Impl_.toBytes = function(this1) {
+	return new (haxe_io_Bytes().default)(new Uint8Array(this1.buffer));
+}
+UInt8ClampedArray_Impl_.toString = function(this1) {
+	if(this1 != null) {
+		return "UInt8ClampedArray [byteLength:" + this1.byteLength + ", length:" + this1.length + "]";
+	} else {
+		return null;
+	}
+}
+UInt8ClampedArray_Impl_._clamp = function(_in) {
+	var _out = (Std().default)["int"](_in);
+	if(_out > 255) {
+		_out = 255;
+	} else {
+		_out = _out;
+	}
+	if(_out < 0) {
+		return 0;
+	} else {
+		return _out;
+	}
+}
+UInt8ClampedArray_Impl_.BYTES_PER_ELEMENT = 1
+
+// Export
+
+exports.default = UInt8ClampedArray_Impl_;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/compress/Deflate.js

@@ -0,0 +1,45 @@
+// Class: lime.utils.compress.Deflate
+
+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");}
+
+// Constructor
+
+var Deflate = function(){}
+
+// Meta
+
+Deflate.__name__ = ["lime","utils","compress","Deflate"];
+Deflate.prototype = {
+	
+};
+Deflate.prototype.__class__ = $hxClasses["lime.utils.compress.Deflate"] = Deflate;
+
+// Init
+
+
+
+// Statics
+
+Deflate.compress = function(bytes) {
+	var data = require ("pako").deflateRaw(bytes.getData());
+	return (haxe_io_Bytes().default).ofData(data);
+}
+Deflate.decompress = function(bytes) {
+	var data = require ("pako").inflateRaw(bytes.getData());
+	return (haxe_io_Bytes().default).ofData(data);
+}
+
+
+// Export
+
+exports.default = Deflate;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/compress/LZMA.js

@@ -0,0 +1,41 @@
+// Class: lime.utils.compress.LZMA
+
+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 LZMA = function(){}
+
+// Meta
+
+LZMA.__name__ = ["lime","utils","compress","LZMA"];
+LZMA.prototype = {
+	
+};
+LZMA.prototype.__class__ = $hxClasses["lime.utils.compress.LZMA"] = LZMA;
+
+// Init
+
+
+
+// Statics
+
+LZMA.compress = function(bytes) {
+	return null;
+}
+LZMA.decompress = function(bytes) {
+	return null;
+}
+
+
+// Export
+
+exports.default = LZMA;

hGameTest/node_modules/openfl/lib/_gen/lime/utils/compress/Zlib.js

@@ -0,0 +1,45 @@
+// Class: lime.utils.compress.Zlib
+
+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");}
+
+// Constructor
+
+var Zlib = function(){}
+
+// Meta
+
+Zlib.__name__ = ["lime","utils","compress","Zlib"];
+Zlib.prototype = {
+	
+};
+Zlib.prototype.__class__ = $hxClasses["lime.utils.compress.Zlib"] = Zlib;
+
+// Init
+
+
+
+// Statics
+
+Zlib.compress = function(bytes) {
+	var data = require ("pako").deflate(bytes.getData());
+	return (haxe_io_Bytes().default).ofData(data);
+}
+Zlib.decompress = function(bytes) {
+	var data = require ("pako").inflate(bytes.getData());
+	return (haxe_io_Bytes().default).ofData(data);
+}
+
+
+// Export
+
+exports.default = Zlib;