First commit

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,102 @@
+// Class: lime.media.AudioManager
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function lime_media_AudioContext() {return require("./../../lime/media/AudioContext");}
+function lime_media_HTML5AudioContext() {return require("./../../lime/media/HTML5AudioContext");}
+function Type() {return require("./../../Type");}
+
+// Constructor
+
+var AudioManager = function(){}
+
+// Meta
+
+AudioManager.__name__ = ["lime","media","AudioManager"];
+AudioManager.prototype = {
+	
+};
+AudioManager.prototype.__class__ = $hxClasses["lime.media.AudioManager"] = AudioManager;
+
+// Init
+
+
+
+// Statics
+
+AudioManager.init = function(context) {
+	if(AudioManager.context == null) {
+		if(context == null) {
+			try {
+				window.AudioContext = window.AudioContext || window.webkitAudioContext;
+				AudioManager.context = (lime_media_AudioContext().default).WEB(new AudioContext ());
+			} catch( e ) {
+				AudioManager.context = (lime_media_AudioContext().default).HTML5(new (lime_media_HTML5AudioContext().default)());
+			}
+		} else {
+			AudioManager.context = context;
+		}
+	}
+}
+AudioManager.resume = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				var device = alc.getContextsDevice(currentContext);
+				alc.resumeDevice(device);
+				alc.processContext(currentContext);
+			}
+		}
+	}
+}
+AudioManager.shutdown = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				var device = alc.getContextsDevice(currentContext);
+				alc.makeContextCurrent(null);
+				alc.destroyContext(currentContext);
+				if(device != null) {
+					alc.closeDevice(device);
+				}
+			}
+		}
+		AudioManager.context = null;
+	}
+}
+AudioManager.suspend = function() {
+	if(AudioManager.context != null) {
+		var _g = AudioManager.context;
+		if((Type().default).enumIndex(_g) == 0) {
+			var al = _g[3];
+			var alc = _g[2];
+			var currentContext = alc.getCurrentContext();
+			if(currentContext != null) {
+				alc.suspendContext(currentContext);
+				var device = alc.getContextsDevice(currentContext);
+				alc.pauseDevice(device);
+			}
+		}
+	}
+}
+
+
+// Export
+
+exports.default = AudioManager;

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

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

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

@@ -0,0 +1,89 @@
+// Class: lime.media.FlashAudioContext
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Constructor
+
+var FlashAudioContext = function() {
+}
+
+// Meta
+
+FlashAudioContext.__name__ = ["lime","media","FlashAudioContext"];
+FlashAudioContext.prototype = {
+	createBuffer: function(stream,context) {
+		return null;
+	},
+	getBytesLoaded: function(buffer) {
+		return 0;
+	},
+	getBytesTotal: function(buffer) {
+		return 0;
+	},
+	getID3: function(buffer) {
+		return null;
+	},
+	getIsBuffering: function(buffer) {
+		return false;
+	},
+	getIsURLInaccessible: function(buffer) {
+		return false;
+	},
+	getLength: function(buffer) {
+		return 0;
+	},
+	getURL: function(buffer) {
+		return null;
+	},
+	close: function(buffer) {
+	},
+	extract: function(buffer,target,length,startPosition) {
+		if(startPosition == null) {
+			startPosition = -1;
+		}
+		return 0;
+	},
+	load: function(buffer,stream,context) {
+	},
+	loadCompressedDataFromByteArray: function(buffer,bytes,bytesLength) {
+	},
+	loadPCMFromByteArray: function(buffer,bytes,samples,format,stereo,sampleRate) {
+		if(sampleRate == null) {
+			sampleRate = 44100;
+		}
+		if(stereo == null) {
+			stereo = true;
+		}
+	},
+	play: function(buffer,startTime,loops,sndTransform) {
+		if(loops == null) {
+			loops = 0;
+		}
+		if(startTime == null) {
+			startTime = 0;
+		}
+		return null;
+	}
+};
+FlashAudioContext.prototype.__class__ = $hxClasses["lime.media.FlashAudioContext"] = FlashAudioContext;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = FlashAudioContext;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALEffect/ALEffect_Impl_.js

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

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALFilter/ALFilter_Impl_.js

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

hGameTest/node_modules/openfl/lib/_gen/lime/media/openal/_ALSource/ALSource_Impl_.js

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