First commit

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

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

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

@@ -0,0 +1,82 @@
+// Class: haxe.ds.EnumValueMap
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+var $import = require("./../../import_stub").default;
+var $extend = require("./../../extend_stub").default;
+function haxe_IMap() {return require("./../../haxe/IMap");}
+function haxe_ds_BalancedTree() {return require("./../../haxe/ds/BalancedTree");}
+function Type() {return require("./../../Type");}
+function Reflect() {return require("./../../Reflect");}
+
+// Constructor
+
+var EnumValueMap = function() {
+	(haxe_ds_BalancedTree().default).call(this);
+}
+
+// Meta
+
+EnumValueMap.__name__ = ["haxe","ds","EnumValueMap"];
+EnumValueMap.__interfaces__ = [(haxe_IMap().default)];
+EnumValueMap.__super__ = (haxe_ds_BalancedTree().default);
+EnumValueMap.prototype = $extend((haxe_ds_BalancedTree().default).prototype, {
+	compare: function(k1,k2) {
+		var d = (Type().default).enumIndex(k1) - (Type().default).enumIndex(k2);
+		if(d != 0) {
+			return d;
+		}
+		var p1 = (Type().default).enumParameters(k1);
+		var p2 = (Type().default).enumParameters(k2);
+		if(p1.length == 0 && p2.length == 0) {
+			return 0;
+		}
+		return this.compareArgs(p1,p2);
+	},
+	compareArgs: function(a1,a2) {
+		var ld = a1.length - a2.length;
+		if(ld != 0) {
+			return ld;
+		}
+		var _g1 = 0;
+		var _g = a1.length;
+		while(_g1 < _g) {
+			var i = _g1++;
+			var d = this.compareArg(a1[i],a2[i]);
+			if(d != 0) {
+				return d;
+			}
+		}
+		return 0;
+	},
+	compareArg: function(v1,v2) {
+		if((Reflect().default).isEnumValue(v1) && (Reflect().default).isEnumValue(v2)) {
+			return this.compare(v1,v2);
+		} else if((v1 instanceof Array) && v1.__enum__ == null && ((v2 instanceof Array) && v2.__enum__ == null)) {
+			return this.compareArgs(v1,v2);
+		} else {
+			return (Reflect().default).compare(v1,v2);
+		}
+	}
+});
+EnumValueMap.prototype.__class__ = $hxClasses["haxe.ds.EnumValueMap"] = EnumValueMap;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = EnumValueMap;

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

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

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

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

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

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

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

@@ -0,0 +1,67 @@
+// Class: haxe.ds.TreeNode
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../hxClasses_stub").default;
+
+// Constructor
+
+var TreeNode = function(l,k,v,r,h) {
+	if(h == null) {
+		h = -1;
+	}
+	this.left = l;
+	this.key = k;
+	this.value = v;
+	this.right = r;
+	if(h == -1) {
+		var tmp;
+		var _this = this.left;
+		var _this1 = this.right;
+		if((_this == null ? 0 : _this._height) > (_this1 == null ? 0 : _this1._height)) {
+			var _this2 = this.left;
+			if(_this2 == null) {
+				tmp = 0;
+			} else {
+				tmp = _this2._height;
+			}
+		} else {
+			var _this3 = this.right;
+			if(_this3 == null) {
+				tmp = 0;
+			} else {
+				tmp = _this3._height;
+			}
+		}
+		this._height = tmp + 1;
+	} else {
+		this._height = h;
+	}
+}
+
+// Meta
+
+TreeNode.__name__ = ["haxe","ds","TreeNode"];
+TreeNode.prototype = {
+	
+};
+TreeNode.prototype.__class__ = $hxClasses["haxe.ds.TreeNode"] = TreeNode;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = TreeNode;

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

@@ -0,0 +1,46 @@
+// Class: haxe.ds._StringMap.StringMapIterator
+
+var $global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this
+
+$global.Object.defineProperty(exports, "__esModule", {value: true});
+
+var __map_reserved = {};
+
+// Imports
+
+var $hxClasses = require("./../../../hxClasses_stub").default;
+
+// Constructor
+
+var StringMapIterator = function(map,keys) {
+	this.map = map;
+	this.keys = keys;
+	this.index = 0;
+	this.count = keys.length;
+}
+
+// Meta
+
+StringMapIterator.__name__ = ["haxe","ds","_StringMap","StringMapIterator"];
+StringMapIterator.prototype = {
+	hasNext: function() {
+		return this.index < this.count;
+	},
+	next: function() {
+		return this.map.get(this.keys[this.index++]);
+	}
+};
+StringMapIterator.prototype.__class__ = $hxClasses["haxe.ds._StringMap.StringMapIterator"] = StringMapIterator;
+
+// Init
+
+
+
+// Statics
+
+
+
+
+// Export
+
+exports.default = StringMapIterator;

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

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