First commit

hGameTest/node_modules/openfl/src/externs/core/flash/flash/Memory.hx

@@ -0,0 +1,158 @@
+package flash; #if (!display && flash)
+
+
+import openfl.system.ApplicationDomain;
+import openfl.utils.ByteArray;
+
+
+extern class Memory {
+	
+	
+	public static inline function getByte (addr:Int):Int {
+		
+		#if flash
+		return untyped __vmem_get__ (0, addr);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function getDouble (addr:Int):Float {
+		
+		#if flash
+		return untyped __vmem_get__ (4, addr);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function getI32 (addr:Int):Int {
+		
+		#if flash
+		return untyped __vmem_get__ (2, addr);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function getFloat (addr:Int):Float {
+		
+		#if flash
+		return untyped __vmem_get__ (3, addr);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function getUI16 (addr:Int):Int {
+		
+		#if flash
+		return untyped __vmem_get__ (1, addr);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function select (b:ByteArray):Void {
+		
+		#if (flash && !display)
+		ApplicationDomain.currentDomain.domainMemory = b;
+		#end
+		
+	}
+	
+	
+	public static inline function setByte (addr:Int, v:Int):Void {
+		
+		#if flash
+		untyped __vmem_set__ (0, addr, v);
+		#end
+		
+	}
+	
+	
+	public static inline function setDouble (addr:Int, v:Float):Void {
+		
+		#if flash
+		untyped __vmem_set__ (4, addr, v);
+		#end
+		
+	}
+	
+	
+	public static inline function setFloat (addr:Int, v:Float):Void {
+		
+		#if flash
+		untyped __vmem_set__ (3, addr, v);
+		#end
+		
+	}
+	
+	
+	public static inline function setI16 (addr:Int, v:Int):Void {
+		
+		#if flash
+		untyped __vmem_set__ (1, addr, v);
+		#end
+		
+	}
+	
+	
+	public static inline function setI32 (addr:Int, v:Int):Void {
+		
+		#if flash
+		untyped __vmem_set__ (2, addr, v);
+		#end
+		
+	}
+	
+	
+	public static inline function signExtend1 (v:Int):Int {
+		
+		#if flash
+		return untyped __vmem_sign__ (0, v);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function signExtend8 (v:Int):Int {
+		
+		#if flash
+		return untyped __vmem_sign__ (1, v);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+	public static inline function signExtend16 (v:Int):Int {
+		
+		#if flash
+		return untyped __vmem_sign__ (2, v);
+		#else
+		return 0;
+		#end
+		
+	}
+	
+	
+}
+
+
+#else
+typedef Memory = openfl.Memory;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/Vector.hx

@@ -0,0 +1,39 @@
+package flash;
+
+
+@:require(flash10) extern class Vector<T> implements ArrayAccess<T> {
+	
+	public var length:Int;
+	public var fixed:Bool;
+	
+	public function new (?length:UInt, ?fixed:Bool):Void;
+	public function concat (?a:Vector<T>):Vector<T>;
+	public function indexOf (x:T, ?from:Int):Int;
+	@:require(flash19) public function insertAt (index:Int, element:T):Int;
+	public function join (sep:String = ","):String;
+	public function lastIndexOf (x:T, ?from:Int):Int;
+	public function pop ():Null<T>;
+	public function push (x:T):Int;
+	@:require(flash19) public function removeAt (index:Int):T;
+	public function reverse ():Vector<T>;
+	public function shift ():Null<T>;
+	public function unshift (x:T):Void;
+	public function slice (?pos:Int, ?end:Int):Vector<T>;
+	public function sort (f:T->T->Int):Void;
+	public function splice (pos:Int, len:Int):Vector<T>;
+	public function toString ():String;
+	
+	public inline static function ofArray<T> (v:Array<T>):Vector<T> {
+		
+		return untyped __vector__(v);
+		
+	}
+	
+	public inline static function convert<T,U> (v:Vector<T>):Vector<U> {
+		
+		return untyped __vector__(v);
+		
+	}
+	
+	
+}

hGameTest/node_modules/openfl/src/externs/core/flash/flash/desktop/Clipboard.hx

@@ -0,0 +1,33 @@
+package flash.desktop; #if (!display && flash)
+
+
+import openfl.utils.Object;
+
+@:require(flash10)
+
+
+extern class Clipboard {
+	
+	
+	public static var generalClipboard (default, never):Clipboard;
+	
+	public var formats (default, never):Array<ClipboardFormats>;
+	
+	#if air
+	public var supportsFilePromise (default, never):Bool;
+	#end
+	
+	public function clear ():Void;
+	public function clearData (format:ClipboardFormats):Void;
+	public function getData (format:ClipboardFormats, transferMode:ClipboardTransferMode = null):Object;
+	public function hasFormat (format:ClipboardFormats):Bool;
+	public function setData (format:ClipboardFormats, data:Object, serializable:Bool = true):Bool;
+	public function setDataHandler (format:ClipboardFormats, handler:Void->Dynamic, serializable:Bool = true):Bool;
+	
+	
+}
+
+
+#else
+typedef Clipboard = openfl.desktop.Clipboard;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/desktop/ClipboardFormats.hx

@@ -0,0 +1,21 @@
+package flash.desktop; #if (!display && flash)
+
+
+@:enum abstract ClipboardFormats(String) from String to String {
+	
+	public var HTML_FORMAT = "air:html";
+	public var RICH_TEXT_FORMAT = "air:rtf";
+	public var TEXT_FORMAT = "air:text";
+	
+	#if air
+	public var BITMAP_FORMAT = "air:bitmap";
+	public var FILE_LIST_FORMAT = "air:file list";
+	public var FILE_PROMISE_LIST_FORMAT = "air:file promise list";
+	#end
+	
+}
+
+
+#else
+typedef ClipboardFormats = openfl.desktop.ClipboardFormats;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/desktop/ClipboardTransferMode.hx

@@ -0,0 +1,16 @@
+package flash.desktop; #if (!display && flash)
+
+
+@:enum abstract ClipboardTransferMode(String) from String to String {
+	
+	public var CLONE_ONLY = "cloneOnly";
+	public var CLONE_PREFERRED = "clonePreferred";
+	public var ORIGINAL_ONLY = "originalOnly";
+	public var ORIGINAL_PREFERRED = "originalPreferred";
+	
+}
+
+
+#else
+typedef ClipboardTransferMode = openfl.desktop.ClipboardTransferMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/AVM1Movie.hx

@@ -0,0 +1,21 @@
+package flash.display; #if (!display && flash)
+
+
+import haxe.Constraints.Function;
+
+
+extern class AVM1Movie extends DisplayObject {
+	
+	
+	private function new ():Void;
+	
+	public function addCallback (functionName:String, closure:Function):Void;
+	public function call (functionName:String, ?p1:Dynamic, ?p2:Dynamic, ?p3:Dynamic, ?p4:Dynamic, ?p5:Dynamic):Dynamic;
+	
+	
+}
+
+
+#else
+typedef AVM1Movie = openfl.display.AVM1Movie;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Bitmap.hx

@@ -0,0 +1,20 @@
+package flash.display; #if (!display && flash)
+
+
+extern class Bitmap extends DisplayObject {
+	
+	
+	public var bitmapData:BitmapData;
+	public var pixelSnapping:PixelSnapping;
+	public var smoothing:Bool;
+	
+	
+	public function new (bitmapData:BitmapData = null, ?pixelSnapping:PixelSnapping, smoothing:Bool = false);
+	
+	
+}
+
+
+#else
+typedef Bitmap = openfl.display.Bitmap;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/BitmapData.hx

@@ -0,0 +1,203 @@
+package flash.display; #if (!display && flash)
+
+
+import lime.app.Future;
+import lime.app.Promise;
+import lime.graphics.Image;
+import openfl.display.BitmapDataChannel;
+import openfl.display3D.textures.TextureBase;
+import openfl.filters.BitmapFilter;
+import openfl.geom.ColorTransform;
+import openfl.geom.Matrix;
+import openfl.geom.Point;
+import openfl.geom.Rectangle;
+import openfl.utils.ByteArray;
+import openfl.utils.Object;
+
+
+extern class BitmapData implements IBitmapDrawable {
+	
+	
+	public var height (default, never):Int;
+	
+	public var image (get, never):Image;
+	private inline function get_image ():Image { return null; }
+	
+	public var readable (get, never):Bool;
+	private inline function get_readable ():Bool { return true; }
+	
+	public var rect (default, never):Rectangle;
+	public var transparent (default, never):Bool;
+	public var width (default, never):Int;
+	
+	public function new (width:Int, height:Int, transparent:Bool = true, fillColor:UInt = 0xFFFFFFFF);
+	public function applyFilter (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, filter:BitmapFilter):Void;
+	public function clone ():BitmapData;
+	public function colorTransform (rect:Rectangle, colorTransform:ColorTransform):Void;
+	public function compare (otherBitmapData:BitmapData):Object;
+	public function copyChannel (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, sourceChannel:BitmapDataChannel, destChannel:BitmapDataChannel):Void;
+	public function copyPixels (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, alphaBitmapData:BitmapData = null, alphaPoint:Point = null, mergeAlpha:Bool = false):Void;
+	
+	#if flash
+	@:require(flash11_4) public function copyPixelsToByteArray (rect:Rectangle, data:ByteArray):Void;
+	#end
+	
+	public function dispose ():Void;
+	
+	public inline function disposeImage ():Void {}
+	
+	public function draw (source:IBitmapDrawable, matrix:Matrix = null, colorTransform:ColorTransform = null, blendMode:BlendMode = null, clipRect:Rectangle = null, smoothing:Bool = false):Void;
+	@:require(flash11_3) public function drawWithQuality (source:IBitmapDrawable, matrix:Matrix = null, colorTransform:ColorTransform = null, blendMode:BlendMode = null, clipRect:Rectangle = null, smoothing:Bool = false, quality:StageQuality = null) : Void;
+	@:require(flash11_3) public function encode (rect:Rectangle, compressor:Object, byteArray:ByteArray = null):ByteArray;
+	public function fillRect (rect:Rectangle, color:UInt):Void;
+	public function floodFill (x:Int, y:Int, color:UInt):Void;
+	
+	
+	public static inline function fromBase64 (base64:String, type:String):BitmapData {
+		
+		return null;
+		
+	}
+	
+	
+	public static inline function fromBytes (bytes:ByteArray, rawAlpha:ByteArray = null):BitmapData {
+		
+		return null;
+		
+	}
+	
+	
+	public static inline function fromFile (path:String):BitmapData {
+		
+		return null;
+		
+	}
+	
+	
+	public static inline function fromImage (image:Image, transparent:Bool = true):BitmapData {
+		
+		#if flash
+		return image.src;
+		#else
+		return null;
+		#end
+		
+	}
+	
+	
+	public static function fromTexture (texture:TextureBase):BitmapData {
+		
+		return null;
+		
+	}
+	
+	
+	public function generateFilterRect (sourceRect:Rectangle, filter:BitmapFilter):Rectangle;
+	public function getColorBoundsRect (mask:UInt, color:UInt, findColor:Bool = true):Rectangle;
+	public function getPixel (x:Int, y:Int):Int;
+	public function getPixel32 (x:Int, y:Int):Int;
+	public function getPixels (rect:Rectangle):ByteArray;
+	@:require(flash10) public function getVector (rect:Rectangle):Vector<UInt>;
+	
+	@:require(flash10) public function histogram (hRect:Rectangle = null):Vector<Vector<Float>>;
+	public function hitTest (firstPoint:Point, firstAlphaThreshold:UInt, secondObject:Object, secondBitmapDataPoint:Point = null, secondAlphaThreshold:UInt = 1):Bool;
+	
+	
+	public static inline function loadFromBase64 (base64:String, type:String):Future<BitmapData> {
+		
+		return Image.loadFromBase64 (base64, type).then (function (image) {
+			
+			if (image == null) {
+				
+				return Future.withValue (null);
+				
+			} else {
+				
+				return Future.withValue (image.src);
+				
+			}
+			
+		});
+		
+	}
+	
+	
+	public static inline function loadFromBytes (bytes:ByteArray, rawAlpha:ByteArray = null):Future<BitmapData> {
+		
+		return Image.loadFromBytes (bytes).then (function (image) {
+			
+			if (image == null) {
+				
+				return Future.withValue (null);
+				
+			} else {
+				
+				var bitmapData:BitmapData = image.src;
+				
+				if (rawAlpha != null) {
+					
+					var data = bitmapData.getPixels (bitmapData.rect);
+					
+					for (i in 0...rawAlpha.length) {
+						
+						data[i * 4] = rawAlpha.readUnsignedByte ();
+						
+					}
+					
+					bitmapData.setPixels (bitmapData.rect, data);
+					
+				}
+				
+				return Future.withValue (bitmapData);
+				
+			}
+			
+		});
+		
+	}
+	
+	
+	public static inline function loadFromFile (path:String):Future<BitmapData> {
+		
+		return Image.loadFromFile (path).then (function (image) {
+			
+			if (image == null) {
+				
+				return Future.withValue (null);
+				
+			} else {
+				
+				return Future.withValue (image.src);
+				
+			}
+			
+		});
+		
+	}
+	
+	
+	public function lock ():Void;
+	public function merge (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redMultiplier:UInt, greenMultiplier:UInt, blueMultiplier:UInt, alphaMultiplier:UInt):Void;
+	public function noise (randomSeed:Int, low:UInt = 0, high:UInt = 255, channelOptions:UInt = 7, grayScale:Bool = false):Void;
+	public function paletteMap (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, redArray:Array<Int> = null, greenArray:Array<Int> = null, blueArray:Array<Int> = null, alphaArray:Array<Int> = null):Void;
+	public function perlinNoise (baseX:Float, baseY:Float, numOctaves:UInt, randomSeed:Int, stitch:Bool, fractalNoise:Bool, channelOptions:UInt = 7, grayScale:Bool = false, offsets:Array<Point> = null):Void;
+	
+	#if flash
+	public function pixelDissolve (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, randomSeed:Int = 0, numPixels:Int = 0, fillColor:UInt = 0):Int;
+	#end
+	
+	public function scroll (x:Int, y:Int):Void;
+	public function setPixel (x:Int, y:Int, color:UInt):Void;
+	public function setPixel32 (x:Int, y:Int, color:UInt):Void;
+	public function setPixels (rect:Rectangle, byteArray:ByteArray):Void;
+	@:require(flash10) public function setVector (rect:Rectangle, inputVector:Vector<UInt>):Void;
+	public function threshold (sourceBitmapData:BitmapData, sourceRect:Rectangle, destPoint:Point, operation:String, threshold:UInt, color:UInt = 0x00000000, mask:UInt = 0xFFFFFFFF, copySource:Bool = false):Int;
+	public function unlock (changeRect:Rectangle = null):Void;
+	
+	
+}
+
+
+#else
+typedef BitmapData = openfl.display.BitmapData;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/BitmapDataChannel.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef BitmapDataChannel = openfl.display.BitmapDataChannel;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/BlendMode.hx

@@ -0,0 +1,27 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract BlendMode(String) from String to String {
+	
+	public var ADD = "add";
+	public var ALPHA = "alpha";
+	public var DARKEN = "darken";
+	public var DIFFERENCE = "difference";
+	public var ERASE = "erase";
+	public var HARDLIGHT = "hardlight";
+	public var INVERT = "invert";
+	public var LAYER = "layer";
+	public var LIGHTEN = "lighten";
+	public var MULTIPLY = "multiply";
+	public var NORMAL = "normal";
+	public var OVERLAY = "overlay";
+	public var SCREEN = "screen";
+	public var SHADER = "shader";
+	public var SUBTRACT = "subtract";
+	
+}
+
+
+#else
+typedef BlendMode = openfl.display.BlendMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/CapsStyle.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract CapsStyle(String) from String to String {
+	
+	public var NONE = "none";
+	public var ROUND = "round";
+	public var SQUARE = "square";
+	
+}
+
+
+#else
+typedef CapsStyle = openfl.display.CapsStyle;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/DisplayObject.hx

@@ -0,0 +1,98 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.events.EventDispatcher;
+import openfl.filters.BitmapFilter;
+import openfl.geom.Point;
+import openfl.geom.Rectangle;
+import openfl.geom.Transform;
+import openfl.geom.Vector3D;
+
+
+extern class DisplayObject extends EventDispatcher implements IBitmapDrawable {
+	
+	
+	#if flash
+	public var accessibilityProperties:flash.accessibility.AccessibilityProperties;
+	#end
+	
+	public var alpha:Float;
+	public var blendMode:BlendMode;
+	
+	#if flash
+	@:require(flash10) public var blendShader (null, never):Shader;
+	#end
+	
+	public var cacheAsBitmap:Bool;
+	
+	#if air
+	public var cacheAsBitmapMatrix:flash.geom.Matrix;
+	#end
+	
+	public var filters:Array<BitmapFilter>;
+	public var height:Float;
+	public var loaderInfo (default, never):LoaderInfo;
+	public var mask:DisplayObject;
+	public var mouseX (default, never):Float;
+	public var mouseY (default, never):Float;
+	public var name:String;
+	public var opaqueBackground:Null<UInt>;
+	public var parent (default, never):DisplayObjectContainer;
+	public var root (default, never):DisplayObject;
+	public var rotation:Float;
+	
+	#if flash
+	@:require(flash10) public var rotationX:Float;
+	#end
+	
+	#if flash
+	@:require(flash10) public var rotationY:Float;
+	#end
+	
+	#if flash
+	@:require(flash10) public var rotationZ:Float;
+	#end
+	
+	public var scale9Grid:Rectangle;
+	public var scaleX:Float;
+	public var scaleY:Float;
+	
+	#if flash
+	@:require(flash10) public var scaleZ:Float;
+	#end
+	
+	public var scrollRect:Rectangle;
+	public var stage (default, never):Stage;
+	public var transform:Transform;
+	public var visible:Bool;
+	public var width:Float;
+	public var x:Float;
+	public var y:Float;
+	
+	#if flash
+	@:require(flash10) var z:Float;
+	#end
+	
+	public function getBounds (targetCoordinateSpace:DisplayObject):Rectangle;
+	public function getRect (targetCoordinateSpace:DisplayObject):Rectangle;
+	public function globalToLocal (pos:Point):Point;
+	
+	#if flash
+	@:require(flash10) public function globalToLocal3D (point:Point):Vector3D;
+	#end
+	
+	public function hitTestObject (obj:DisplayObject):Bool;
+	public function hitTestPoint (x:Float, y:Float, shapeFlag:Bool = false):Bool;
+	public function localToGlobal (point:Point):Point;
+	
+	#if flash
+	@:require(flash10) public function local3DToGlobal (point3d:Vector3D):Point;
+	#end
+	
+	
+}
+
+
+#else
+typedef DisplayObject = openfl.display.DisplayObject;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/DisplayObjectContainer.hx

@@ -0,0 +1,42 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Point;
+
+
+extern class DisplayObjectContainer extends InteractiveObject {
+	
+	
+	public var mouseChildren:Bool;
+	public var numChildren (default, never):Int;
+	public var tabChildren:Bool;
+	
+	#if flash
+	public var textSnapshot (default, never):flash.text.TextSnapshot;
+	#end
+	
+	
+	private function new ();
+	public function addChild (child:DisplayObject):DisplayObject;
+	public function addChildAt (child:DisplayObject, index:Int):DisplayObject;
+	public function areInaccessibleObjectsUnderPoint (point:Point):Bool;
+	public function contains (child:DisplayObject):Bool;
+	public function getChildAt (index:Int):DisplayObject;
+	public function getChildByName (name:String):DisplayObject;
+	public function getChildIndex (child:DisplayObject):Int;
+	public function getObjectsUnderPoint (point:Point):Array<DisplayObject>;
+	public function removeChild (child:DisplayObject):DisplayObject;
+	public function removeChildAt (index:Int):DisplayObject;
+	@:require(flash11) public function removeChildren (beginIndex:Int = 0, endIndex:Int = 0x7FFFFFFF):Void;
+	public function setChildIndex (child:DisplayObject, index:Int):Void;
+	@:require(flash11_8) public function stopAllMovieClips ():Void;
+	public function swapChildren (child1:DisplayObject, child2:DisplayObject):Void;
+	public function swapChildrenAt (index1:Int, index2:Int):Void;
+	
+	
+}
+
+
+#else
+typedef DisplayObjectContainer = openfl.display.DisplayObjectContainer;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/FrameLabel.hx

@@ -0,0 +1,22 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.events.EventDispatcher;
+
+
+@:final extern class FrameLabel extends EventDispatcher {
+	
+	
+	public var frame (default, never):Int;
+	public var name (default, never):String;
+	
+	
+	public function new (name:String, frame:Int):Void;
+	
+	
+}
+
+
+#else
+typedef FrameLabel = openfl.display.FrameLabel;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GradientType.hx

@@ -0,0 +1,13 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract GradientType(String) from String to String {
+	
+	public var LINEAR = "linear";
+	public var RADIAL = "radial";
+	
+}
+
+#else
+typedef GradientType = openfl.display.GradientType;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Graphics.hx

@@ -0,0 +1,48 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Matrix;
+import openfl.geom.Point;
+import openfl.geom.Rectangle;
+import openfl.Vector;
+
+
+@:final extern class Graphics {
+	
+	
+	public function beginBitmapFill (bitmap:BitmapData, matrix:Matrix = null, repeat:Bool = true, smooth:Bool = false):Void;
+	public function beginFill (color:UInt = 0, alpha:Float = 1):Void;
+	public function beginGradientFill (type:GradientType, colors:Array<UInt>, alphas:Array<Float>, ratios:Array<Int>, matrix:Matrix = null, ?spreadMethod:SpreadMethod, ?interpolationMethod:InterpolationMethod, focalPointRatio:Null<Float> = null):Void;
+	
+	#if flash
+	@:require(flash10) public function beginShaderFill (shader:Shader, matrix:Matrix = null):Void;
+	#end
+	
+	public function clear ():Void;
+	
+	@:require(flash10) public function copyFrom (sourceGraphics:Graphics):Void;
+	@:require(flash11) public function cubicCurveTo (controlX1:Float, controlY1:Float, controlX2:Float, controlY2:Float, anchorX:Float, anchorY:Float):Void;
+	public function curveTo (controlX:Float, controlY:Float, anchorX:Float, anchorY:Float):Void;
+	public function drawCircle (x:Float, y:Float, radius:Float):Void;
+	public function drawEllipse (x:Float, y:Float, width:Float, height:Float):Void;
+	@:require(flash10) public function drawGraphicsData (graphicsData:Vector<IGraphicsData>):Void;
+	@:require(flash10) public function drawPath (commands:Vector<Int>, data:Vector<Float>, ?winding:GraphicsPathWinding):Void;
+	public function drawRect (x:Float, y:Float, width:Float, height:Float):Void;
+	public function drawRoundRect (x:Float, y:Float, width:Float, height:Float, ellipseWidth:Float, ellipseHeight:Null<Float> = null):Void;
+	public function drawRoundRectComplex (x:Float, y:Float, width:Float, height:Float, topLeftRadius:Float, topRightRadius:Float, bottomLeftRadius:Float, bottomRightRadius:Float):Void;
+	@:require(flash10) public function drawTriangles (vertices:Vector<Float>, ?indices:Vector<Int> = null, ?uvtData:Vector<Float> = null, ?culling:TriangleCulling, ?colors:Vector<Int>, blendMode:Int = 0):Void;
+	public function endFill ():Void;
+	@:require(flash10) public function lineBitmapStyle (bitmap:BitmapData, matrix:Matrix = null, repeat:Bool = true, smooth:Bool = false):Void;
+	public function lineGradientStyle (type:GradientType, colors:Array<UInt>, alphas:Array<Float>, ratios:Array<Int>, matrix:Matrix = null, ?spreadMethod:SpreadMethod, ?interpolationMethod:InterpolationMethod, focalPointRatio:Null<Float> = null):Void;
+	public function lineStyle (thickness:Null<Float> = null, color:Null<UInt> = null, alpha:Null<Float> = null, pixelHinting:Null<Bool> = null, ?scaleMode:LineScaleMode, ?caps:CapsStyle, ?joints:JointStyle, miterLimit:Null<Float> = 3):Void;
+	public function lineTo (x:Float, y:Float):Void;
+	public function moveTo (x:Float, y:Float):Void;
+	@:require(flash11_6) public function readGraphicsData (recurse:Bool = true):Vector<IGraphicsData>;
+	
+	
+}
+
+
+#else
+typedef Graphics = openfl.display.Graphics;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsBitmapFill.hx

@@ -0,0 +1,24 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Matrix;
+
+
+@:final extern class GraphicsBitmapFill implements IGraphicsData implements IGraphicsFill {
+	
+	
+	public var bitmapData:BitmapData;
+	public var matrix:Matrix;
+	public var repeat:Bool;
+	public var smooth:Bool;
+	
+	
+	public function new (bitmapData:BitmapData = null, matrix:Matrix = null, repeat:Bool = true, smooth:Bool = false);
+	
+	
+}
+
+
+#else
+typedef GraphicsBitmapFill = openfl.display.GraphicsBitmapFill;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsEndFill.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class GraphicsEndFill implements IGraphicsData implements IGraphicsFill {
+	
+	
+	public function new ();
+	
+	
+}
+
+
+#else
+typedef GraphicsEndFill = openfl.display.GraphicsEndFill;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsGradientFill.hx

@@ -0,0 +1,28 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Matrix;
+
+
+@:final extern class GraphicsGradientFill implements IGraphicsData implements IGraphicsFill {
+	
+	
+	public var alphas:Array<Float>;
+	public var colors:Array<UInt>;
+	public var focalPointRatio:Float;
+	public var interpolationMethod:InterpolationMethod;
+	public var matrix:Matrix;
+	public var ratios:Array<UInt>;
+	public var spreadMethod:SpreadMethod;
+	public var type:GradientType;
+	
+	
+	public function new (?type:GradientType, colors:Array<UInt> = null, alphas:Array<Float> = null, ratios:Array<UInt> = null, matrix:Matrix = null, ?spreadMethod:SpreadMethod, ?interpolationMethod:InterpolationMethod, focalPointRatio:Float = 0);
+	
+	
+}
+
+
+#else
+typedef GraphicsGradientFill = openfl.display.GraphicsGradientFill;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsPath.hx

@@ -0,0 +1,29 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.Vector;
+
+
+@:final extern class GraphicsPath implements IGraphicsData implements IGraphicsPath {
+	
+	
+	public var commands:Vector<Int>;
+	public var data:Vector<Float>;
+	public var winding:GraphicsPathWinding; /* note: currently ignored */
+	
+	public function new (commands:Vector<Int> = null, data:Vector<Float> = null, ?winding:GraphicsPathWinding);
+	
+	@:require(flash11) public function cubicCurveTo (controlX1:Float, controlY1:Float, controlX2:Float, controlY2:Float, anchorX:Float, anchorY:Float):Void;
+	public function curveTo (controlX:Float, controlY:Float, anchorX:Float, anchorY:Float):Void;
+	public function lineTo (x:Float, y:Float):Void;
+	public function moveTo (x:Float, y:Float):Void;
+	public function wideLineTo (x:Float, y:Float):Void;
+	public function wideMoveTo (x:Float, y:Float):Void;
+	
+	
+}
+
+
+#else
+typedef GraphicsPath = openfl.display.GraphicsPath;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsPathCommand.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef GraphicsPathCommand = openfl.display.GraphicsPathCommand;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsPathWinding.hx

@@ -0,0 +1,14 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract GraphicsPathWinding(String) from String to String {
+	
+	public var EVEN_ODD = "evenOdd";
+	public var NON_ZERO = "nonZero";
+	
+}
+
+
+#else
+typedef GraphicsPathWinding = openfl.display.GraphicsPathWinding;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsSolidFill.hx

@@ -0,0 +1,18 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class GraphicsSolidFill implements IGraphicsData implements IGraphicsFill {
+	
+	
+	public var alpha:Float;
+	public var color:UInt;
+	
+	public function new (color:UInt = 0, alpha:Float = 1);
+	
+	
+}
+
+
+#else
+typedef GraphicsSolidFill = openfl.display.GraphicsSolidFill;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsStroke.hx

@@ -0,0 +1,23 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class GraphicsStroke implements IGraphicsData implements IGraphicsStroke {
+	
+	
+	public var caps:CapsStyle;
+	public var fill:IGraphicsFill;
+	public var joints:JointStyle;
+	public var miterLimit:Float;
+	public var pixelHinting:Bool;
+	public var scaleMode:LineScaleMode;
+	public var thickness:Float;
+	
+	public function new (thickness:Float = Math.NaN, pixelHinting:Bool = false, ?scaleMode:LineScaleMode, ?caps:CapsStyle, ?joints:JointStyle, miterLimit:Float = 3, fill:IGraphicsFill = null);
+	
+	
+}
+
+
+#else
+typedef GraphicsStroke = openfl.display.GraphicsStroke;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/GraphicsTrianglePath.hx

@@ -0,0 +1,22 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.Vector;
+
+
+@:final extern class GraphicsTrianglePath implements IGraphicsData implements IGraphicsPath {
+	
+	
+	public var culling:TriangleCulling;
+	public var indices:Vector<Int>;
+	public var uvtData:Vector<Float>;
+	public var vertices:Vector<Float>;
+	
+	public function new (?vertices:Vector<Float>, ?indices:Vector<Int>, ?uvtData:Vector<Float>, ?culling:TriangleCulling);
+	
+}
+
+
+#else
+typedef GraphicsTrianglePath = openfl.display.GraphicsTrianglePath;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/IBitmapDrawable.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef IBitmapDrawable = openfl.display.IBitmapDrawable;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/IGraphicsData.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef IGraphicsData = openfl.display.IGraphicsData;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/IGraphicsFill.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef IGraphicsFill = openfl.display.IGraphicsFill;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/IGraphicsPath.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef IGraphicsPath = openfl.display.IGraphicsPath;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/IGraphicsStroke.hx

@@ -0,0 +1,4 @@
+package flash.display;
+
+
+typedef IGraphicsStroke = openfl.display.IGraphicsStroke;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/InteractiveObject.hx

@@ -0,0 +1,37 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Rectangle;
+
+
+extern class InteractiveObject extends DisplayObject {
+	
+	
+	#if flash
+	public var accessibilityImplementation:flash.accessibility.AccessibilityImplementation;
+	#end
+	
+	#if flash
+	public var contextMenu:flash.ui.ContextMenu;
+	#elseif air
+	public var contextMenu:flash.display.NativeMenu;
+	#end
+	
+	public var doubleClickEnabled:Bool;
+	public var focusRect:Null<Bool>;
+	public var mouseEnabled:Bool;
+	@:require(flash11) public var needsSoftKeyboard:Bool;
+	@:require(flash11) public var softKeyboardInputAreaOfInterest:Rectangle;
+	public var tabEnabled:Bool;
+	public var tabIndex:Int;
+	
+	public function new ();
+	@:require(flash11) public function requestSoftKeyboard ():Bool;
+	
+	
+}
+
+
+#else
+typedef InteractiveObject = openfl.display.InteractiveObject;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/InterpolationMethod.hx

@@ -0,0 +1,14 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract InterpolationMethod(String) from String to String {
+	
+	public var LINEAR_RGB = "linearRGB";
+	public var RGB = "rgb";
+	
+}
+
+
+#else
+typedef InterpolationMethod = openfl.display.InterpolationMethod;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/JPEGEncoderOptions.hx

@@ -0,0 +1,18 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class JPEGEncoderOptions {
+	
+	
+	public var quality:UInt;
+	
+	
+	public function new (quality:UInt = 80);
+	
+	
+}
+
+
+#else
+typedef JPEGEncoderOptions = openfl.display.JPEGEncoderOptions;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/JointStyle.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract JointStyle(String) from String to String {
+	
+	public var MITER = "miter";
+	public var ROUND = "round";
+	public var BEVEL = "bevel";
+	
+}
+
+
+#else
+typedef JointStyle = openfl.display.JointStyle;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/LineScaleMode.hx

@@ -0,0 +1,16 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract LineScaleMode(String) from String to String {
+	
+	public var HORIZONTAL = "horizontal";
+	public var NONE = "none";
+	public var NORMAL = "normal";
+	public var VERTICAL = "vertical";
+	
+}
+
+
+#else
+typedef LineScaleMode = openfl.display.LineScaleMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Loader.hx

@@ -0,0 +1,35 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.events.UncaughtErrorEvents;
+import openfl.net.URLRequest;
+import openfl.system.LoaderContext;
+import openfl.utils.ByteArray;
+
+
+extern class Loader extends DisplayObjectContainer {
+	
+	
+	public var content (default, never):DisplayObject;
+	public var contentLoaderInfo (default, never):LoaderInfo;
+	@:require(flash10_1) public var uncaughtErrorEvents (default, never):UncaughtErrorEvents;
+	
+	public function new ();
+	public function close ():Void;
+	public function load (request:URLRequest, context:LoaderContext = null):Void;
+	public function loadBytes (buffer:ByteArray, context:LoaderContext = null):Void;
+	
+	#if air
+	public function loadFilePromise (promise:flash.desktop.IFilePromise, ?context:flash.system.LoaderContext):Void;
+	#end
+	
+	public function unload ():Void;
+	@:require(flash10) public function unloadAndStop (gc:Bool = true):Void;
+	
+	
+}
+
+
+#else
+typedef Loader = openfl.display.Loader;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/LoaderInfo.hx

@@ -0,0 +1,68 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.events.EventDispatcher;
+import openfl.events.UncaughtErrorEvents;
+import openfl.system.ApplicationDomain;
+import openfl.utils.ByteArray;
+
+
+extern class LoaderInfo extends EventDispatcher {
+	
+	
+	#if flash
+	public var actionScriptVersion (default, never):flash.display.ActionScriptVersion;
+	#end
+	
+	public var applicationDomain (default, never):ApplicationDomain;
+	public var bytes (default, never):ByteArray;
+	public var bytesLoaded (default, never):Int;
+	public var bytesTotal (default, never):Int;
+	public var childAllowsParent (default, never):Bool;
+	
+	#if flash
+	@:require(flash11_4) public var childSandboxBridge:Dynamic;
+	#end
+	
+	public var content (default, never):DisplayObject;
+	public var contentType (default, never):String;
+	public var frameRate (default, never):Float;
+	public var height (default, never):Int;
+	
+	#if flash
+	@:require(flash10_1) public var isURLInaccessible (default, never):Bool;
+	#end
+	
+	public var loader (default, never):Loader;
+	public var loaderURL (default, never):String;
+	public var parameters (default, never):Dynamic<String>;
+	public var parentAllowsChild (default, never):Bool;
+	
+	#if flash
+	@:require(flash11_4) public var parentSandboxBridge:Dynamic;
+	#end
+	
+	public var sameDomain (default, never):Bool;
+	public var sharedEvents (default, never):EventDispatcher;
+	
+	#if flash
+	public var swfVersion (default, never):UInt;
+	#end
+	
+	public var uncaughtErrorEvents (default, never):UncaughtErrorEvents;
+	public var url (default, never):String;
+	public var width (default, never):Int;
+	
+	private function new ();
+	
+	#if flash
+	public static function getLoaderInfoByDefinition (object:Dynamic):LoaderInfo;
+	#end
+	
+	
+}
+
+
+#else
+typedef LoaderInfo = openfl.display.LoaderInfo;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/MovieClip.hx

@@ -0,0 +1,50 @@
+package flash.display; #if (!display && flash)
+
+
+extern class MovieClip extends Sprite #if openfl_dynamic implements Dynamic #end {
+	
+	
+	public var currentFrame (default, never):Int;
+	@:require(flash10) public var currentFrameLabel (default, never):String;
+	public var currentLabel (default, never):String;
+	public var currentLabels (default, never):Array<FrameLabel>;
+	public var enabled:Bool;
+	public var framesLoaded (default, never):Int;
+	@:require(flash11) public var isPlaying (default, never):Bool;
+	
+	#if flash
+	public var scenes (default, never):Array<flash.display.Scene>;
+	#end
+	
+	public var totalFrames (default, never):Int;
+	
+	#if flash
+	public var trackAsMenu:Bool;
+	#end
+	
+	public function new ();
+	public function addFrameScript (index:Int, method:Void->Void):Void;
+	public function gotoAndPlay (frame:#if (haxe_ver >= "3.4.2") Any #else Dynamic #end, scene:String = null):Void;
+	public function gotoAndStop (frame:#if (haxe_ver >= "3.4.2") Any #else Dynamic #end, scene:String = null):Void;
+	public function nextFrame ():Void;
+	
+	#if flash
+	public function nextScene ():Void;
+	#end
+	
+	public function play ():Void;
+	public function prevFrame ():Void;
+	
+	#if flash
+	public function prevScene ():Void;
+	#end
+	
+	public function stop ():Void;
+	
+	
+}
+
+
+#else
+typedef MovieClip = openfl.display.MovieClip;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/PNGEncoderOptions.hx

@@ -0,0 +1,18 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class PNGEncoderOptions {
+	
+	
+	public var fastCompression:Bool;
+	
+	
+	public function new (fastCompression:Bool = false):Void;
+	
+	
+}
+
+
+#else
+typedef PNGEncoderOptions = openfl.display.PNGEncoderOptions;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/PixelSnapping.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract PixelSnapping(String) from String to String {
+	
+	public var ALWAYS = "always";
+	public var AUTO = "auto";
+	public var NEVER = "never";
+	
+}
+
+
+#else
+typedef PixelSnapping = openfl.display.PixelSnapping;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Shader.hx

@@ -0,0 +1,37 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.utils.ByteArray;
+
+@:require(flash10)
+
+
+extern class Shader {
+	
+	
+	public var byteCode (never, default):ByteArray;
+	public var data:ShaderData;
+	public var glFragmentSource (get, set):String;
+	public var glProgram (get, never):Dynamic;
+	public var glVertexSource (get, set):String;
+	public var precisionHint:ShaderPrecision;
+	
+	
+	public function new (code:ByteArray = null):Void;
+	
+	
+	private inline function get_glFragmentSource ():String { return null; }
+	private inline function set_glFragmentSource (value:String):String { return null; }
+	
+	private inline function get_glProgram ():String { return null; }
+	
+	private inline function get_glVertexSource ():String { return null; }
+	private inline function set_glVertexSource (value:String):String { return null; }
+	
+	
+}
+
+
+#else
+typedef Shader = openfl.display.Shader;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderData.hx

@@ -0,0 +1,20 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.utils.ByteArray;
+
+@:require(flash10)
+
+
+@:final extern class ShaderData implements Dynamic {
+	
+	
+	public function new (byteArray:ByteArray):Void;
+	
+	
+}
+
+
+#else
+typedef ShaderData = openfl.display.ShaderData;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderInput.hx

@@ -0,0 +1,22 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class ShaderInput<T> implements Dynamic {
+	
+	
+	public var channels (default, never):Int;
+	public var height:Int;
+	public var index (default, never):Int;
+	public var input:T;
+	public var width:Int;
+	
+	
+	public function new ();
+	
+	
+}
+
+
+#else
+typedef ShaderInput<T> = openfl.display.ShaderInput<T>;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderJob.hx

@@ -0,0 +1,27 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.events.EventDispatcher;
+
+
+extern class ShaderJob extends EventDispatcher {
+	
+	
+	public var width:Int;
+	public var height:Int;
+	public var progress (default, never):Float;
+	public var shader:Shader;
+	public var target:Dynamic;
+	
+	
+	public function new (shader:Shader = null, target:Dynamic = null, width:Int = 0, height:Int = 0);
+	public function cancel ():Void;
+	public function start (waitForCompletion:Bool = false):Void;
+	
+	
+}
+
+
+#else
+typedef ShaderJob = openfl.display.ShaderJob;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderParameter.hx

@@ -0,0 +1,19 @@
+package flash.display; #if (!display && flash)
+
+
+@:final extern class ShaderParameter<T> implements Dynamic {
+	
+	
+	public var index (default, never):Int;
+	public var type (default, never):ShaderParameterType;
+	public var value:Array<T>;
+	
+	public function new ();
+	
+	
+}
+
+
+#else
+typedef ShaderParameter<T> = openfl.display.ShaderParameter<T>;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderParameterType.hx

@@ -0,0 +1,33 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract ShaderParameterType(String) from String to String {
+	
+	public var BOOL = "bool";
+	public var BOOL2 = "bool2";
+	public var BOOL3 = "bool3";
+	public var BOOL4 = "bool4";
+	public var FLOAT = "float";
+	public var FLOAT2 = "float2";
+	public var FLOAT3 = "float3";
+	public var FLOAT4 = "float4";
+	public var INT = "int";
+	public var INT2 = "int2";
+	public var INT3 = "int3";
+	public var INT4 = "int4";
+	public var MATRIX2X2 = "matrix2x2";
+	public var MATRIX2X3 = "matrix2x3";
+	public var MATRIX2X4 = "matrix2x4";
+	public var MATRIX3X2 = "matrix3x2";
+	public var MATRIX3X3 = "matrix3x3";
+	public var MATRIX3X4 = "matrix3x4";
+	public var MATRIX4X2 = "matrix4x2";
+	public var MATRIX4X3 = "matrix4x3";
+	public var MATRIX4X4 = "matrix4x4";
+	
+}
+
+
+#else
+typedef ShaderParameterType = openfl.display.ShaderParameterType;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/ShaderPrecision.hx

@@ -0,0 +1,14 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract ShaderPrecision(String) from String to String {
+	
+	public var FAST = "fast";
+	public var FULL = "full";
+	
+}
+
+
+#else
+typedef ShaderPrecision = openfl.display.ShaderPrecision;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Shape.hx

@@ -0,0 +1,17 @@
+package flash.display; #if (!display && flash)
+
+
+extern class Shape extends DisplayObject {
+	
+	
+	public var graphics (default, never):Graphics;
+	
+	public function new ();
+	
+	
+}
+
+
+#else
+typedef Shape = openfl.display.Shape;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/SimpleButton.hx

@@ -0,0 +1,27 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.media.SoundTransform;
+
+
+extern class SimpleButton extends InteractiveObject {
+	
+	
+	public var downState:DisplayObject;
+	public var enabled:Bool;
+	public var hitTestState:DisplayObject;
+	public var overState:DisplayObject;
+	public var soundTransform:SoundTransform;
+	public var trackAsMenu:Bool;
+	public var upState:DisplayObject;
+	public var useHandCursor:Bool;
+	
+	public function new (upState:DisplayObject = null, overState:DisplayObject = null, downState:DisplayObject = null, hitTestState:DisplayObject = null);
+	
+	
+}
+
+
+#else
+typedef SimpleButton = openfl.display.SimpleButton;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/SpreadMethod.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract SpreadMethod(String) from String to String {
+	
+	public var PAD = "pad";
+	public var REFLECT = "reflect";
+	public var REPEAT = "repeat";
+	
+}
+
+
+#else
+typedef SpreadMethod = openfl.display.SpreadMethod;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Sprite.hx

@@ -0,0 +1,41 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.geom.Rectangle;
+import openfl.media.SoundTransform;
+
+
+extern class Sprite extends DisplayObjectContainer {
+	
+	
+	public var buttonMode:Bool;
+	public var dropTarget (default, never):DisplayObject;
+	public var graphics (default, never):Graphics;
+	public var hitArea:Sprite;
+	
+	#if flash
+	public var soundTransform:SoundTransform;
+	#end
+	
+	public var useHandCursor:Bool;
+	
+	public function new ();
+	public function startDrag (lockCenter:Bool = false, bounds:Rectangle = null):Void;
+	
+	#if flash
+	public function startTouchDrag (touchPointID:Int, lockCenter:Bool = false, bounds:Rectangle = null):Void;
+	#end
+	
+	public function stopDrag ():Void;
+	
+	#if flash
+	public function stopTouchDrag (touchPointID:Int):Void;
+	#end
+	
+	
+}
+
+
+#else
+typedef Sprite = openfl.display.Sprite;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Stage.hx

@@ -0,0 +1,190 @@
+package flash.display; #if (!display && flash)
+
+
+import lime.app.Application in LimeApplication;
+import lime.app.IModule;
+import lime.app.Preloader;
+import lime.graphics.RenderContext;
+import lime.graphics.Renderer;
+import lime.ui.Gamepad;
+import lime.ui.GamepadAxis;
+import lime.ui.GamepadButton;
+import lime.ui.Joystick;
+import lime.ui.JoystickHatPosition;
+import lime.ui.KeyCode;
+import lime.ui.KeyModifier;
+import lime.ui.Touch;
+import lime.ui.Window;
+import openfl.display.Application;
+import openfl.geom.Rectangle;
+import openfl.Lib;
+
+
+extern class Stage extends DisplayObjectContainer implements IModule {
+	
+	
+	public var align:StageAlign;
+	@:require(flash10_2) public var allowsFullScreen (default, never):Bool;
+	@:require(flash11_3) public var allowsFullScreenInteractive (default, never):Bool;
+	public var application (get, never):Application;
+	
+	private inline function get_application ():Application { return Lib.application; }
+	
+	#if air
+	public var autoOrients:Bool;
+	#end
+	
+	#if flash
+	@:require(flash15) public var browserZoomFactor (default, never):Float;
+	#end
+	
+	@:require(flash10_2) public var color:UInt;
+	
+	#if flash
+	@:require(flash10) public var colorCorrection:flash.display.ColorCorrection;
+	#end
+	
+	#if flash
+	@:require(flash10) public var colorCorrectionSupport (default, never):flash.display.ColorCorrectionSupport;
+	#end
+	
+	@:require(flash11_4) public var contentsScaleFactor (default, never):Float;
+	
+	#if flash
+	@:require(flash11) public var displayContextInfo (default, never):String;
+	#end
+	
+	public var displayState:StageDisplayState;
+	public var focus:InteractiveObject;
+	public var frameRate:Float;
+	public var fullScreenHeight (default, never):UInt;
+	
+	#if flash
+	public var fullScreenSourceRect:Rectangle;
+	#end
+	
+	public var fullScreenWidth (default, never):UInt;
+	
+	#if flash
+	@:require(flash11_2) public var mouseLock:Bool;
+	#end
+	
+	#if air
+	public var nativeWindow (default, never):NativeWindow;
+	public var orientation (default, never):StageOrientation;
+	#end
+	
+	public var quality:StageQuality;
+	public var scaleMode:StageScaleMode;
+	public var showDefaultContextMenu:Bool;
+	
+	#if flash
+	@:require(flash11) public var softKeyboardRect (default, never):Rectangle;
+	#end
+	
+	public var stage3Ds (default, never):Vector<Stage3D>;
+	public var stageFocusRect:Bool;
+	public var stageHeight (default, never):Int;
+	
+	#if flash
+	@:require(flash10_2) public var stageVideos (default, never):Vector<flash.media.StageVideo>;
+	#end
+	
+	public var stageWidth (default, never):Int;
+	
+	#if air
+	public var supportedOrientations (default, never):Vector<StageOrientation>;
+	#end
+	
+	public var window (get, never):Window;
+	
+	private inline function get_window ():Window { return Lib.application.window; }
+	
+	#if flash
+	@:require(flash10_1) public var wmodeGPU (default, never):Bool;
+	#end
+	
+	
+	#if !flash
+	public function new (window:Window, color:Null<Int> = null);
+	#end
+	
+	
+	#if air
+	public function assignFocus (objectToFocus:InteractiveObject, direction:FocusDirection):Void;
+	#end
+	
+	public function invalidate ():Void;
+	
+	#if flash
+	public function isFocusInaccessible ():Bool;
+	#end
+	
+	#if air
+	public function setAspectRatio (newAspectRatio:StageAspectRatio):Void;
+	public function setOrientation (newOrientation:StageOrientation):Void;
+	public static var supportsOrientationChange (default, never):Bool;
+	#end
+	
+	
+	
+	public function addRenderer (renderer:Renderer):Void;
+	public function addWindow (window:Window):Void;
+	public function registerModule (application:LimeApplication):Void;
+	public function removeRenderer (renderer:Renderer):Void;
+	public function removeWindow (window:Window):Void;
+	public function setPreloader (preloader:Preloader):Void;
+	public function unregisterModule (application:LimeApplication):Void;
+	public function onGamepadAxisMove (gamepad:Gamepad, axis:GamepadAxis, value:Float):Void;
+	public function onGamepadButtonDown (gamepad:Gamepad, button:GamepadButton):Void;
+	public function onGamepadButtonUp (gamepad:Gamepad, button:GamepadButton):Void;
+	public function onGamepadConnect (gamepad:Gamepad):Void;
+	public function onGamepadDisconnect (gamepad:Gamepad):Void;
+	public function onJoystickAxisMove (joystick:Joystick, axis:Int, value:Float):Void;
+	public function onJoystickButtonDown (joystick:Joystick, button:Int):Void;
+	public function onJoystickButtonUp (joystick:Joystick, button:Int):Void;
+	public function onJoystickConnect (joystick:Joystick):Void;
+	public function onJoystickDisconnect (joystick:Joystick):Void;
+	public function onJoystickHatMove (joystick:Joystick, hat:Int, position:JoystickHatPosition):Void;
+	public function onJoystickTrackballMove (joystick:Joystick, trackball:Int, value:Float):Void;
+	public function onKeyDown (window:Window, keyCode:KeyCode, modifier:KeyModifier):Void;
+	public function onKeyUp (window:Window, keyCode:KeyCode, modifier:KeyModifier):Void;
+	public function onModuleExit (code:Int):Void;
+	public function onMouseDown (window:Window, x:Float, y:Float, button:Int):Void;
+	public function onMouseMove (window:Window, x:Float, y:Float):Void;
+	public function onMouseMoveRelative (window:Window, x:Float, y:Float):Void;
+	public function onMouseUp (window:Window, x:Float, y:Float, button:Int):Void;
+	public function onMouseWheel (window:Window, deltaX:Float, deltaY:Float):Void;
+	public function onPreloadComplete ():Void;
+	public function onPreloadProgress (loaded:Int, total:Int):Void;
+	public function onRenderContextLost (renderer:Renderer):Void;
+	public function onRenderContextRestored (renderer:Renderer, context:RenderContext):Void;
+	public function onTextEdit (window:Window, text:String, start:Int, length:Int):Void;
+	public function onTextInput (window:Window, text:String):Void;
+	public function onTouchMove (touch:Touch):Void;
+	public function onTouchEnd (touch:Touch):Void;
+	public function onTouchStart (touch:Touch):Void;
+	public function onWindowActivate (window:Window):Void;
+	public function onWindowClose (window:Window):Void;
+	public function onWindowCreate (window:Window):Void;
+	public function onWindowDeactivate (window:Window):Void;
+	public function onWindowDropFile (window:Window, file:String):Void;
+	public function onWindowEnter (window:Window):Void;
+	public function onWindowFocusIn (window:Window):Void;
+	public function onWindowFocusOut (window:Window):Void;
+	public function onWindowFullscreen (window:Window):Void;
+	public function onWindowLeave (window:Window):Void;
+	public function onWindowMinimize (window:Window):Void;
+	public function onWindowMove (window:Window, x:Float, y:Float):Void;
+	public function onWindowResize (window:Window, width:Int, height:Int):Void;
+	public function onWindowRestore (window:Window):Void;
+	public function render (renderer:Renderer):Void;
+	public function update (deltaTime:Int):Void;
+	
+	
+}
+
+
+#else
+typedef Stage = openfl.display.Stage;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/Stage3D.hx

@@ -0,0 +1,31 @@
+package flash.display; #if (!display && flash)
+
+
+import openfl.display3D.Context3D;
+import openfl.display3D.Context3DProfile;
+import openfl.display3D.Context3DRenderMode;
+import openfl.events.EventDispatcher;
+import openfl.Vector;
+
+@:require(flash11)
+
+
+extern class Stage3D extends EventDispatcher {
+	
+	
+	public var context3D (default, never):Context3D;
+	public var visible:Bool;
+	public var x:Float;
+	public var y:Float;
+	
+	
+	public function requestContext3D (?context3DRenderMode:Context3DRenderMode, ?profile:Context3DProfile):Void;
+	@:require(flash12) public function requestContext3DMatchingProfiles (profiles:Vector<String>):Void;
+	
+	
+}
+
+
+#else
+typedef Stage3D = openfl.display.Stage3D;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/StageAlign.hx

@@ -0,0 +1,20 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract StageAlign(String) from String to String {
+	
+	public var BOTTOM = "bottom";
+	public var BOTTOM_LEFT = "bottomLeft";
+	public var BOTTOM_RIGHT = "bottomRight";
+	public var LEFT = "left";
+	public var RIGHT = "right";
+	public var TOP = "top";
+	public var TOP_LEFT = "topLeft";
+	public var TOP_RIGHT = "topRight";
+	
+}
+
+
+#else
+typedef StageAlign = openfl.display.StageAlign;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/StageDisplayState.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract StageDisplayState(String) from String to String {
+	
+	public var FULL_SCREEN = "fullScreen";
+	public var FULL_SCREEN_INTERACTIVE = "fullScreenInteractive";
+	public var NORMAL = "normal";
+	
+}
+
+
+#else
+typedef StageDisplayState = openfl.display.StageDisplayState;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/StageQuality.hx

@@ -0,0 +1,16 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract StageQuality(String) from String to String {
+	
+	public var BEST = "best";
+	public var HIGH = "high";
+	public var LOW = "low";
+	public var MEDIUM = "medium";
+	
+}
+
+
+#else
+typedef StageQuality = openfl.display.StageQuality;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/StageScaleMode.hx

@@ -0,0 +1,16 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract StageScaleMode(String) from String to String {
+	
+	public var EXACT_FIT = "exactFit";
+	public var NO_BORDER = "noBorder";
+	public var NO_SCALE = "noScale";
+	public var SHOW_ALL = "showAll";
+	
+}
+
+
+#else
+typedef StageScaleMode = openfl.display.StageScaleMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display/TriangleCulling.hx

@@ -0,0 +1,15 @@
+package flash.display; #if (!display && flash)
+
+
+@:enum abstract TriangleCulling(String) from String to String {
+	
+	public var NEGATIVE = "negative";
+	public var NONE = "none";
+	public var POSITIVE = "positive";
+	
+}
+
+
+#else
+typedef TriangleCulling = openfl.display.TriangleCulling;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3D.hx

@@ -0,0 +1,85 @@
+package flash.display3D; #if (!display && flash)
+
+
+import openfl.display.BitmapData;
+import openfl.display3D.textures.CubeTexture;
+import openfl.display3D.textures.RectangleTexture;
+import openfl.display3D.textures.Texture;
+import openfl.display3D.textures.TextureBase;
+import openfl.display3D.textures.VideoTexture;
+import openfl.events.EventDispatcher;
+import openfl.geom.Matrix3D;
+import openfl.geom.Rectangle;
+import openfl.utils.ByteArray;
+import openfl.Vector;
+
+
+@:final extern class Context3D extends EventDispatcher {
+	
+	
+	@:require(flash15) public static var supportsVideoTexture (default, never):Bool;
+	@:require(flash15) public var backBufferHeight (default, never):Int;
+	@:require(flash15) public var backBufferWidth (default, never):Int;
+	public var driverInfo (default, never):String;
+	public var enableErrorChecking:Bool;
+	@:require(flash15) public var maxBackBufferHeight:Int;
+	@:require(flash15) public var maxBackBufferWidth:Int;
+	@:require(flash12) public var profile (default, never):String;
+	
+	public function clear (red:Float = 0, green:Float = 0, blue:Float = 0, alpha:Float = 1, depth:Float = 1, stencil:UInt = 0, mask:UInt = 0xFFFFFFFF):Void;
+	public function configureBackBuffer (width:Int, height:Int, antiAlias:Int, enableDepthAndStencil:Bool = true, wantsBestResolution:Bool = false, wantsBestResolutionOnBrowserZoom:Bool = false):Void;
+	public function createCubeTexture (size:Int, format:Context3DTextureFormat, optimizeForRenderToTexture:Bool, streamingLevels:Int = 0):CubeTexture;
+	public function createIndexBuffer (numIndices:Int, ?bufferUsage:Context3DBufferUsage):IndexBuffer3D;
+	public function createProgram ():Program3D;
+	
+	#if flash
+	@:require(flash11_8)
+	#end
+	public function createRectangleTexture (width:Int, height:Int, format:Context3DTextureFormat, optimizeForRenderToTexture:Bool):RectangleTexture;
+	
+	public function createTexture (width:Int, height:Int, format:Context3DTextureFormat, optimizeForRenderToTexture:Bool, streamingLevels:Int = 0):Texture;
+	public function createVertexBuffer (numVertices:Int, data32PerVertex:Int, ?bufferUsage:Context3DBufferUsage):VertexBuffer3D;
+	@:require(flash15) public function createVideoTexture ():VideoTexture;
+	public function dispose (recreate:Bool = true):Void;
+	public function drawToBitmapData (destination:BitmapData):Void;
+	public function drawTriangles (indexBuffer:IndexBuffer3D, firstIndex:Int = 0, numTriangles:Int = -1):Void;
+	public function present ():Void;
+	public function setBlendFactors (sourceFactor:Context3DBlendFactor, destinationFactor:Context3DBlendFactor):Void;
+	public function setColorMask (red:Bool, green:Bool, blue:Bool, alpha:Bool):Void;
+	public function setCulling (triangleFaceToCull:Context3DTriangleFace):Void;
+	public function setDepthTest (depthMask:Bool, passCompareMode:Context3DCompareMode):Void;
+	
+	#if air
+	@:require(flash16) public function setFillMode (fillMode:flash.display3D.Context3DFillMode):Void;
+	#end
+	
+	public function setProgram (program:Program3D):Void;
+	
+	#if flash
+	@:require(flash11_2)
+	#end
+	public function setProgramConstantsFromByteArray (programType:Context3DProgramType, firstRegister:Int, numRegisters:Int, data:ByteArray, byteArrayOffset:UInt):Void;
+	
+	public function setProgramConstantsFromMatrix (programType:Context3DProgramType, firstRegister:Int, matrix:Matrix3D, transposedMatrix:Bool = false):Void;
+	public function setProgramConstantsFromVector (programType:Context3DProgramType, firstRegister:Int, data:Vector<Float>, numRegisters:Int = -1):Void;
+	public function setRenderToBackBuffer ():Void;
+	public function setRenderToTexture (texture:TextureBase, enableDepthAndStencil:Bool = false, antiAlias:Int = 0, surfaceSelector:Int = 0, colorOutputIndex:Int = 0):Void;
+	
+	#if flash
+	@:require(flash11_6)
+	#end
+	public function setSamplerStateAt (sampler:Int, wrap:Context3DWrapMode, filter:Context3DTextureFilter, mipfilter:Context3DMipFilter):Void;
+	
+	public function setScissorRectangle (rectangle:Rectangle):Void;
+	public function setStencilActions (?triangleFace:Context3DTriangleFace, ?compareMode:Context3DCompareMode, ?actionOnBothPass:Context3DStencilAction, ?actionOnDepthFail:Context3DStencilAction, ?actionOnDepthPassStencilFail:Context3DStencilAction):Void;
+	public function setStencilReferenceValue (referenceValue:UInt, readMask:UInt = 255, writeMask:UInt = 255):Void;
+	public function setTextureAt (sampler:Int, texture:TextureBase):Void;
+	public function setVertexBufferAt (index:Int, buffer:VertexBuffer3D, bufferOffset:Int = 0, ?format:Context3DVertexBufferFormat):Void;
+	
+	
+}
+
+
+#else
+typedef Context3D = openfl.display3D.Context3D;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DBlendFactor.hx

@@ -0,0 +1,22 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DBlendFactor(String) from String to String {
+	
+	public var DESTINATION_ALPHA = "destinationAlpha";
+	public var DESTINATION_COLOR = "destinationColor";
+	public var ONE = "one";
+	public var ONE_MINUS_DESTINATION_ALPHA = "oneMinusDestinationAlpha";
+	public var ONE_MINUS_DESTINATION_COLOR = "oneMinusDestinationColor";
+	public var ONE_MINUS_SOURCE_ALPHA = "oneMinusSourceAlpha";
+	public var ONE_MINUS_SOURCE_COLOR = "oneMinusSourceColor";
+	public var SOURCE_ALPHA = "sourceAlpha";
+	public var SOURCE_COLOR = "sourceColor";
+	public var ZERO = "zero";
+	
+}
+
+
+#else
+typedef Context3DBlendFactor = openfl.display3D.Context3DBlendFactor;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DBufferUsage.hx

@@ -0,0 +1,14 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DBufferUsage(String) from String to String {
+	
+	public var DYNAMIC_DRAW = "dynamicDraw";
+	public var STATIC_DRAW = "staticDraw";
+	
+}
+
+
+#else
+typedef Context3DBufferUsage = openfl.display3D.Context3DBufferUsage;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DClearMask.hx

@@ -0,0 +1,4 @@
+package flash.display3D;
+
+
+typedef Context3DClearMask = openfl.display3D.Context3DClearMask;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DCompareMode.hx

@@ -0,0 +1,20 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DCompareMode(String) from String to String {
+	
+	public var ALWAYS = "always";
+	public var EQUAL = "equal";
+	public var GREATER = "greater";
+	public var GREATER_EQUAL = "greaterEqual";
+	public var LESS = "less";
+	public var LESS_EQUAL = "lessEqual";
+	public var NEVER = "never";
+	public var NOT_EQUAL = "notEqual";
+	
+}
+
+
+#else
+typedef Context3DCompareMode = openfl.display3D.Context3DCompareMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DMipFilter.hx

@@ -0,0 +1,15 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DMipFilter(String) from String to String {
+	
+	public var MIPLINEAR = "miplinear";
+	public var MIPNEAREST = "mipnearest";
+	public var MIPNONE = "mipnone";
+	
+}
+
+
+#else
+typedef Context3DMipFilter = openfl.display3D.Context3DMipFilter;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DProfile.hx

@@ -0,0 +1,18 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DProfile(String) from String to String {
+	
+	public var BASELINE = "baseline";
+	public var BASELINE_CONSTRAINED = "baselineConstrained";
+	public var BASELINE_EXTENDED = "baselineExtended";
+	public var STANDARD = "standard";
+	public var STANDARD_CONSTRAINED = "standardConstrained";
+	public var STANDARD_EXTENDED = "standardExtended";
+	
+}
+
+
+#else
+typedef Context3DProfile = openfl.display3D.Context3DProfile;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DProgramType.hx

@@ -0,0 +1,14 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DProgramType(String) from String to String {
+	
+	public var FRAGMENT = "fragment";
+	public var VERTEX = "vertex";
+	
+}
+
+
+#else
+typedef Context3DProgramType = openfl.display3D.Context3DProgramType;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DRenderMode.hx

@@ -0,0 +1,14 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DRenderMode(String) from String to String {
+	
+	public var AUTO = "auto";
+	public var SOFTWARE = "software";
+	
+}
+
+
+#else
+typedef Context3DRenderMode = openfl.display3D.Context3DRenderMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DStencilAction.hx

@@ -0,0 +1,20 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DStencilAction(String) from String to String {
+	
+	public var DECREMENT_SATURATE = "decrementSaturate";
+	public var DECREMENT_WRAP = "decrementWrap";
+	public var INCREMENT_SATURATE = "incrementSaturate";
+	public var INCREMENT_WRAP = "incrementWrap";
+	public var INVERT = "invert";
+	public var KEEP = "keep";
+	public var SET = "set";
+	public var ZERO = "zero";
+	
+}
+
+
+#else
+typedef Context3DStencilAction = openfl.display3D.Context3DStencilAction;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DTextureFilter.hx

@@ -0,0 +1,18 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DTextureFilter(String) from String to String {
+	
+	public var ANISOTROPIC16X = "anisotropic16x";
+	public var ANISOTROPIC2X = "anisotropic2x";
+	public var ANISOTROPIC4X = "anisotropic4x";
+	public var ANISOTROPIC8X = "anisotropic8x";
+	public var LINEAR = "linear";
+	public var NEAREST = "nearest";
+	
+}
+
+
+#else
+typedef Context3DTextureFilter = openfl.display3D.Context3DTextureFilter;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DTextureFormat.hx

@@ -0,0 +1,18 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DTextureFormat(String) from String to String {
+	
+	public var BGR_PACKED = "bgrPacked565";
+	public var BGRA = "bgra";
+	public var BGRA_PACKED = "bgraPacked4444";
+	public var COMPRESSED = "compressed";
+	public var COMPRESSED_ALPHA = "compressedAlpha";
+	public var RGBA_HALF_FLOAT = "rgbaHalfFloat";
+	
+}
+
+
+#else
+typedef Context3DTextureFormat = openfl.display3D.Context3DTextureFormat;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DTriangleFace.hx

@@ -0,0 +1,16 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DTriangleFace(String) from String to String {
+	
+	public var BACK = "back";
+	public var FRONT = "front";
+	public var FRONT_AND_BACK = "frontAndBack";
+	public var NONE = "none";
+	
+}
+
+
+#else
+typedef Context3DTriangleFace = openfl.display3D.Context3DTriangleFace;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DVertexBufferFormat.hx

@@ -0,0 +1,17 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DVertexBufferFormat(String) from String to String {
+	
+	public var BYTES_4 = "bytes4";
+	public var FLOAT_1 = "float1";
+	public var FLOAT_2 = "float2";
+	public var FLOAT_3 = "float3";
+	public var FLOAT_4 = "float4";
+	
+}
+
+
+#else
+typedef Context3DVertexBufferFormat = openfl.display3D.Context3DVertexBufferFormat;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Context3DWrapMode.hx

@@ -0,0 +1,16 @@
+package flash.display3D; #if (!display && flash)
+
+
+@:enum abstract Context3DWrapMode(String) from String to String {
+	
+	public var CLAMP = "clamp";
+	public var CLAMP_U_REPEAT_V = "clamp_u_repeat_v";
+	public var REPEAT = "repeat";
+	public var REPEAT_U_CLAMP_V = "repeat_u_clamp_v";
+	
+}
+
+
+#else
+typedef Context3DWrapMode = openfl.display3D.Context3DWrapMode;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/IndexBuffer3D.hx

@@ -0,0 +1,29 @@
+package flash.display3D; #if (!display && flash)
+
+
+import lime.utils.ArrayBufferView;
+import openfl.utils.ByteArray;
+import openfl.Vector;
+
+
+@:final extern class IndexBuffer3D {
+	
+	
+	public function dispose ():Void;
+	public function uploadFromByteArray (data:ByteArray, byteArrayOffset:Int, startOffset:Int, count:Int):Void;
+	
+	public inline function uploadFromTypedArray (data:ArrayBufferView):Void {
+		
+		uploadFromByteArray (data.buffer, data.byteOffset, 0, data.byteLength);
+		
+	}
+	
+	public function uploadFromVector (data:Vector<UInt>, startOffset:Int, count:Int):Void;
+	
+	
+}
+
+
+#else
+typedef IndexBuffer3D = openfl.display3D.IndexBuffer3D;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/Program3D.hx

@@ -0,0 +1,19 @@
+package flash.display3D; #if (!display && flash)
+
+
+import openfl.utils.ByteArray;
+
+
+@:final extern class Program3D {
+	
+	
+	public function dispose () : Void;
+	public function upload (vertexProgram:ByteArray, fragmentProgram:ByteArray):Void;
+	
+	
+}
+
+
+#else
+typedef Program3D = openfl.display3D.Program3D;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/VertexBuffer3D.hx

@@ -0,0 +1,29 @@
+package flash.display3D; #if (!display && flash)
+
+
+import lime.utils.ArrayBufferView;
+import openfl.utils.ByteArray;
+import openfl.Vector;
+
+
+extern class VertexBuffer3D {
+	
+	
+	public function dispose ():Void;
+	public function uploadFromByteArray (data:ByteArray, byteArrayOffset:Int, startVertex:Int, numVertices:Int):Void;
+	
+	public inline function uploadFromTypedArray (data:ArrayBufferView):Void {
+		
+		uploadFromByteArray (data.buffer, data.byteOffset, 0, data.byteLength);
+		
+	}
+	
+	public function uploadFromVector (data:Vector<Float>, startVertex:Int, numVertices:Int):Void;
+	
+	
+}
+
+
+#else
+typedef VertexBuffer3D = openfl.display3D.VertexBuffer3D;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/textures/CubeTexture.hx

@@ -0,0 +1,21 @@
+package flash.display3D.textures; #if (!display && flash)
+
+
+import openfl.display.BitmapData;
+import openfl.utils.ByteArray;
+
+
+@:final extern class CubeTexture extends TextureBase {
+	
+	
+	public function uploadCompressedTextureFromByteArray (data:ByteArray, byteArrayOffset:UInt, async:Bool = false):Void;
+	public function uploadFromBitmapData (source:BitmapData, side:UInt, miplevel:UInt = 0):Void;
+	public function uploadFromByteArray (data:ByteArray, byteArrayOffset:UInt, side:UInt, miplevel:UInt = 0):Void;
+	
+	
+}
+
+
+#else
+typedef CubeTexture = openfl.display3D.textures.CubeTexture;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/textures/RectangleTexture.hx

@@ -0,0 +1,20 @@
+package flash.display3D.textures; #if (!display && flash)
+
+
+import openfl.display.BitmapData;
+import openfl.utils.ByteArray;
+
+
+@:final extern class RectangleTexture extends TextureBase {
+	
+	
+	public function uploadFromBitmapData (source:BitmapData):Void;
+	public function uploadFromByteArray (data:ByteArray, byteArrayOffset:UInt):Void;
+	
+	
+}
+
+
+#else
+typedef RectangleTexture = openfl.display3D.textures.RectangleTexture;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/textures/Texture.hx

@@ -0,0 +1,21 @@
+package flash.display3D.textures; #if (!display && flash)
+
+
+import openfl.display.BitmapData;
+import openfl.utils.ByteArray;
+
+
+@:final extern class Texture extends TextureBase {
+	
+	
+	public function uploadCompressedTextureFromByteArray (data:ByteArray, byteArrayOffset:UInt, async:Bool = false):Void;
+	public function uploadFromBitmapData (source:BitmapData, miplevel:UInt = 0):Void;
+	public function uploadFromByteArray (data:ByteArray, byteArrayOffset:UInt, miplevel:UInt = 0):Void;
+	
+	
+}
+
+
+#else
+typedef Texture = openfl.display3D.textures.Texture;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/textures/TextureBase.hx

@@ -0,0 +1,18 @@
+package flash.display3D.textures; #if (!display && flash)
+
+
+import openfl.events.EventDispatcher;
+
+
+extern class TextureBase extends EventDispatcher {
+	
+	
+	public function dispose ():Void;
+	
+	
+}
+
+
+#else
+typedef TextureBase = openfl.display3D.textures.TextureBase;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/display3D/textures/VideoTexture.hx

@@ -0,0 +1,25 @@
+package flash.display3D.textures; #if (!display && flash)
+
+
+import openfl.net.NetStream;
+
+
+@:final extern class VideoTexture extends TextureBase {
+	
+	
+	public var videoHeight (default, never):Int;
+	public var videoWidth (default, never):Int;
+	
+	#if flash
+	public function attachCamera (theCamera:flash.media.Camera):Void;
+	#end
+	
+	public function attachNetStream (netStream:NetStream):Void;
+	
+	
+}
+
+
+#else
+typedef VideoTexture = openfl.display3D.textures.VideoTexture;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/ArgumentError.hx

@@ -0,0 +1,9 @@
+package flash.errors; #if (!display && flash)
+
+
+@:native("ArgumentError") extern class ArgumentError extends Error {}
+
+
+#else
+typedef ArgumentError = openfl.errors.ArgumentError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/EOFError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+extern class EOFError extends IOError {
+	
+	
+	public function new (?message:String, id:Int = 0):Void;
+	
+	
+}
+
+
+#else
+typedef EOFError = openfl.errors.EOFError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/Error.hx

@@ -0,0 +1,34 @@
+package flash.errors; #if (!display && flash)
+
+
+extern class Error #if openfl_dynamic implements Dynamic #end {
+	
+	
+	#if flash
+	public static var length:Int;
+	#end
+	
+	public var errorID (default, null):Int;
+	public var message:String; //Dynamic
+	public var name:String; //Dynamic
+	
+	
+	public function new (message:String = "", id:Int = 0);
+	
+	#if flash
+	public static function getErrorMessage (index:Int):String;
+	#end
+	
+	public function getStackTrace ():String;
+	
+	#if flash
+	public static function throwError (type:Class<Dynamic>, index:UInt, ?p1:Dynamic, ?p2:Dynamic, ?p3:Dynamic, ?p4:Dynamic, ?p5:Dynamic):Dynamic;
+	#end
+	
+	
+}
+
+
+#else
+typedef Error = openfl.errors.Error;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/IOError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+extern class IOError extends Error {
+	
+	
+	public function new (message:String = "");
+	
+	
+}
+
+
+#else
+typedef IOError = openfl.errors.IOError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/IllegalOperationError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+extern class IllegalOperationError extends Error {
+	
+	
+	public function new (message:String = "");
+	
+	
+}
+
+
+#else
+typedef IllegalOperationError = openfl.errors.IllegalOperationError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/RangeError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+@:native("RangeError") extern class RangeError extends Error {
+	
+	
+	public function new (message:String = "");
+	
+	
+}
+
+
+#else
+typedef RangeError = openfl.errors.RangeError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/SecurityError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+@:native("SecurityError") extern class SecurityError extends Error {
+	
+	
+	public function new (message:String = "");
+	
+	
+}
+
+
+#else
+typedef SecurityError = openfl.errors.SecurityError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/errors/TypeError.hx

@@ -0,0 +1,15 @@
+package flash.errors; #if (!display && flash)
+
+
+@:native("TypeError") extern class TypeError extends Error {
+	
+	
+	public function new (message:String = "");
+	
+	
+}
+
+
+#else
+typedef TypeError = openfl.errors.TypeError;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/AccelerometerEvent.hx

@@ -0,0 +1,23 @@
+package flash.events; #if (!display && flash)
+
+
+@:require(flash10_1)
+
+extern class AccelerometerEvent extends Event {
+	
+	
+	public static var UPDATE (default, never):String;
+	public var accelerationX:Float;
+	public var accelerationY:Float;
+	public var accelerationZ:Float;
+	public var timestamp:Float;
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, timestamp:Float = 0, accelerationX:Float = 0, accelerationY:Float = 0, accelerationZ:Float = 0):Void;
+	
+	
+}
+
+
+#else
+typedef AccelerometerEvent = openfl.events.AccelerometerEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/ActivityEvent.hx

@@ -0,0 +1,20 @@
+package flash.events; #if (!display && flash)
+
+
+extern class ActivityEvent extends Event {
+	
+	
+	public static var ACTIVITY (default, never):String;
+	
+	public var activating:Bool;
+	
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, activating:Bool = false);
+	
+	
+}
+
+
+#else
+typedef ActivityEvent = openfl.events.ActivityEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/AsyncErrorEvent.hx

@@ -0,0 +1,23 @@
+package flash.events; #if (!display && flash)
+
+
+import haxe.io.Error;
+
+
+extern class AsyncErrorEvent extends ErrorEvent {
+	
+	
+	public static var ASYNC_ERROR (default, never):String;
+	
+	public var error:Error;
+	
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, text:String = "", error:Error = null);
+	
+	
+}
+
+
+#else
+typedef AsyncErrorEvent = openfl.events.AsyncErrorEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/ContextMenuEvent.hx

@@ -0,0 +1,30 @@
+package flash.events; #if (!display && flash)
+
+
+import openfl.display.InteractiveObject;
+
+
+extern class ContextMenuEvent extends Event {
+	
+	
+	public static var MENU_ITEM_SELECT (default, never):String;
+	public static var MENU_SELECT (default, never):String;
+	
+	public var contextMenuOwner:InteractiveObject;
+	
+	#if flash
+	@:require(flash10) public var isMouseTargetInaccessible:Bool;
+	#end
+	
+	public var mouseTarget:InteractiveObject;
+	
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, mouseTarget:InteractiveObject = null, contextMenuOwner:InteractiveObject = null);
+	
+	
+}
+
+
+#else
+typedef ContextMenuEvent = openfl.events.ContextMenuEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/DataEvent.hx

@@ -0,0 +1,21 @@
+package flash.events; #if (!display && flash)
+
+
+extern class DataEvent extends TextEvent {
+	
+	
+	public static var DATA (default, never):String;
+	public static var UPLOAD_COMPLETE_DATA (default, never):String;
+	
+	public var data:String;
+	
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, data:String = "");
+	
+	
+}
+
+
+#else
+typedef DataEvent = openfl.events.DataEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/ErrorEvent.hx

@@ -0,0 +1,19 @@
+package flash.events; #if (!display && flash)
+
+
+extern class ErrorEvent extends TextEvent {
+	
+	
+	public static var ERROR (default, never):String;
+	
+	@:require(flash10_1) public var errorID (default, never):Int;
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, text:String = "", id:Int = 0):Void;
+	
+	
+}
+
+
+#else
+typedef ErrorEvent = openfl.events.ErrorEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/Event.hx

@@ -0,0 +1,145 @@
+package flash.events; #if (!display && flash)
+
+
+extern class Event {
+	
+	
+	public static var ACTIVATE (default, never):String;
+	public static var ADDED (default, never):String;
+	public static var ADDED_TO_STAGE (default, never):String;
+	
+	#if flash
+	@:require(flash15) public static var BROWSER_ZOOM_CHANGE (default, never):String;
+	#end
+	
+	public static var CANCEL (default, never):String;
+	public static var CHANGE (default, never):String;
+	
+	#if flash
+	public static var CHANNEL_MESSAGE (default, never):String;
+	#end
+	
+	#if flash
+	public static var CHANNEL_STATE (default, never):String;
+	#end
+	
+	@:require(flash10) public static var CLEAR (default, never):String;
+	public static var CLOSE (default, never):String;
+	
+	#if (flash && air)
+	public static var CLOSING (default, never):String;
+	#end
+	
+	public static var COMPLETE (default, never):String;
+	public static var CONNECT (default, never):String;
+	@:require(flash11) public static var CONTEXT3D_CREATE (default, never):String;
+	@:require(flash10) public static var COPY (default, never):String;
+	@:require(flash10) public static var CUT (default, never):String;
+	public static var DEACTIVATE (default, never):String;
+	
+	#if air
+	public static var DISPLAYING (default, never):String;
+	#end
+	
+	public static var ENTER_FRAME (default, never):String;
+	
+	#if air
+	public static var EXITING (default, never):String;
+	#end
+	
+	@:require(flash10) public static var EXIT_FRAME (default, never):String;
+	@:require(flash10) public static var FRAME_CONSTRUCTED (default, never):String;
+	@:require(flash11_3) public static var FRAME_LABEL (default, never):String;
+	public static var FULLSCREEN (default, never):String;
+	
+	#if air
+	public static var HTML_BOUNDS_CHANGE (default, never):String;
+	public static var HTML_DOM_INITIALIZE (default, never):String;
+	public static var HTML_RENDER (default, never):String;
+	#end
+	
+	public static var ID3 (default, never):String;
+	public static var INIT (default, never):String;
+	
+	#if air
+	public static var LOCATION_CHANGE (default, never):String;
+	#end
+	
+	public static var MOUSE_LEAVE (default, never):String;
+	
+	#if air
+	public static var NETWORK_CHANGE (default, never):String;
+	#end
+	
+	public static var OPEN (default, never):String;
+	@:require(flash10) public static var PASTE (default, never):String;
+	
+	#if air
+	public static var PREPARING (default, never):String;
+	#end
+	
+	public static var REMOVED (default, never):String;
+	public static var REMOVED_FROM_STAGE (default, never):String;
+	public static var RENDER (default, never):String;
+	public static var RESIZE (default, never):String;
+	public static var SCROLL (default, never):String;
+	public static var SELECT (default, never):String;
+	@:require(flash10) public static var SELECT_ALL (default, never):String;
+	public static var SOUND_COMPLETE (default, never):String;
+	
+	#if air
+	public static var STANDARD_ERROR_CLOSE (default, never):String;
+	public static var STANDARD_INPUT_CLOSE (default, never):String;
+	public static var STANDARD_OUTPUT_CLOSE (default, never):String;
+	#end
+	
+	#if flash
+	@:require(flash11_3) public static var SUSPEND (default, never):String;
+	#end
+	
+	public static var TAB_CHILDREN_CHANGE (default, never):String;
+	public static var TAB_ENABLED_CHANGE (default, never):String;
+	public static var TAB_INDEX_CHANGE (default, never):String;
+	@:require(flash11_3) public static var TEXTURE_READY (default, never):String;
+	
+	#if flash
+	@:require(flash11) public static var TEXT_INTERACTION_MODE_CHANGE (default, never):String;
+	#end
+	
+	public static var UNLOAD (default, never):String;
+	
+	#if air
+	public static var USER_IDLE (default, never):String;
+	public static var USER_PRESENT (default, never):String;
+	#end
+	
+	#if flash
+	public static var VIDEO_FRAME (default, never):String;
+	#end
+	
+	#if flash
+	public static var WORKER_STATE (default, never):String;
+	#end
+	
+	public var bubbles (default, null):Bool;
+	public var cancelable (default, null):Bool;
+	public var currentTarget (default, null):#if (haxe_ver >= "3.4.2") Any #else IEventDispatcher #end;
+	public var eventPhase (default, null):EventPhase;
+	public var target (default, null):#if (haxe_ver >= "3.4.2") Any #else IEventDispatcher #end;
+	public var type (default, null):String;
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false);
+	public function clone ():Event;
+	public function formatToString (className:String, ?p1:Dynamic, ?p2:Dynamic, ?p3:Dynamic, ?p4:Dynamic, ?p5:Dynamic):String;
+	public function isDefaultPrevented ():Bool;
+	public function preventDefault ():Void;
+	public function stopImmediatePropagation ():Void;
+	public function stopPropagation ():Void;
+	public function toString ():String;
+	
+}
+
+
+#else
+typedef Event = openfl.events.Event;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/EventDispatcher.hx

@@ -0,0 +1,21 @@
+package flash.events; #if (!display && flash)
+
+
+extern class EventDispatcher implements IEventDispatcher {
+	
+	
+	public function new (target:IEventDispatcher = null):Void;
+	public function addEventListener (type:String, listener:Dynamic->Void, useCapture:Bool = false, priority:Int = 0, useWeakReference:Bool = false):Void;
+	public function dispatchEvent (event:Event):Bool;
+	public function hasEventListener (type:String):Bool;
+	public function removeEventListener (type:String, listener:Dynamic->Void, useCapture:Bool = false):Void;
+	public function toString ():String;
+	public function willTrigger (type:String):Bool;
+	
+	
+}
+
+
+#else
+typedef EventDispatcher = openfl.events.EventDispatcher;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/EventPhase.hx

@@ -0,0 +1,4 @@
+package flash.events;
+
+
+typedef EventPhase = openfl.events.EventPhase;

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/FocusEvent.hx

@@ -0,0 +1,35 @@
+package flash.events; #if (!display && flash)
+
+
+import openfl.display.InteractiveObject;
+
+
+extern class FocusEvent extends Event {
+	
+	
+	public static var FOCUS_IN (default, never):String;
+	public static var FOCUS_OUT (default, never):String;
+	public static var KEY_FOCUS_CHANGE (default, never):String;
+	public static var MOUSE_FOCUS_CHANGE (default, never):String;
+	
+	#if air
+	public var direction:flash.display.FocusDirection;
+	#end
+	
+	#if flash
+	@:require(flash10) public var isRelatedObjectInaccessible:Bool;
+	#end
+	
+	public var keyCode:Int;
+	public var relatedObject:InteractiveObject;
+	public var shiftKey:Bool;
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, relatedObject:InteractiveObject = null, shiftKey:Bool = false, keyCode:Int = 0);
+	
+	
+}
+
+
+#else
+typedef FocusEvent = openfl.events.FocusEvent;
+#end

hGameTest/node_modules/openfl/src/externs/core/flash/flash/events/FullScreenEvent.hx

@@ -0,0 +1,22 @@
+package flash.events; #if (!display && flash)
+
+
+extern class FullScreenEvent extends ActivityEvent {
+	
+	
+	public static var FULL_SCREEN (default, never):String;
+	@:require(flash11_3) public static var FULL_SCREEN_INTERACTIVE_ACCEPTED (default, never):String;
+	
+	public var fullScreen:Bool;
+	@:require(flash11_3) public var interactive:Bool;
+	
+	
+	public function new (type:String, bubbles:Bool = false, cancelable:Bool = false, fullScreen:Bool = false, interactive:Bool = false);
+	
+	
+}
+
+
+#else
+typedef FullScreenEvent = openfl.events.FullScreenEvent;
+#end