First commit

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,85 @@
+// Class: haxe.io.Path
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+function HxOverrides() {return require("./../../HxOverrides");}
+
+// Constructor
+
+var Path = function(path) {
+	switch(path) {
+	case ".":case "..":
+		this.dir = path;
+		this.file = "";
+		return;
+	}
+	var c1 = path.lastIndexOf("/");
+	var c2 = path.lastIndexOf("\\");
+	if(c1 < c2) {
+		this.dir = (HxOverrides().default).substr(path,0,c2);
+		path = (HxOverrides().default).substr(path,c2 + 1,null);
+		this.backslash = true;
+	} else if(c2 < c1) {
+		this.dir = (HxOverrides().default).substr(path,0,c1);
+		path = (HxOverrides().default).substr(path,c1 + 1,null);
+	} else {
+		this.dir = null;
+	}
+	var cp = path.lastIndexOf(".");
+	if(cp != -1) {
+		this.ext = (HxOverrides().default).substr(path,cp + 1,null);
+		this.file = (HxOverrides().default).substr(path,0,cp);
+	} else {
+		this.ext = null;
+		this.file = path;
+	}
+}
+
+// Meta
+
+Path.__name__ = ["haxe","io","Path"];
+Path.prototype = {
+	toString: function() {
+		return (this.dir == null ? "" : this.dir + (this.backslash ? "\\" : "/")) + this.file + (this.ext == null ? "" : "." + this.ext);
+	}
+};
+Path.prototype.__class__ = $hxClasses["haxe.io.Path"] = Path;
+
+// Init
+
+
+
+// Statics
+
+Path.withoutDirectory = function(path) {
+	var s = new Path(path);
+	s.dir = null;
+	return s.toString();
+}
+Path.directory = function(path) {
+	var s = new Path(path);
+	if(s.dir == null) {
+		return "";
+	}
+	return s.dir;
+}
+Path.extension = function(path) {
+	var s = new Path(path);
+	if(s.ext == null) {
+		return "";
+	}
+	return s.ext;
+}
+
+
+// Export
+
+exports.default = Path;