main.js

// Generated by Haxe 3.3.0 (git build development @ 6eb9c9a)
if (process.version < "v4.0.0") console.warn("Module " + (typeof(module) == "undefined" ? "" : module.filename) + " requires node.js version 4.0.0 or higher");
(function ($hx_exports, $global) { "use strict";
$hx_exports["promhx"] = $hx_exports["promhx"] || {};
var $estr = function() { return js_Boot.__string_rec(this,''); };
function $extend(from, fields) {
	function Inherit() {} Inherit.prototype = from; var proto = new Inherit();
	for (var name in fields) proto[name] = fields[name];
	if( fields.toString !== Object.prototype.toString ) proto.toString = fields.toString;
	return proto;
}
var AsyncTools = function() { };
AsyncTools.__name__ = ["AsyncTools"];
AsyncTools.aMapLimit = function(iterable,limit,cb,done) {
	AsyncTools.aForEachOfMapLimit(iterable,limit,function(item,_,done1) {
		cb(item,done1);
	},done);
};
AsyncTools.aMapSeries = function(iterable,cb,done) {
	AsyncTools.aMapLimit(iterable,1,cb,done);
};
AsyncTools.aEachLimit = function(iterable,limit,cb,done) {
	AsyncTools.aMapLimit(iterable,limit,function(item,done1) {
		cb(item,function(err) {
			done1(err,true);
		});
	},function(err1,items) {
		done(err1);
	});
};
AsyncTools.aEachSeries = function(iterable,cb,done) {
	AsyncTools.aEachLimit(iterable,1,cb,done);
};
AsyncTools.aForEachOfMapLimit = function(iterable,limit,cb,done) {
	var complete = new haxe_ds_IntMap();
	var it = $iterator(iterable)();
	var completed = false;
	var running = 0;
	var pos = 0;
	var completedItems = function() {
		var currentPos = pos;
		var _g = [];
		var _g2 = 0;
		while(_g2 < currentPos) _g.push(complete.h[_g2++]);
		return _g;
	};
	var next = null;
	next = function() {
		if(!completed) {
			if(!it.hasNext()) {
				if(running <= 0) {
					if(!completed) {
						completed = true;
						var tmp = completedItems();
						done(null,tmp);
					}
				}
			} else {
				var nextItem = it.next();
				pos += 1;
				var currentPos1 = pos - 1;
				running += 1;
				cb(nextItem,currentPos1,function(err,mapped) {
					if(!completed) {
						if(err != null) {
							if(!completed) {
								completed = true;
								var tmp1 = completedItems();
								done(err,tmp1);
							}
						} else {
							running -= 1;
							complete.h[currentPos1] = mapped;
							next();
						}
					}
				});
				if(!completed) {
					if(limit == 0 || running < limit) {
						next();
					}
				}
			}
		}
	};
	next();
};
var buddy_BuddySuite = function() {
	this.timeoutMs = 5000;
	this.suite = this.currentSuite = new buddy_TestSuite("");
	this.describeQueue = [];
};
buddy_BuddySuite.__name__ = ["buddy","BuddySuite"];
buddy_BuddySuite.prototype = {
	suite: null
	,currentSuite: null
	,describeQueue: null
	,timeoutMs: null
	,describe: function(description,spec,_hasInclude) {
		if(_hasInclude == null) {
			_hasInclude = false;
		}
		var suite = new buddy_TestSuite(description);
		this.currentSuite.specs.add(buddy_TestSpec.Describe(suite,_hasInclude));
		this.describeQueue.push({ suite : suite, spec : spec});
	}
	,beforeEach: function(init) {
		this.currentSuite.beforeEach.add(init);
	}
	,it: function(desc,spec,_hasInclude) {
		if(_hasInclude == null) {
			_hasInclude = false;
		}
		if(this.currentSuite == this.suite) {
			throw new js__$Boot_HaxeError("Cannot use 'it' outside of a describe block.");
		}
		this.currentSuite.specs.add(buddy_TestSpec.It(desc,spec,_hasInclude));
	}
	,xit: function(desc,spec,_hasInclude) {
		if(_hasInclude == null) {
			_hasInclude = false;
		}
		if(this.currentSuite == this.suite) {
			throw new js__$Boot_HaxeError("Cannot use 'it' outside of a describe block.");
		}
		this.currentSuite.specs.add(buddy_TestSpec.It(desc,null,_hasInclude));
	}
	,fail: null
	,pending: null
	,__class__: buddy_BuddySuite
};
var ContextTest = function() {
	var _gthis = this;
	buddy_BuddySuite.call(this);
	this.describe("A new Mustache.Context",buddy_TestFunc.Sync(function() {
		var context;
		var tmp = buddy_TestFunc.Sync(function() {
			context = new mustache__$Context_ContextImpl({ name : "parent", message : "hi", a : { b : "b"}},null,null);
		});
		_gthis.beforeEach(tmp);
		var tmp1 = buddy_TestFunc.Sync(function() {
			utest_Assert.equals("parent",context.lookup("name"),null,{ fileName : "ContextTest.hx", lineNumber : 13, className : "ContextTest", methodName : "new"});
		});
		_gthis.it("is able to lookup properties of its own view",tmp1);
		var tmp2 = buddy_TestFunc.Sync(function() {
			utest_Assert.equals("b",context.lookup("a.b"),null,{ fileName : "ContextTest.hx", lineNumber : 17, className : "ContextTest", methodName : "new"});
		});
		_gthis.it("is able to lookup nested properties of its own view",tmp2);
		var tmp3 = buddy_TestFunc.Sync(function() {
			var tmp4 = buddy_TestFunc.Sync(function() {
				context = new mustache__$Context_ContextImpl({ name : "child", c : { d : "d"}},context,null);
			});
			_gthis.beforeEach(tmp4);
			var tmp5 = buddy_TestFunc.Sync(function() {
				utest_Assert.equals("child",context.view.name,null,{ fileName : "ContextTest.hx", lineNumber : 26, className : "ContextTest", methodName : "new"});
				utest_Assert.equals("parent",context.parent.view.name,null,{ fileName : "ContextTest.hx", lineNumber : 27, className : "ContextTest", methodName : "new"});
			});
			_gthis.it("returns the child context",tmp5);
			var tmp6 = buddy_TestFunc.Sync(function() {
				utest_Assert.equals("child",context.lookup("name"),null,{ fileName : "ContextTest.hx", lineNumber : 31, className : "ContextTest", methodName : "new"});
			});
			_gthis.it("is able to lookup properties of its own view",tmp6);
			var tmp7 = buddy_TestFunc.Sync(function() {
				utest_Assert.equals("hi",context.lookup("message"),null,{ fileName : "ContextTest.hx", lineNumber : 35, className : "ContextTest", methodName : "new"});
			});
			_gthis.it("is able to lookup properties of the parent context's view",tmp7);
			var tmp8 = buddy_TestFunc.Sync(function() {
				utest_Assert.equals("d",context.lookup("c.d"),null,{ fileName : "ContextTest.hx", lineNumber : 39, className : "ContextTest", methodName : "new"});
			});
			_gthis.it("is able to lookup nested properties of its own view",tmp8);
			var tmp9 = buddy_TestFunc.Sync(function() {
				utest_Assert.equals("b",context.lookup("a.b"),null,{ fileName : "ContextTest.hx", lineNumber : 43, className : "ContextTest", methodName : "new"});
			});
			_gthis.it("is able to lookup nested properties of its parent view",tmp9);
		});
		_gthis.describe("when pushed",tmp3);
	}));
};
ContextTest.__name__ = ["ContextTest"];
ContextTest.__super__ = buddy_BuddySuite;
ContextTest.prototype = $extend(buddy_BuddySuite.prototype,{
	__class__: ContextTest
});
var EReg = function(r,opt) {
	this.r = new RegExp(r,opt.split("u").join(""));
};
EReg.__name__ = ["EReg"];
EReg.prototype = {
	r: null
	,match: function(s) {
		if(this.r.global) {
			this.r.lastIndex = 0;
		}
		this.r.m = this.r.exec(s);
		this.r.s = s;
		return this.r.m != null;
	}
	,matched: function(n) {
		if(this.r.m != null && n >= 0 && n < this.r.m.length) {
			return this.r.m[n];
		} else {
			throw new js__$Boot_HaxeError("EReg::matched");
		}
	}
	,matchedPos: function() {
		if(this.r.m == null) {
			throw new js__$Boot_HaxeError("No string matched");
		}
		return { pos : this.r.m.index, len : this.r.m[0].length};
	}
	,matchSub: function(s,pos,len) {
		if(len == null) {
			len = -1;
		}
		if(this.r.global) {
			this.r.lastIndex = pos;
			var tmp = this.r;
			var tmp1 = len < 0?s:HxOverrides.substr(s,0,pos + len);
			this.r.m = tmp.exec(tmp1);
			var b = this.r.m != null;
			if(b) {
				this.r.s = s;
			}
			return b;
		} else {
			var b1 = this.match(len < 0?HxOverrides.substr(s,pos,null):HxOverrides.substr(s,pos,len));
			if(b1) {
				this.r.s = s;
				this.r.m.index += pos;
			}
			return b1;
		}
	}
	,split: function(s) {
		var d = "#__delim__#";
		return s.replace(this.r,d).split(d);
	}
	,map: function(s,f) {
		var offset = 0;
		var buf_b = "";
		while(true) {
			if(offset >= s.length) {
				break;
			} else if(!this.matchSub(s,offset)) {
				buf_b += Std.string(HxOverrides.substr(s,offset,null));
				break;
			}
			var p = this.matchedPos();
			buf_b += Std.string(HxOverrides.substr(s,offset,p.pos - offset));
			buf_b += Std.string(f(this));
			if(p.len == 0) {
				buf_b += Std.string(HxOverrides.substr(s,p.pos,1));
				offset = p.pos + 1;
			} else {
				offset = p.pos + p.len;
			}
			if(!this.r.global) {
				break;
			}
		}
		if(!this.r.global && offset > 0 && offset < s.length) {
			buf_b += Std.string(HxOverrides.substr(s,offset,null));
		}
		return buf_b;
	}
	,__class__: EReg
};
var HxOverrides = function() { };
HxOverrides.__name__ = ["HxOverrides"];
HxOverrides.strDate = function(s) {
	var _g = s.length;
	switch(_g) {
	case 8:
		var k = s.split(":");
		var d = new Date();
		d.setTime(0);
		d.setUTCHours(k[0]);
		d.setUTCMinutes(k[1]);
		d.setUTCSeconds(k[2]);
		return d;
	case 10:
		var k1 = s.split("-");
		return new Date(k1[0],k1[1] - 1,k1[2],0,0,0);
	case 19:
		var k2 = s.split(" ");
		var y = k2[0].split("-");
		var t = k2[1].split(":");
		return new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
	default:
		throw new js__$Boot_HaxeError("Invalid date format : " + s);
	}
};
HxOverrides.cca = function(s,index) {
	var x = s.charCodeAt(index);
	if(x != x) {
		return undefined;
	}
	return x;
};
HxOverrides.substr = function(s,pos,len) {
	if(len == null) {
		len = s.length;
	} else if(len < 0) {
		if(pos == 0) {
			len = s.length + len;
		} else {
			return "";
		}
	}
	return s.substr(pos,len);
};
HxOverrides.remove = function(a,obj) {
	var i = a.indexOf(obj);
	if(i == -1) {
		return false;
	}
	a.splice(i,1);
	return true;
};
HxOverrides.iter = function(a) {
	return { cur : 0, arr : a, hasNext : function() {
		return this.cur < this.arr.length;
	}, next : function() {
		return this.arr[this.cur++];
	}};
};
var Lambda = function() { };
Lambda.__name__ = ["Lambda"];
Lambda.array = function(it) {
	var a = [];
	var tmp = $iterator(it)();
	while(tmp.hasNext()) a.push(tmp.next());
	return a;
};
Lambda.has = function(it,elt) {
	var tmp = $iterator(it)();
	while(tmp.hasNext()) if(tmp.next() == elt) {
		return true;
	}
	return false;
};
Lambda.exists = function(it,f) {
	var tmp = $iterator(it)();
	while(tmp.hasNext()) if(f(tmp.next())) {
		return true;
	}
	return false;
};
Lambda.iter = function(it,f) {
	var tmp = $iterator(it)();
	while(tmp.hasNext()) f(tmp.next());
};
Lambda.filter = function(it,f) {
	var l = new List();
	var tmp = $iterator(it)();
	while(tmp.hasNext()) {
		var x = tmp.next();
		if(f(x)) {
			l.add(x);
		}
	}
	return l;
};
Lambda.empty = function(it) {
	return !$iterator(it)().hasNext();
};
var List = function() {
	this.length = 0;
};
List.__name__ = ["List"];
List.prototype = {
	h: null
	,q: null
	,length: null
	,add: function(item) {
		var x = new _$List_ListNode(item,null);
		if(this.h == null) {
			this.h = x;
		} else {
			this.q.next = x;
		}
		this.q = x;
		this.length++;
	}
	,pop: function() {
		if(this.h == null) {
			return null;
		}
		var x = this.h.item;
		this.h = this.h.next;
		if(this.h == null) {
			this.q = null;
		}
		this.length--;
		return x;
	}
	,isEmpty: function() {
		return this.h == null;
	}
	,iterator: function() {
		return new _$List_ListIterator(this.h);
	}
	,filter: function(f) {
		var l2 = new List();
		var l = this.h;
		while(l != null) {
			var v = l.item;
			l = l.next;
			if(f(v)) {
				l2.add(v);
			}
		}
		return l2;
	}
	,__class__: List
};
var _$List_ListNode = function(item,next) {
	this.item = item;
	this.next = next;
};
_$List_ListNode.__name__ = ["_List","ListNode"];
_$List_ListNode.prototype = {
	item: null
	,next: null
	,__class__: _$List_ListNode
};
var _$List_ListIterator = function(head) {
	this.head = head;
};
_$List_ListIterator.__name__ = ["_List","ListIterator"];
_$List_ListIterator.prototype = {
	head: null
	,hasNext: function() {
		return this.head != null;
	}
	,next: function() {
		var val = this.head.item;
		this.head = this.head.next;
		return val;
	}
	,__class__: _$List_ListIterator
};
Math.__name__ = ["Math"];
var mustache_Writer = function() {
	this.cache = new haxe_ds_StringMap();
};
mustache_Writer.__name__ = ["mustache","Writer"];
mustache_Writer.escapeHTML = function(string) {
	return mustache_Writer.escapeRe.map(string,function(re) {
		var this1 = mustache_Writer.entityMap;
		var key = re.matched(0);
		var _this = this1;
		if(__map_reserved[key] != null) {
			return _this.getReserved(key);
		} else {
			return _this.h[key];
		}
	});
};
mustache_Writer.prototype = {
	cache: null
	,parse: function(template,tags) {
		var _this = this.cache;
		var tokens = __map_reserved[template] != null?_this.getReserved(template):_this.h[template];
		if(tokens == null) {
			var this1 = this.cache;
			var v = mustache_Parser.parse(template,tags);
			var _this1 = this1;
			if(__map_reserved[template] != null) {
				_this1.setReserved(template,v);
			} else {
				_this1.h[template] = v;
			}
			tokens = v;
		}
		return tokens;
	}
	,render: function(template,context,partials) {
		return this.renderTokens(this.parse(template),context,partials,template);
	}
	,renderTokens: function(tokens,context,partials,originalTemplate) {
		var buffer = "";
		var _g = 0;
		while(_g < tokens.length) {
			var token = tokens[_g];
			++_g;
			var value;
			var _g1 = token.type;
			switch(_g1[1]) {
			case 0:
				value = token.value;
				break;
			case 1:
				var value1 = context.lookup(token.value);
				if(value1 == null) {
					value = null;
				} else if(_g1[2]) {
					value = mustache_Writer.escapeHTML(Std.string(value1));
				} else {
					value = Std.string(value1);
				}
				break;
			case 2:
				if(_g1[2]) {
					value = this.renderInverted(token,context,partials,originalTemplate);
				} else {
					value = this.renderSection(token,context,partials,originalTemplate);
				}
				break;
			case 4:
				value = this.renderPartial(token,context,partials);
				break;
			case 3:case 5:case 6:
				continue;
				break;
			case 7:
				value = this.renderPartialOverride(token,context,partials);
				break;
			case 8:
				value = this.renderTokens(this.resolveBlock(token,context).subTokens,context,partials,originalTemplate);
				break;
			}
			if(value != null) {
				buffer += value;
			}
		}
		return buffer;
	}
	,renderSection: function(token,context,partials,originalTemplate) {
		var _gthis = this;
		var _g = Mustache.getSectionValueKind(context.lookup(token.value));
		switch(_g[1]) {
		case 0:
			return null;
		case 1:
			var arr = _g[2];
			var buffer = "";
			var len = arr.length;
			var _g1 = 0;
			while(_g1 < len) buffer += this.renderTokens(token.subTokens,new mustache__$Context_ContextImpl(arr[_g1++],context,null),partials,originalTemplate);
			return buffer;
		case 2:
			return this.renderTokens(token.subTokens,new mustache__$Context_ContextImpl(_g[2],context,null),partials,originalTemplate);
		case 3:
			return this.renderTokens(token.subTokens,context,partials,originalTemplate);
		case 4:
			return _g[2](originalTemplate.substring(token.endIndex,token.sectionEndIndex),function(template) {
				return _gthis.render(template,context,partials);
			});
		}
	}
	,renderInverted: function(token,context,partials,originalTemplate) {
		if(Mustache.getSectionValueKind(context.lookup(token.value))[1] == 0) {
			return this.renderTokens(token.subTokens,context,partials,originalTemplate);
		} else {
			return null;
		}
	}
	,renderPartial: function(token,context,partials) {
		if(partials == null) {
			return null;
		}
		var value = partials(token.value);
		if(value != null) {
			return this.renderTokens(this.parse(value),context,partials,value);
		}
		return null;
	}
	,renderPartialOverride: function(token,context,partials) {
		if(partials == null) {
			return null;
		}
		var value = partials(token.value);
		if(value == null) {
			return null;
		}
		return this.renderTokens(this.parse(value),new mustache__$Context_ContextImpl({ },context,token),partials,value);
	}
	,resolveBlock: function(token,context) {
		var resultToken = token;
		while(context != null) {
			if(context.partialOverride != null) {
				var _g = 0;
				var _g1 = context.partialOverride.subTokens;
				while(_g < _g1.length) {
					var overrideToken = _g1[_g];
					++_g;
					if(overrideToken.type == mustache_TokenType.Block && overrideToken.value == token.value) {
						resultToken = overrideToken;
					}
				}
			}
			context = context.parent;
		}
		return resultToken;
	}
	,__class__: mustache_Writer
};
var Mustache = function() { };
Mustache.__name__ = ["Mustache"];
Mustache.getSectionValueKind = function(value) {
	if(value == null) {
		return SectionValueKind.KFalsy;
	}
	if(typeof(value) == "boolean") {
		if(value) {
			return SectionValueKind.KBasic;
		} else {
			return SectionValueKind.KFalsy;
		}
	}
	if(typeof(value) == "number") {
		if(value != 0) {
			return SectionValueKind.KBasic;
		} else {
			return SectionValueKind.KFalsy;
		}
	}
	var value1 = value;
	var str = (value1 instanceof String)?value1:null;
	if(str != null) {
		if(str.length > 0) {
			return SectionValueKind.KObject(str);
		} else {
			return SectionValueKind.KFalsy;
		}
	}
	var value2 = value;
	var arr = (value2 instanceof Array)?value2:null;
	if(arr != null) {
		if(arr.length > 0) {
			return SectionValueKind.KArray(arr);
		} else {
			return SectionValueKind.KFalsy;
		}
	}
	if(Reflect.isFunction(value)) {
		return SectionValueKind.KFunction(value);
	}
	if(Reflect.isObject(value)) {
		return SectionValueKind.KObject(value);
	}
	return SectionValueKind.KBasic;
};
var SectionValueKind = { __ename__ : ["SectionValueKind"], __constructs__ : ["KFalsy","KArray","KObject","KBasic","KFunction"] };
SectionValueKind.KFalsy = ["KFalsy",0];
SectionValueKind.KFalsy.toString = $estr;
SectionValueKind.KFalsy.__enum__ = SectionValueKind;
SectionValueKind.KArray = function(a) { var $x = ["KArray",1,a]; $x.__enum__ = SectionValueKind; $x.toString = $estr; return $x; };
SectionValueKind.KObject = function(o) { var $x = ["KObject",2,o]; $x.__enum__ = SectionValueKind; $x.toString = $estr; return $x; };
SectionValueKind.KBasic = ["KBasic",3];
SectionValueKind.KBasic.toString = $estr;
SectionValueKind.KBasic.__enum__ = SectionValueKind;
SectionValueKind.KFunction = function(f) { var $x = ["KFunction",4,f]; $x.__enum__ = SectionValueKind; $x.toString = $estr; return $x; };
var ParseTest = function() {
	var _gthis = this;
	buddy_BuddySuite.call(this);
	var _g = new haxe_ds_StringMap();
	var value = [];
	if(__map_reserved[""] != null) {
		_g.setReserved("",value);
	} else {
		_g.h[""] = value;
	}
	var value1 = [new mustache_Token(mustache_TokenType.Value(true),"hi",0,6)];
	if(__map_reserved["{{hi}}"] != null) {
		_g.setReserved("{{hi}}",value1);
	} else {
		_g.h["{{hi}}"] = value1;
	}
	var value2 = [new mustache_Token(mustache_TokenType.Value(true),"hi.world",0,12)];
	if(__map_reserved["{{hi.world}}"] != null) {
		_g.setReserved("{{hi.world}}",value2);
	} else {
		_g.h["{{hi.world}}"] = value2;
	}
	var value3 = [new mustache_Token(mustache_TokenType.Value(true),"hi . world",0,14)];
	if(__map_reserved["{{hi . world}}"] != null) {
		_g.setReserved("{{hi . world}}",value3);
	} else {
		_g.h["{{hi . world}}"] = value3;
	}
	var value4 = [new mustache_Token(mustache_TokenType.Value(true),"hi",0,7)];
	if(__map_reserved["{{ hi}}"] != null) {
		_g.setReserved("{{ hi}}",value4);
	} else {
		_g.h["{{ hi}}"] = value4;
	}
	var value5 = [new mustache_Token(mustache_TokenType.Value(true),"hi",0,7)];
	if(__map_reserved["{{hi }}"] != null) {
		_g.setReserved("{{hi }}",value5);
	} else {
		_g.h["{{hi }}"] = value5;
	}
	var value6 = [new mustache_Token(mustache_TokenType.Value(true),"hi",0,8)];
	if(__map_reserved["{{ hi }}"] != null) {
		_g.setReserved("{{ hi }}",value6);
	} else {
		_g.h["{{ hi }}"] = value6;
	}
	var value7 = [new mustache_Token(mustache_TokenType.Value(false),"hi",0,8)];
	if(__map_reserved["{{{hi}}}"] != null) {
		_g.setReserved("{{{hi}}}",value7);
	} else {
		_g.h["{{{hi}}}"] = value7;
	}
	var value8 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,7)];
	if(__map_reserved["{{!hi}}"] != null) {
		_g.setReserved("{{!hi}}",value8);
	} else {
		_g.h["{{!hi}}"] = value8;
	}
	var value9 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,8)];
	if(__map_reserved["{{! hi}}"] != null) {
		_g.setReserved("{{! hi}}",value9);
	} else {
		_g.h["{{! hi}}"] = value9;
	}
	var value10 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,9)];
	if(__map_reserved["{{! hi }}"] != null) {
		_g.setReserved("{{! hi }}",value10);
	} else {
		_g.h["{{! hi }}"] = value10;
	}
	var value11 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,8)];
	if(__map_reserved["{{ !hi}}"] != null) {
		_g.setReserved("{{ !hi}}",value11);
	} else {
		_g.h["{{ !hi}}"] = value11;
	}
	var value12 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,9)];
	if(__map_reserved["{{ ! hi}}"] != null) {
		_g.setReserved("{{ ! hi}}",value12);
	} else {
		_g.h["{{ ! hi}}"] = value12;
	}
	var value13 = [new mustache_Token(mustache_TokenType.Comment,"hi",0,10)];
	if(__map_reserved["{{ ! hi }}"] != null) {
		_g.setReserved("{{ ! hi }}",value13);
	} else {
		_g.h["{{ ! hi }}"] = value13;
	}
	var value14 = [new mustache_Token(mustache_TokenType.Text,"a\n b",0,4)];
	if(__map_reserved["a\n b"] != null) {
		_g.setReserved("a\n b",value14);
	} else {
		_g.h["a\n b"] = value14;
	}
	var value15 = [new mustache_Token(mustache_TokenType.Text,"a",0,1),new mustache_Token(mustache_TokenType.Value(true),"hi",1,7)];
	if(__map_reserved["a{{hi}}"] != null) {
		_g.setReserved("a{{hi}}",value15);
	} else {
		_g.h["a{{hi}}"] = value15;
	}
	var value16 = [new mustache_Token(mustache_TokenType.Text,"a ",0,2),new mustache_Token(mustache_TokenType.Value(true),"hi",2,8)];
	if(__map_reserved["a {{hi}}"] != null) {
		_g.setReserved("a {{hi}}",value16);
	} else {
		_g.h["a {{hi}}"] = value16;
	}
	var value17 = [new mustache_Token(mustache_TokenType.Text," a",0,2),new mustache_Token(mustache_TokenType.Value(true),"hi",2,8)];
	if(__map_reserved[" a{{hi}}"] != null) {
		_g.setReserved(" a{{hi}}",value17);
	} else {
		_g.h[" a{{hi}}"] = value17;
	}
	var value18 = [new mustache_Token(mustache_TokenType.Text," a ",0,3),new mustache_Token(mustache_TokenType.Value(true),"hi",3,9)];
	if(__map_reserved[" a {{hi}}"] != null) {
		_g.setReserved(" a {{hi}}",value18);
	} else {
		_g.h[" a {{hi}}"] = value18;
	}
	var value19 = [new mustache_Token(mustache_TokenType.Text,"a",0,1),new mustache_Token(mustache_TokenType.Value(true),"hi",1,7),new mustache_Token(mustache_TokenType.Text,"b",7,8)];
	if(__map_reserved["a{{hi}}b"] != null) {
		_g.setReserved("a{{hi}}b",value19);
	} else {
		_g.h["a{{hi}}b"] = value19;
	}
	var value20 = [new mustache_Token(mustache_TokenType.Text,"a",0,1),new mustache_Token(mustache_TokenType.Value(true),"hi",1,7),new mustache_Token(mustache_TokenType.Text," b",7,9)];
	if(__map_reserved["a{{hi}} b"] != null) {
		_g.setReserved("a{{hi}} b",value20);
	} else {
		_g.h["a{{hi}} b"] = value20;
	}
	var value21 = [new mustache_Token(mustache_TokenType.Text,"a",0,1),new mustache_Token(mustache_TokenType.Value(true),"hi",1,7),new mustache_Token(mustache_TokenType.Text,"b ",7,9)];
	if(__map_reserved["a{{hi}}b "] != null) {
		_g.setReserved("a{{hi}}b ",value21);
	} else {
		_g.h["a{{hi}}b "] = value21;
	}
	var value22 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Value(true),"hi",2,8),new mustache_Token(mustache_TokenType.Text," b \n",8,12)];
	if(__map_reserved["a\n{{hi}} b \n"] != null) {
		_g.setReserved("a\n{{hi}} b \n",value22);
	} else {
		_g.h["a\n{{hi}} b \n"] = value22;
	}
	var value23 = [new mustache_Token(mustache_TokenType.Text,"a\n ",0,3),new mustache_Token(mustache_TokenType.Value(true),"hi",3,9),new mustache_Token(mustache_TokenType.Text," \nb",9,12)];
	if(__map_reserved["a\n {{hi}} \nb"] != null) {
		_g.setReserved("a\n {{hi}} \nb",value23);
	} else {
		_g.h["a\n {{hi}} \nb"] = value23;
	}
	var value24 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Comment,"hi",3,10),new mustache_Token(mustache_TokenType.Text,"b",12,13)];
	if(__map_reserved["a\n {{!hi}} \nb"] != null) {
		_g.setReserved("a\n {{!hi}} \nb",value24);
	} else {
		_g.h["a\n {{!hi}} \nb"] = value24;
	}
	var value25 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",2,8,[],8),new mustache_Token(mustache_TokenType.Text,"b",15,16)];
	if(__map_reserved["a\n{{#a}}{{/a}}\nb"] != null) {
		_g.setReserved("a\n{{#a}}{{/a}}\nb",value25);
	} else {
		_g.h["a\n{{#a}}{{/a}}\nb"] = value25;
	}
	var value26 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],9),new mustache_Token(mustache_TokenType.Text,"b",16,17)];
	if(__map_reserved["a\n {{#a}}{{/a}}\nb"] != null) {
		_g.setReserved("a\n {{#a}}{{/a}}\nb",value26);
	} else {
		_g.h["a\n {{#a}}{{/a}}\nb"] = value26;
	}
	var value27 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],9),new mustache_Token(mustache_TokenType.Text,"b",17,18)];
	if(__map_reserved["a\n {{#a}}{{/a}} \nb"] != null) {
		_g.setReserved("a\n {{#a}}{{/a}} \nb",value27);
	} else {
		_g.h["a\n {{#a}}{{/a}} \nb"] = value27;
	}
	var value28 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",2,8,[],9),new mustache_Token(mustache_TokenType.Text,"b",16,17)];
	if(__map_reserved["a\n{{#a}}\n{{/a}}\nb"] != null) {
		_g.setReserved("a\n{{#a}}\n{{/a}}\nb",value28);
	} else {
		_g.h["a\n{{#a}}\n{{/a}}\nb"] = value28;
	}
	var value29 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],10),new mustache_Token(mustache_TokenType.Text,"b",17,18)];
	if(__map_reserved["a\n {{#a}}\n{{/a}}\nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{/a}}\nb",value29);
	} else {
		_g.h["a\n {{#a}}\n{{/a}}\nb"] = value29;
	}
	var value30 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],10),new mustache_Token(mustache_TokenType.Text,"b",18,19)];
	if(__map_reserved["a\n {{#a}}\n{{/a}} \nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{/a}} \nb",value30);
	} else {
		_g.h["a\n {{#a}}\n{{/a}} \nb"] = value30;
	}
	var value31 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",2,8,[],9),new mustache_Token(mustache_TokenType.Section(false),"b",16,22,[],23),new mustache_Token(mustache_TokenType.Text,"b",30,31)];
	if(__map_reserved["a\n{{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb"] != null) {
		_g.setReserved("a\n{{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb",value31);
	} else {
		_g.h["a\n{{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb"] = value31;
	}
	var value32 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],10),new mustache_Token(mustache_TokenType.Section(false),"b",17,23,[],24),new mustache_Token(mustache_TokenType.Text,"b",31,32)];
	if(__map_reserved["a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb",value32);
	} else {
		_g.h["a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb"] = value32;
	}
	var value33 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[],10),new mustache_Token(mustache_TokenType.Section(false),"b",17,23,[],24),new mustache_Token(mustache_TokenType.Text,"b",32,33)];
	if(__map_reserved["a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}} \nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}} \nb",value33);
	} else {
		_g.h["a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}} \nb"] = value33;
	}
	var value34 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",2,8,[new mustache_Token(mustache_TokenType.Section(false),"b",9,15,[],16)],23),new mustache_Token(mustache_TokenType.Text,"b",30,31)];
	if(__map_reserved["a\n{{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb"] != null) {
		_g.setReserved("a\n{{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb",value34);
	} else {
		_g.h["a\n{{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb"] = value34;
	}
	var value35 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[new mustache_Token(mustache_TokenType.Section(false),"b",10,16,[],17)],24),new mustache_Token(mustache_TokenType.Text,"b",31,32)];
	if(__map_reserved["a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb",value35);
	} else {
		_g.h["a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb"] = value35;
	}
	var value36 = [new mustache_Token(mustache_TokenType.Text,"a\n",0,2),new mustache_Token(mustache_TokenType.Section(false),"a",3,9,[new mustache_Token(mustache_TokenType.Section(false),"b",10,16,[],17)],24),new mustache_Token(mustache_TokenType.Text,"b",32,33)];
	if(__map_reserved["a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}} \nb"] != null) {
		_g.setReserved("a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}} \nb",value36);
	} else {
		_g.h["a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}} \nb"] = value36;
	}
	var value37 = [new mustache_Token(mustache_TokenType.Partial,"abc",0,8)];
	if(__map_reserved["{{>abc}}"] != null) {
		_g.setReserved("{{>abc}}",value37);
	} else {
		_g.h["{{>abc}}"] = value37;
	}
	var value38 = [new mustache_Token(mustache_TokenType.Partial,"abc",0,10)];
	if(__map_reserved["{{> abc }}"] != null) {
		_g.setReserved("{{> abc }}",value38);
	} else {
		_g.h["{{> abc }}"] = value38;
	}
	var value39 = [new mustache_Token(mustache_TokenType.Partial,"abc",0,11)];
	if(__map_reserved["{{ > abc }}"] != null) {
		_g.setReserved("{{ > abc }}",value39);
	} else {
		_g.h["{{ > abc }}"] = value39;
	}
	var value40 = [new mustache_Token(mustache_TokenType.SetDelimiters,"<% %>",0,11)];
	if(__map_reserved["{{=<% %>=}}"] != null) {
		_g.setReserved("{{=<% %>=}}",value40);
	} else {
		_g.h["{{=<% %>=}}"] = value40;
	}
	var value41 = [new mustache_Token(mustache_TokenType.SetDelimiters,"<% %>",0,13)];
	if(__map_reserved["{{= <% %> =}}"] != null) {
		_g.setReserved("{{= <% %> =}}",value41);
	} else {
		_g.h["{{= <% %> =}}"] = value41;
	}
	var value42 = [new mustache_Token(mustache_TokenType.SetDelimiters,"<% %>",0,11),new mustache_Token(mustache_TokenType.SetDelimiters,"{{ }}",11,22)];
	if(__map_reserved["{{=<% %>=}}<%={{ }}=%>"] != null) {
		_g.setReserved("{{=<% %>=}}<%={{ }}=%>",value42);
	} else {
		_g.h["{{=<% %>=}}<%={{ }}=%>"] = value42;
	}
	var value43 = [new mustache_Token(mustache_TokenType.SetDelimiters,"<% %>",0,11),new mustache_Token(mustache_TokenType.Value(true),"hi",11,17)];
	if(__map_reserved["{{=<% %>=}}<%hi%>"] != null) {
		_g.setReserved("{{=<% %>=}}<%hi%>",value43);
	} else {
		_g.h["{{=<% %>=}}<%hi%>"] = value43;
	}
	var value44 = [new mustache_Token(mustache_TokenType.Section(false),"a",0,6,[],6),new mustache_Token(mustache_TokenType.Text,"hi",12,14),new mustache_Token(mustache_TokenType.Section(false),"b",14,20,[],20),new mustache_Token(mustache_TokenType.Text,"\n",26,27)];
	if(__map_reserved["{{#a}}{{/a}}hi{{#b}}{{/b}}\n"] != null) {
		_g.setReserved("{{#a}}{{/a}}hi{{#b}}{{/b}}\n",value44);
	} else {
		_g.h["{{#a}}{{/a}}hi{{#b}}{{/b}}\n"] = value44;
	}
	var value45 = [new mustache_Token(mustache_TokenType.Value(true),"a",0,5),new mustache_Token(mustache_TokenType.Text,"\n",5,6),new mustache_Token(mustache_TokenType.Value(true),"b",6,11),new mustache_Token(mustache_TokenType.Text,"\n\n",11,13),new mustache_Token(mustache_TokenType.Section(false),"c",13,19,[],20)];
	if(__map_reserved["{{a}}\n{{b}}\n\n{{#c}}\n{{/c}}\n"] != null) {
		_g.setReserved("{{a}}\n{{b}}\n\n{{#c}}\n{{/c}}\n",value45);
	} else {
		_g.h["{{a}}\n{{b}}\n\n{{#c}}\n{{/c}}\n"] = value45;
	}
	var value46 = [new mustache_Token(mustache_TokenType.Section(false),"foo",0,8,[new mustache_Token(mustache_TokenType.Section(false),"a",11,17,[new mustache_Token(mustache_TokenType.Text,"    ",18,22),new mustache_Token(mustache_TokenType.Value(true),"b",22,27),new mustache_Token(mustache_TokenType.Text,"\n",27,28)],30)],37)];
	if(__map_reserved["{{#foo}}\n  {{#a}}\n    {{b}}\n  {{/a}}\n{{/foo}}\n"] != null) {
		_g.setReserved("{{#foo}}\n  {{#a}}\n    {{b}}\n  {{/a}}\n{{/foo}}\n",value46);
	} else {
		_g.h["{{#foo}}\n  {{#a}}\n    {{b}}\n  {{/a}}\n{{/foo}}\n"] = value46;
	}
	var expectations = _g;
	this.describe("Mustache.parse",buddy_TestFunc.Sync(function() {
		var tmp = expectations.keys();
		while(tmp.hasNext()) {
			var template = [tmp.next()];
			var tmp1 = "knows how to parse " + JSON.stringify(template[0]);
			var tmp2 = buddy_TestFunc.Sync((function(template1) {
				return function() {
					utest_Assert.same(__map_reserved[template1[0]] != null?expectations.getReserved(template1[0]):expectations.h[template1[0]],Mustache.defaultWriter.parse(template1[0],null),null,null,null,{ fileName : "ParseTest.hx", lineNumber : 75, className : "ParseTest", methodName : "new"});
				};
			})(template));
			_gthis.it(tmp1,tmp2);
		}
		var tmp3 = buddy_TestFunc.Sync(function() {
			var tmp4 = buddy_TestFunc.Sync(function() {
				ParseTest["throws"](function() {
					Mustache.defaultWriter.parse("My name is {{name",null);
				},new EReg("unclosed tag at 17","i"));
			});
			_gthis.it("throws an error",tmp4);
		});
		_gthis.describe("when there is an unclosed tag",tmp3);
		var tmp5 = buddy_TestFunc.Sync(function() {
			var tmp6 = buddy_TestFunc.Sync(function() {
				ParseTest["throws"](function() {
					Mustache.defaultWriter.parse("A list: {{#people}}{{name}}",null);
				},new EReg("unclosed section \"people\" at 27","i"));
			});
			_gthis.it("throws an error",tmp6);
		});
		_gthis.describe("when there is an unclosed section",tmp5);
		var tmp7 = buddy_TestFunc.Sync(function() {
			var tmp8 = buddy_TestFunc.Sync(function() {
				ParseTest["throws"](function() {
					Mustache.defaultWriter.parse("The end of the list! {{/people}}",null);
				},new EReg("unopened section \"people\" at 21","i"));
			});
			_gthis.it("throws an error",tmp8);
		});
		_gthis.describe("when there is an unopened section",tmp7);
		var tmp9 = buddy_TestFunc.Sync(function() {
			var tmp10 = buddy_TestFunc.Sync(function() {
				ParseTest["throws"](function() {
					Mustache.defaultWriter.parse("A template <% name %>",["<%"]);
				},new EReg("invalid tags","i"));
			});
			_gthis.it("throws an error",tmp10);
		});
		_gthis.describe("when invalid tags are given as an argument",tmp9);
		var tmp11 = buddy_TestFunc.Sync(function() {
			var tmp12 = buddy_TestFunc.Sync(function() {
				ParseTest["throws"](function() {
					Mustache.defaultWriter.parse("A template {{=<%=}}",null);
				},new EReg("invalid tags","i"));
			});
			_gthis.it("throws an error",tmp12);
		});
		_gthis.describe("when the template contains invalid tags",tmp11);
	}));
};
ParseTest.__name__ = ["ParseTest"];
ParseTest["throws"] = function(fn,re) {
	try {
		fn();
	} catch( $e0 ) {
		haxe_CallStack.lastException = $e0;
		if ($e0 instanceof js__$Boot_HaxeError) $e0 = $e0.val;
		if( js_Boot.__instanceof($e0,String) ) {
			var e = $e0;
			utest_Assert.match(re,e,null,{ fileName : "ParseTest.hx", lineNumber : 9, className : "ParseTest", methodName : "throws"});
			return;
		} else {
		var e1 = $e0;
		throw new js__$Boot_HaxeError("not string thrown");
		}
	}
	throw new js__$Boot_HaxeError("no error thrown");
};
ParseTest.__super__ = buddy_BuddySuite;
ParseTest.prototype = $extend(buddy_BuddySuite.prototype,{
	__class__: ParseTest
});
var Reflect = function() { };
Reflect.__name__ = ["Reflect"];
Reflect.field = function(o,field) {
	try {
		return o[field];
	} catch( e ) {
		haxe_CallStack.lastException = e;
		return null;
	}
};
Reflect.fields = function(o) {
	var a = [];
	if(o != null) {
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		for( var f in o ) {
		if(f != "__id__" && f != "hx__closures__" && hasOwnProperty.call(o,f)) {
			a.push(f);
		}
		}
	}
	return a;
};
Reflect.isFunction = function(f) {
	if(typeof(f) == "function") {
		return !(f.__name__ || f.__ename__);
	} else {
		return false;
	}
};
Reflect.compareMethods = function(f1,f2) {
	if(f1 == f2) {
		return true;
	}
	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) {
		return false;
	}
	if(f1.scope == f2.scope && f1.method == f2.method) {
		return f1.method != null;
	} else {
		return false;
	}
};
Reflect.isObject = function(v) {
	if(v == null) {
		return false;
	}
	var t = typeof(v);
	if(!(t == "string" || t == "object" && v.__enum__ == null)) {
		if(t == "function") {
			return (v.__name__ || v.__ename__) != null;
		} else {
			return false;
		}
	} else {
		return true;
	}
};
var ScannerTest = function() {
	var _gthis = this;
	buddy_BuddySuite.call(this);
	this.describe("A new Mustache.Scanner",buddy_TestFunc.Sync(function() {
		var tmp = buddy_TestFunc.Sync(function() {
			var tmp1 = buddy_TestFunc.Sync(function() {
				utest_Assert.isTrue(new mustache_Scanner("").tail == "",null,{ fileName : "ScannerTest.hx", lineNumber : 11, className : "ScannerTest", methodName : "new"});
			});
			_gthis.it("is at the end",tmp1);
		});
		_gthis.describe("for an empty string",tmp);
		var tmp2 = buddy_TestFunc.Sync(function() {
			var scanner;
			_gthis.beforeEach(buddy_TestFunc.Sync(function() {
				scanner = new mustache_Scanner("a b c");
			}));
			var tmp3 = buddy_TestFunc.Sync(function() {
				var tmp4 = buddy_TestFunc.Sync(function() {
					var tmp5 = buddy_TestFunc.Sync(function() {
						var match = scanner.scan(new EReg("a b c",""));
						utest_Assert.equals(scanner.string,match,null,{ fileName : "ScannerTest.hx", lineNumber : 25, className : "ScannerTest", methodName : "new"});
						utest_Assert.isTrue(scanner.tail == "",null,{ fileName : "ScannerTest.hx", lineNumber : 26, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the entire string",tmp5);
				});
				_gthis.describe("when the RegExp matches the entire string",tmp4);
				var tmp6 = buddy_TestFunc.Sync(function() {
					var tmp7 = buddy_TestFunc.Sync(function() {
						utest_Assert.equals("a",scanner.scan(new EReg("a","")),null,{ fileName : "ScannerTest.hx", lineNumber : 33, className : "ScannerTest", methodName : "new"});
						utest_Assert.equals(1,scanner.pos,null,{ fileName : "ScannerTest.hx", lineNumber : 34, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the portion of the string that matched",tmp7);
				});
				_gthis.describe("when the RegExp matches at index 0",tmp6);
				var tmp8 = buddy_TestFunc.Sync(function() {
					var tmp9 = buddy_TestFunc.Sync(function() {
						utest_Assert.equals("",scanner.scan(new EReg("b","")),null,{ fileName : "ScannerTest.hx", lineNumber : 41, className : "ScannerTest", methodName : "new"});
						utest_Assert.equals(0,scanner.pos,null,{ fileName : "ScannerTest.hx", lineNumber : 42, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the empty string",tmp9);
				});
				_gthis.describe("when the RegExp matches at some index other than 0",tmp8);
				var tmp10 = buddy_TestFunc.Sync(function() {
					var tmp11 = buddy_TestFunc.Sync(function() {
						utest_Assert.equals("",scanner.scan(new EReg("z","")),null,{ fileName : "ScannerTest.hx", lineNumber : 49, className : "ScannerTest", methodName : "new"});
						utest_Assert.equals(0,scanner.pos,null,{ fileName : "ScannerTest.hx", lineNumber : 50, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the empty string",tmp11);
				});
				_gthis.describe("when the RegExp does not match",tmp10);
			});
			_gthis.describe("scan",tmp3);
			var tmp12 = buddy_TestFunc.Sync(function() {
				var tmp13 = buddy_TestFunc.Sync(function() {
					var tmp14 = buddy_TestFunc.Sync(function() {
						utest_Assert.equals("",scanner.scanUntil(new EReg("a","")),null,{ fileName : "ScannerTest.hx", lineNumber : 59, className : "ScannerTest", methodName : "new"});
						utest_Assert.equals(0,scanner.pos,null,{ fileName : "ScannerTest.hx", lineNumber : 60, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the empty string",tmp14);
				});
				_gthis.describe("when the RegExp matches at index 0",tmp13);
				var tmp15 = buddy_TestFunc.Sync(function() {
					var tmp16 = buddy_TestFunc.Sync(function() {
						utest_Assert.equals("a ",scanner.scanUntil(new EReg("b","")),null,{ fileName : "ScannerTest.hx", lineNumber : 67, className : "ScannerTest", methodName : "new"});
						utest_Assert.equals(2,scanner.pos,null,{ fileName : "ScannerTest.hx", lineNumber : 68, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the string up to that index",tmp16);
				});
				_gthis.describe("when the RegExp matches at some index other than 0",tmp15);
				var tmp17 = buddy_TestFunc.Sync(function() {
					var tmp18 = buddy_TestFunc.Sync(function() {
						var match1 = scanner.scanUntil(new EReg("z",""));
						utest_Assert.equals(scanner.string,match1,null,{ fileName : "ScannerTest.hx", lineNumber : 75, className : "ScannerTest", methodName : "new"});
						utest_Assert.isTrue(scanner.tail == "",null,{ fileName : "ScannerTest.hx", lineNumber : 76, className : "ScannerTest", methodName : "new"});
					});
					_gthis.it("returns the entire string",tmp18);
				});
				_gthis.describe("when the RegExp does not match",tmp17);
			});
			_gthis.describe("scanUntil",tmp12);
		});
		_gthis.describe("for a non-empty string",tmp2);
	}));
};
ScannerTest.__name__ = ["ScannerTest"];
ScannerTest.__super__ = buddy_BuddySuite;
ScannerTest.prototype = $extend(buddy_BuddySuite.prototype,{
	__class__: ScannerTest
});
var Std = function() { };
Std.__name__ = ["Std"];
Std.string = function(s) {
	return js_Boot.__string_rec(s,"");
};
Std.parseInt = function(x) {
	var v = parseInt(x,10);
	if(v == 0 && (HxOverrides.cca(x,1) == 120 || HxOverrides.cca(x,1) == 88)) {
		v = parseInt(x);
	}
	if(isNaN(v)) {
		return null;
	}
	return v;
};
var StringBuf = function() {
	this.b = "";
};
StringBuf.__name__ = ["StringBuf"];
StringBuf.prototype = {
	b: null
	,__class__: StringBuf
};
var StringTools = function() { };
StringTools.__name__ = ["StringTools"];
StringTools.isSpace = function(s,pos) {
	var c = HxOverrides.cca(s,pos);
	if(!(c > 8 && c < 14)) {
		return c == 32;
	} else {
		return true;
	}
};
StringTools.ltrim = function(s) {
	var l = s.length;
	var r = 0;
	while(r < l && StringTools.isSpace(s,r)) ++r;
	if(r > 0) {
		return HxOverrides.substr(s,r,l - r);
	} else {
		return s;
	}
};
StringTools.rtrim = function(s) {
	var l = s.length;
	var r = 0;
	while(r < l && StringTools.isSpace(s,l - r - 1)) ++r;
	if(r > 0) {
		return HxOverrides.substr(s,0,l - r);
	} else {
		return s;
	}
};
StringTools.trim = function(s) {
	return StringTools.ltrim(StringTools.rtrim(s));
};
StringTools.lpad = function(s,c,l) {
	if(c.length <= 0) {
		return s;
	}
	while(s.length < l) s = c + s;
	return s;
};
StringTools.replace = function(s,sub,by) {
	return s.split(sub).join(by);
};
var buddy_Buddy = function() { };
buddy_Buddy.__name__ = ["buddy","Buddy"];
var TestMain = function() { };
TestMain.__name__ = ["TestMain"];
TestMain.__interfaces__ = [buddy_Buddy];
TestMain.main = function() {
	var testsDone = false;
	var runner = null;
	var oldTrace = haxe_Log.trace;
	var outputError = function() {
		haxe_Log.trace = oldTrace;
		haxe_Log.trace(runner.unrecoverableError,{ fileName : "GenerateMain.hx", lineNumber : 202, className : "TestMain", methodName : "main"});
		var stack = runner.unrecoverableErrorStack;
		if(stack == null || stack.length == 0) {
			return;
		}
		var _g = 0;
		while(_g < stack.length) {
			var s = stack[_g];
			++_g;
			if(s[1] == 2) {
				var line = s[4];
				var file = s[3];
				if(line > 0) {
					haxe_Log.trace(file + ":" + line,{ fileName : "GenerateMain.hx", lineNumber : 208, className : "TestMain", methodName : "main"});
				}
			}
		}
	};
	var startRun = function(done) {
		runner = new buddy_SuitesRunner([new ScannerTest(),new ContextTest(),new ParseTest(),new TestSpec()],new buddy_reporting_ConsoleReporter());
		runner.run().then(function(_) {
			if(runner.unrecoverableError != null) {
				outputError();
			}
			done();
		});
	};
	process.on('uncaughtException', function(err) {
	runner.haveUnrecoverableError(err);
	});
	startRun(function() {
		process.exit(runner.statusCode());
	});
};
var js_node_Fs = require("fs");
var haxe_io_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.substr(path,0,c2);
		path = HxOverrides.substr(path,c2 + 1,null);
		this.backslash = true;
	} else if(c2 < c1) {
		this.dir = HxOverrides.substr(path,0,c1);
		path = HxOverrides.substr(path,c1 + 1,null);
	} else {
		this.dir = null;
	}
	var cp = path.lastIndexOf(".");
	if(cp != -1) {
		this.ext = HxOverrides.substr(path,cp + 1,null);
		this.file = HxOverrides.substr(path,0,cp);
	} else {
		this.ext = null;
		this.file = path;
	}
};
haxe_io_Path.__name__ = ["haxe","io","Path"];
haxe_io_Path.prototype = {
	dir: null
	,file: null
	,ext: null
	,backslash: null
	,__class__: haxe_io_Path
};
var TestSpec = function() {
	this.skipTests = { comments : ["Standalone Without Newline"], delimiters : ["Standalone Without Newline"], inverted : ["Standalone Without Newline"], partials : ["Standalone Without Previous Line","Standalone Without Newline","Standalone Indentation"], sections : ["Standalone Without Newline"]};
	var _gthis = this;
	buddy_BuddySuite.call(this);
	this.describe("Mustache spec compliance",buddy_TestFunc.Sync(function() {
		var tmp = buddy_TestFunc.Sync(function() {
			Mustache.defaultWriter.cache = new haxe_ds_StringMap();
		});
		_gthis.beforeEach(tmp);
		var _g = 0;
		var _g1 = TestSpec.specFiles;
		while(_g < _g1.length) {
			var specArea = [_g1[_g]];
			++_g;
			var tmp1 = "- " + specArea[0] + ":";
			var tmp11 = buddy_TestFunc.Sync((function(specArea1) {
				return function() {
					var _g2 = 0;
					var _g3 = TestSpec.getSpecs(specArea1[0]).tests;
					while(_g2 < _g3.length) {
						var test = [_g3[_g2]];
						++_g2;
						var desc = test[0].name + " - " + test[0].desc;
						if(Object.prototype.hasOwnProperty.call(_gthis.skipTests,specArea1[0]) && _gthis.skipTests[specArea1[0]].indexOf(test[0].name) != -1) {
							_gthis.xit(desc,null);
						} else {
							var tmp2 = buddy_TestFunc.Sync((function(test1) {
								return function() {
									var template = test1[0].template;
									var this1 = new mustache__$Context_ContextImpl(test1[0].data,null,null);
									var obj = test1[0].partials;
									var partials = (function() {
										return function(name) {
											return Reflect.field(obj,name);
										};
									})();
									var _this = Mustache.defaultWriter;
									var output = _this.renderTokens(_this.parse(template),this1,partials,template);
									utest_Assert.equals(test1[0].expected,output,null,{ fileName : "TestSpec.hx", lineNumber : 71, className : "TestSpec", methodName : "new"});
								};
							})(test));
							_gthis.it(desc,tmp2);
						}
					}
				};
			})(specArea));
			_gthis.describe(tmp1,tmp11);
		}
	}));
};
TestSpec.__name__ = ["TestSpec"];
TestSpec.getSpecs = function(specArea) {
	return JSON.parse(js_node_Fs.readFileSync(specArea == "inheritance"?"test/inheritance.json":"spec/specs" + "/" + specArea + ".json",{ encoding : "utf8"}));
};
TestSpec.__super__ = buddy_BuddySuite;
TestSpec.prototype = $extend(buddy_BuddySuite.prototype,{
	skipTests: null
	,__class__: TestSpec
});
var ValueType = { __ename__ : ["ValueType"], __constructs__ : ["TNull","TInt","TFloat","TBool","TObject","TFunction","TClass","TEnum","TUnknown"] };
ValueType.TNull = ["TNull",0];
ValueType.TNull.toString = $estr;
ValueType.TNull.__enum__ = ValueType;
ValueType.TInt = ["TInt",1];
ValueType.TInt.toString = $estr;
ValueType.TInt.__enum__ = ValueType;
ValueType.TFloat = ["TFloat",2];
ValueType.TFloat.toString = $estr;
ValueType.TFloat.__enum__ = ValueType;
ValueType.TBool = ["TBool",3];
ValueType.TBool.toString = $estr;
ValueType.TBool.__enum__ = ValueType;
ValueType.TObject = ["TObject",4];
ValueType.TObject.toString = $estr;
ValueType.TObject.__enum__ = ValueType;
ValueType.TFunction = ["TFunction",5];
ValueType.TFunction.toString = $estr;
ValueType.TFunction.__enum__ = ValueType;
ValueType.TClass = function(c) { var $x = ["TClass",6,c]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; };
ValueType.TEnum = function(e) { var $x = ["TEnum",7,e]; $x.__enum__ = ValueType; $x.toString = $estr; return $x; };
ValueType.TUnknown = ["TUnknown",8];
ValueType.TUnknown.toString = $estr;
ValueType.TUnknown.__enum__ = ValueType;
var Type = function() { };
Type.__name__ = ["Type"];
Type.getEnum = function(o) {
	if(o == null) {
		return null;
	}
	return o.__enum__;
};
Type.getClassName = function(c) {
	var a = c.__name__;
	if(a == null) {
		return null;
	}
	return a.join(".");
};
Type.getEnumName = function(e) {
	var a = e.__ename__;
	return a.join(".");
};
Type.getInstanceFields = function(c) {
	var a = [];
	for(var i in c.prototype) a.push(i);
	HxOverrides.remove(a,"__class__");
	HxOverrides.remove(a,"__properties__");
	return a;
};
Type["typeof"] = function(v) {
	var _g = typeof(v);
	switch(_g) {
	case "boolean":
		return ValueType.TBool;
	case "function":
		if(v.__name__ || v.__ename__) {
			return ValueType.TObject;
		}
		return ValueType.TFunction;
	case "number":
		if(Math.ceil(v) == v % 2147483648.0) {
			return ValueType.TInt;
		}
		return ValueType.TFloat;
	case "object":
		if(v == null) {
			return ValueType.TNull;
		}
		var e = v.__enum__;
		if(e != null) {
			return ValueType.TEnum(e);
		}
		var c = js_Boot.getClass(v);
		if(c != null) {
			return ValueType.TClass(c);
		}
		return ValueType.TObject;
	case "string":
		return ValueType.TClass(String);
	case "undefined":
		return ValueType.TNull;
	default:
		return ValueType.TUnknown;
	}
};
var buddy_SpecStatus = { __ename__ : ["buddy","SpecStatus"], __constructs__ : ["Unknown","Passed","Pending","Failed"] };
buddy_SpecStatus.Unknown = ["Unknown",0];
buddy_SpecStatus.Unknown.toString = $estr;
buddy_SpecStatus.Unknown.__enum__ = buddy_SpecStatus;
buddy_SpecStatus.Passed = ["Passed",1];
buddy_SpecStatus.Passed.toString = $estr;
buddy_SpecStatus.Passed.__enum__ = buddy_SpecStatus;
buddy_SpecStatus.Pending = ["Pending",2];
buddy_SpecStatus.Pending.toString = $estr;
buddy_SpecStatus.Pending.__enum__ = buddy_SpecStatus;
buddy_SpecStatus.Failed = ["Failed",3];
buddy_SpecStatus.Failed.toString = $estr;
buddy_SpecStatus.Failed.__enum__ = buddy_SpecStatus;
var buddy_Step = { __ename__ : ["buddy","Step"], __constructs__ : ["TSuite","TSpec"] };
buddy_Step.TSuite = function(s) { var $x = ["TSuite",0,s]; $x.__enum__ = buddy_Step; $x.toString = $estr; return $x; };
buddy_Step.TSpec = function(s) { var $x = ["TSpec",1,s]; $x.__enum__ = buddy_Step; $x.toString = $estr; return $x; };
var buddy_Suite = function(description) {
	this.stack = [];
	this.steps = [];
	if(description == null) {
		throw new js__$Boot_HaxeError("Suite requires a description.");
	}
	this.description = description;
};
buddy_Suite.__name__ = ["buddy","Suite"];
buddy_Suite.prototype = {
	description: null
	,steps: null
	,error: null
	,stack: null
	,get_specs: function() {
		var output = [];
		var _g = 0;
		var _g1 = this.steps;
		while(_g < _g1.length) {
			var step = _g1[_g];
			++_g;
			if(step[1] == 1) {
				output.push(step[2]);
			}
		}
		return output;
	}
	,get_suites: function() {
		var output = [];
		var _g = 0;
		var _g1 = this.steps;
		while(_g < _g1.length) {
			var step = _g1[_g];
			++_g;
			if(step[1] == 0) {
				output.push(step[2]);
			}
		}
		return output;
	}
	,passed: function() {
		if(Lambda.exists(this.get_specs(),function(spec) {
			return spec.status == buddy_SpecStatus.Failed;
		})) {
			return false;
		}
		return !Lambda.exists(this.get_suites(),function(suite) {
			return !suite.passed();
		});
	}
	,__class__: buddy_Suite
};
var buddy_Spec = function(description) {
	this.traces = [];
	this.failures = [];
	this.status = buddy_SpecStatus.Unknown;
	if(description == null) {
		throw new js__$Boot_HaxeError("Spec must have a description.");
	}
	this.description = description;
};
buddy_Spec.__name__ = ["buddy","Spec"];
buddy_Spec.prototype = {
	description: null
	,status: null
	,failures: null
	,traces: null
	,__class__: buddy_Spec
};
var buddy_Failure = function(error,stack) {
	if(error == null) {
		throw new js__$Boot_HaxeError("Failure must have an error.");
	}
	this.error = error;
	this.stack = stack == null?[]:stack;
};
buddy_Failure.__name__ = ["buddy","Failure"];
buddy_Failure.prototype = {
	error: null
	,stack: null
	,__class__: buddy_Failure
};
var buddy_TestFunc = { __ename__ : ["buddy","TestFunc"], __constructs__ : ["Async","Sync"] };
buddy_TestFunc.Async = function(f) { var $x = ["Async",0,f]; $x.__enum__ = buddy_TestFunc; $x.toString = $estr; return $x; };
buddy_TestFunc.Sync = function(f) { var $x = ["Sync",1,f]; $x.__enum__ = buddy_TestFunc; $x.toString = $estr; return $x; };
var buddy_TestSpec = { __ename__ : ["buddy","TestSpec"], __constructs__ : ["Describe","It"] };
buddy_TestSpec.Describe = function(suite,included) { var $x = ["Describe",0,suite,included]; $x.__enum__ = buddy_TestSpec; $x.toString = $estr; return $x; };
buddy_TestSpec.It = function(description,test,included) { var $x = ["It",1,description,test,included]; $x.__enum__ = buddy_TestSpec; $x.toString = $estr; return $x; };
var buddy_TestSuite = function(description) {
	this.afterAll = new List();
	this.afterEach = new List();
	this.specs = new List();
	this.beforeEach = new List();
	this.beforeAll = new List();
	if(description == null) {
		throw new js__$Boot_HaxeError("TestSuite must have a description. Can be empty.");
	}
	this.description = description;
};
buddy_TestSuite.__name__ = ["buddy","TestSuite"];
buddy_TestSuite.prototype = {
	description: null
	,beforeAll: null
	,beforeEach: null
	,specs: null
	,afterEach: null
	,afterAll: null
	,__class__: buddy_TestSuite
};
var buddy_Should = function() { };
buddy_Should.__name__ = ["buddy","Should"];
var buddy_ShouldDynamic = function() { };
buddy_ShouldDynamic.__name__ = ["buddy","ShouldDynamic"];
buddy_ShouldDynamic.__super__ = buddy_Should;
buddy_ShouldDynamic.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldDynamic
});
var buddy_ShouldEnum = function() { };
buddy_ShouldEnum.__name__ = ["buddy","ShouldEnum"];
buddy_ShouldEnum.__super__ = buddy_Should;
buddy_ShouldEnum.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldEnum
});
var buddy_ShouldInt = function() { };
buddy_ShouldInt.__name__ = ["buddy","ShouldInt"];
buddy_ShouldInt.__super__ = buddy_Should;
buddy_ShouldInt.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldInt
});
var buddy_ShouldInt64 = function() { };
buddy_ShouldInt64.__name__ = ["buddy","ShouldInt64"];
buddy_ShouldInt64.__super__ = buddy_Should;
buddy_ShouldInt64.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldInt64
});
var buddy_ShouldFloat = function() { };
buddy_ShouldFloat.__name__ = ["buddy","ShouldFloat"];
buddy_ShouldFloat.__super__ = buddy_Should;
buddy_ShouldFloat.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldFloat
});
var buddy_ShouldDate = function() { };
buddy_ShouldDate.__name__ = ["buddy","ShouldDate"];
buddy_ShouldDate.__super__ = buddy_Should;
buddy_ShouldDate.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldDate
});
var buddy_ShouldString = function() { };
buddy_ShouldString.__name__ = ["buddy","ShouldString"];
buddy_ShouldString.__super__ = buddy_Should;
buddy_ShouldString.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldString
});
var buddy_ShouldIterable = function() { };
buddy_ShouldIterable.__name__ = ["buddy","ShouldIterable"];
buddy_ShouldIterable.__super__ = buddy_Should;
buddy_ShouldIterable.prototype = $extend(buddy_Should.prototype,{
	__class__: buddy_ShouldIterable
});
var buddy_ShouldFunctions = function() { };
buddy_ShouldFunctions.__name__ = ["buddy","ShouldFunctions"];
buddy_ShouldFunctions.prototype = {
	__class__: buddy_ShouldFunctions
};
var buddy_SuitesRunner = function(buddySuites,reporter) {
	this.allTestsPassed = false;
	this.unrecoverableErrorStack = null;
	this.unrecoverableError = null;
	this.buddySuites = buddySuites;
	this.reporter = reporter == null?new buddy_reporting_ConsoleReporter():reporter;
	this.oldLog = haxe_Log.trace;
	this.includeMode = Object.prototype.hasOwnProperty.call(haxe_rtti_Meta.getType(buddy_BuddySuite),"includeMode");
};
buddy_SuitesRunner.__name__ = ["buddy","SuitesRunner"];
buddy_SuitesRunner.posInfosToStack = function(p) {
	if(p == null) {
		return [haxe_StackItem.FilePos(null,"",0)];
	} else {
		return [haxe_StackItem.FilePos(null,p.fileName,p.lineNumber)];
	}
};
buddy_SuitesRunner.prototype = {
	unrecoverableError: null
	,unrecoverableErrorStack: null
	,allTestsPassed: null
	,buddySuites: null
	,reporter: null
	,runCompleted: null
	,includeMode: null
	,oldLog: null
	,run: function() {
		var _gthis = this;
		this.runCompleted = new promhx_Deferred();
		var runCompletedPromise = this.runCompleted.promise();
		this.runDescribes(function(err) {
			if(err != null) {
				_gthis.haveUnrecoverableError(err);
				return;
			}
			if(_gthis.includeMode) {
				_gthis.startIncludeMode();
			}
			_gthis.startRun();
		});
		return runCompletedPromise;
	}
	,runDescribes: function(cb) {
		var _gthis = this;
		var asyncQueue = [];
		var syncQueue = [];
		var processSuiteDescribes = function(suite) {
			while(!Lambda.empty(suite.describeQueue)) {
				var current = suite.describeQueue.pop();
				var _g = current.spec;
				switch(_g[1]) {
				case 0:
					asyncQueue.push({ buddySuite : suite, testSuite : current.suite, run : _g[2]});
					break;
				case 1:
					syncQueue.push({ buddySuite : suite, testSuite : current.suite, run : _g[2]});
					break;
				}
			}
		};
		var processBuddySuites = null;
		processBuddySuites = function() {
			var tmp = $iterator(_gthis.buddySuites)();
			while(tmp.hasNext()) {
				var buddySuite = tmp.next();
				processSuiteDescribes(buddySuite);
			}
			if(syncQueue.length > 0) {
				try {
					var _g1 = 0;
					while(_g1 < syncQueue.length) {
						var test = syncQueue[_g1];
						++_g1;
						test.buddySuite.currentSuite = test.testSuite;
						test.run();
					}
				} catch( err ) {
					haxe_CallStack.lastException = err;
					if (err instanceof js__$Boot_HaxeError) err = err.val;
					cb(err);
					return;
				}
				syncQueue = [];
				processBuddySuites();
			} else if(asyncQueue.length > 0) {
				AsyncTools.aEachSeries(asyncQueue,function(test1,cb1) {
					test1.buddySuite.currentSuite = test1.testSuite;
					test1.run(function() {
						cb1(null);
					});
				},function(err1) {
					if(err1 != null) {
						cb(err1);
						return;
					}
					asyncQueue = [];
					processBuddySuites();
				});
			} else {
				cb(null);
			}
		};
		processBuddySuites();
	}
	,failed: function() {
		return !this.allTestsPassed;
	}
	,statusCode: function() {
		if(this.failed()) {
			return 1;
		} else {
			return 0;
		}
	}
	,startRun: function() {
		var _gthis = this;
		this.reporter.start().then(function(go) {
			if(!go) {
				_gthis.reporter.done([],false).then(function(_) {
					_gthis.runCompleted.resolve(_gthis);
				});
				return;
			}
			var beforeEachStack = [[]];
			var afterEachStack = [[]];
			AsyncTools.aMapSeries(_gthis.buddySuites,function(buddySuite,done) {
				var suiteDone = function(err,suite) {
					if(err == null && suite == null) {
						return;
					}
					if(err != null) {
						suite.error = err;
						suite.stack = haxe_CallStack.exceptionStack();
					}
					done(err,suite);
				};
				var syncSuite = _gthis.mapTestSuite(buddySuite,buddySuite.suite,beforeEachStack,afterEachStack,suiteDone);
				if(syncSuite != null) {
					suiteDone(syncSuite.error,syncSuite.suite);
				}
			},function(err1,suites) {
				if(err1 != null) {
					_gthis.haveUnrecoverableError(err1);
				} else {
					_gthis.allTestsPassed = !Lambda.exists(suites,function(suite1) {
						return !suite1.passed();
					});
					_gthis.reporter.done(suites,_gthis.allTestsPassed).then(function(_1) {
						_gthis.runCompleted.resolve(_gthis);
					});
				}
			});
		});
	}
	,startIncludeMode: function() {
		var traverse = null;
		traverse = function(suite) {
			suite.specs = suite.specs.filter(function(spec) {
				switch(spec[1]) {
				case 0:
					if(spec[3]) {
						return true;
					} else {
						return traverse(spec[2]);
					}
					break;
				case 1:
					return spec[4];
				}
			});
			return suite.specs.length > 0;
		};
		var traverse1 = traverse;
		this.buddySuites = Lambda.filter(this.buddySuites,function(buddySuite) {
			var tmp = buddySuite == null?null:js_Boot.getClass(buddySuite);
			if(Object.prototype.hasOwnProperty.call(haxe_rtti_Meta.getType(tmp),"include")) {
				return true;
			}
			return traverse1(buddySuite.suite);
		});
	}
	,mapTestSuite: function(buddySuite,testSuite,beforeEachStack,afterEachStack,done) {
		var _gthis = this;
		var currentSuite = buddy_tests_SelfTest.lastSuite = new buddy_Suite(testSuite.description);
		var tmp = Lambda.array(testSuite.beforeEach);
		beforeEachStack.push(tmp);
		var tmp1 = Lambda.array(testSuite.afterEach);
		afterEachStack.unshift(tmp1);
		var allSync = this.isSync(testSuite.beforeAll) && this.isSync(testSuite.afterAll);
		var result = null;
		var syncResultCount = 0;
		this.runTestFuncs(testSuite.beforeAll,function(err) {
			if(err != null) {
				if(_gthis.isSync(testSuite.beforeAll)) {
					result = { error : err, suite : currentSuite};
				} else {
					done(err,currentSuite);
				}
				return;
			}
			AsyncTools.aMapSeries(testSuite.specs,function(testSpec,cb) {
				var result2 = _gthis.mapTestSpec(buddySuite,testSuite,beforeEachStack,afterEachStack,testSpec,cb);
				if(result2 != null) {
					syncResultCount += 1;
					cb(result2.error,result2.step);
				}
			},function(err1,testSteps) {
				if(allSync) {
					allSync = testSteps.length == syncResultCount;
				} else {
					allSync = false;
				}
				if(err1 != null) {
					if(allSync) {
						result = { error : err1, suite : currentSuite};
					} else {
						done(err1,currentSuite);
					}
					return;
				}
				_gthis.runTestFuncs(testSuite.afterAll,function(err2) {
					if(err2 != null) {
						if(allSync) {
							result = { error : err2, suite : currentSuite};
						} else {
							done(err2,currentSuite);
						}
						return;
					}
					currentSuite.steps = testSteps;
					beforeEachStack.pop();
					afterEachStack.shift();
					if(allSync) {
						result = { error : null, suite : currentSuite};
					} else {
						done(null,currentSuite);
					}
				});
			});
		});
		if(result != null) {
			done(null,null);
		}
		return result;
	}
	,runTestFuncs: function(funcs,done) {
		var syncQ = [];
		var asyncQ = [];
		var tmp = $iterator(funcs)();
		while(tmp.hasNext()) {
			var func = tmp.next();
			switch(func[1]) {
			case 0:
				asyncQ.push(func[2]);
				break;
			case 1:
				syncQ.push(func[2]);
				break;
			}
		}
		try {
			var _g = 0;
			while(_g < syncQ.length) {
				var f = syncQ[_g];
				++_g;
				f();
			}
		} catch( err ) {
			haxe_CallStack.lastException = err;
			if (err instanceof js__$Boot_HaxeError) err = err.val;
			done(err);
			return;
		}
		AsyncTools.aEachSeries(asyncQ,function(f1,done1) {
			f1(function() {
				done1();
			});
		},done);
	}
	,flatten: function(arr) {
		var _g = [];
		var _g1 = 0;
		while(_g1 < arr.length) {
			var a = arr[_g1];
			++_g1;
			var _g2 = 0;
			while(_g2 < a.length) {
				var b = a[_g2];
				++_g2;
				_g.push(b);
			}
		}
		return _g;
	}
	,isSync: function(funcs) {
		var tmp = $iterator(funcs)();
		while(tmp.hasNext()) if(tmp.next()[1] == 0) {
			return false;
		}
		return true;
	}
	,mapTestSpec: function(buddySuite,testSuite,beforeEachStack,afterEachStack,testSpec,done) {
		var _gthis = this;
		var hasCompleted = false;
		var oldFail = null;
		oldFail = buddySuite.fail = function(err,p) {
			if(err == null) {
				err = "Exception";
			}
			if(!hasCompleted && oldFail == buddySuite.fail) {
				done(err,null);
			}
		};
		var oldPending = buddySuite.pending = function(message,p1) {
			done("Cannot call pending here.",null);
		};
		switch(testSpec[1]) {
		case 0:
			var result = this.mapTestSuite(buddySuite,testSpec[2],beforeEachStack,afterEachStack,function(err1,newSuite) {
				if(err1 == null && newSuite == null) {
					return;
				}
				if(err1 != null) {
					done(err1,null);
				} else {
					done(null,buddy_Step.TSuite(newSuite));
				}
			});
			if(result != null) {
				return { error : result.error, step : buddy_Step.TSuite(result.suite)};
			} else {
				return null;
			}
			break;
		case 1:
			var test = testSpec[3];
			var spec = buddy_tests_SelfTest.lastSpec = new buddy_Spec(testSpec[2]);
			var beforeEach = this.flatten(beforeEachStack);
			var afterEach = this.flatten(afterEachStack);
			var eachIsSync = this.isSync(beforeEach) && this.isSync(afterEach);
			var returnSync;
			if(test == null) {
				returnSync = eachIsSync;
			} else {
				switch(test[1]) {
				case 0:
					returnSync = false;
					break;
				case 1:
					returnSync = eachIsSync;
					break;
				}
			}
			if(!buddy_BuddySuite.useDefaultTrace) {
				haxe_Log.trace = function(v,pos) {
					if(pos == null) {
						spec.traces.push(v == null?"null":"" + v);
					} else {
						spec.traces.push(pos.fileName + ":" + pos.lineNumber + ": " + v);
					}
				};
			}
			var reportFailure = function(error,stack) {
				if(hasCompleted) {
					return;
				}
				spec.status = buddy_SpecStatus.Failed;
				spec.failures.push(new buddy_Failure(error,stack));
			};
			var specCompleted = function(status) {
				if(hasCompleted) {
					return null;
				}
				hasCompleted = true;
				if(spec.status == buddy_SpecStatus.Unknown) {
					spec.status = status;
				}
				if(!buddy_BuddySuite.useDefaultTrace) {
					haxe_Log.trace = _gthis.oldLog;
				}
				buddySuite.fail = oldFail;
				buddySuite.pending = oldPending;
				var syncResult = null;
				_gthis.runTestFuncs(afterEach,function(err2) {
					if(returnSync) {
						syncResult = { error : err2, step : err2 == null?buddy_Step.TSpec(spec):null};
						_gthis.reporter.progress(spec);
					} else if(err2 != null) {
						done(err2,null);
					} else {
						_gthis.reporter.progress(spec).then(function(_) {
							done(null,buddy_Step.TSpec(spec));
						});
					}
				});
				return syncResult;
			};
			if(test == null) {
				return specCompleted(buddy_SpecStatus.Pending);
			}
			buddy_SuitesRunner.currentTest = function(testStatus,error1,stack1) {
				if(testStatus != true) {
					reportFailure(error1,stack1);
				}
			};
			utest_Assert.results = new List();
			var checkUtestResults = function() {
				var _g_head = utest_Assert.results.h;
				while(_g_head != null) {
					var val = _g_head.item;
					_g_head = _g_head.next;
					switch(val[1]) {
					case 0:
						break;
					case 1:
						var tmp = buddy_SuitesRunner.posInfosToStack(val[3]);
						reportFailure(val[2],tmp);
						break;
					case 2:
						reportFailure(val[2],val[3]);
						break;
					case 3:
						reportFailure(val[2],val[3]);
						break;
					case 4:
						reportFailure(val[2],val[3]);
						break;
					case 5:
						reportFailure(val[2],val[3]);
						break;
					case 6:
						reportFailure(val[2],val[3]);
						break;
					case 7:
						spec.traces.push(val[2]);
						break;
					}
				}
			};
			if(!returnSync && buddySuite.timeoutMs > 0) {
				buddy_tools_AsyncTools.wait(buddySuite.timeoutMs).catchError(function(e) {
					var tmp1 = haxe_CallStack.exceptionStack();
					reportFailure(e,tmp1);
					specCompleted(buddy_SpecStatus.Failed);
				}).then(function(_1) {
					reportFailure("Timeout after " + buddySuite.timeoutMs + " ms",[]);
					specCompleted(buddy_SpecStatus.Failed);
				});
			}
			var _syncResult = null;
			var setSyncResult = function(status1) {
				if(!returnSync || _syncResult != null) {
					return;
				}
				_syncResult = status1;
			};
			buddySuite.fail = function(err3,p2) {
				if(err3 == null) {
					err3 = "Manually";
				}
				var tmp2 = buddy_SuitesRunner.posInfosToStack(p2);
				reportFailure(err3,tmp2);
				var tmp3 = specCompleted(buddy_SpecStatus.Failed);
				setSyncResult(tmp3);
			};
			buddySuite.pending = function(message1,p3) {
				spec.traces.push(p3.fileName + ":" + p3.lineNumber + (message1 != null?": " + message1:""));
				var tmp4 = specCompleted(buddy_SpecStatus.Pending);
				setSyncResult(tmp4);
			};
			this.runTestFuncs(beforeEach,function(err4) {
				if(err4 != null) {
					if(returnSync) {
						setSyncResult({ error : err4, step : null});
					} else {
						done(err4,null);
					}
					return;
				}
				(function(func,done1) {
					try {
						switch(func[1]) {
						case 0:
							func[2](function() {
								done1(null);
							});
							break;
						case 1:
							func[2]();
							done1(null);
							break;
						}
					} catch( e1 ) {
						haxe_CallStack.lastException = e1;
						if (e1 instanceof js__$Boot_HaxeError) e1 = e1.val;
						done1(e1);
					}
				})(test,function(err5) {
					checkUtestResults();
					if(err5 != null) {
						var tmp5 = haxe_CallStack.exceptionStack();
						reportFailure(err5,tmp5);
						var tmp6 = specCompleted(buddy_SpecStatus.Failed);
						setSyncResult(tmp6);
					} else {
						var tmp7 = specCompleted(buddy_SpecStatus.Passed);
						setSyncResult(tmp7);
					}
				});
			});
			return _syncResult;
		}
	}
	,haveUnrecoverableError: function(err) {
		this.unrecoverableError = err;
		this.unrecoverableErrorStack = haxe_CallStack.exceptionStack();
		this.runCompleted.resolve(this);
	}
	,__class__: buddy_SuitesRunner
};
var buddy_internal_sys_NodeJs = function() { };
buddy_internal_sys_NodeJs.__name__ = ["buddy","internal","sys","NodeJs"];
buddy_internal_sys_NodeJs.print = function(s) {
	process.stdout.write(s);
};
buddy_internal_sys_NodeJs.println = function(s) {
	console.log(s);
};
var buddy_reporting_Reporter = function() { };
buddy_reporting_Reporter.__name__ = ["buddy","reporting","Reporter"];
buddy_reporting_Reporter.prototype = {
	start: null
	,progress: null
	,done: null
	,__class__: buddy_reporting_Reporter
};
var buddy_reporting_TraceReporter = function(colors) {
	if(colors == null) {
		colors = false;
	}
	this.colors = colors;
};
buddy_reporting_TraceReporter.__name__ = ["buddy","reporting","TraceReporter"];
buddy_reporting_TraceReporter.__interfaces__ = [buddy_reporting_Reporter];
buddy_reporting_TraceReporter.prototype = {
	colors: null
	,start: function() {
		return this.resolveImmediately(true);
	}
	,progress: function(spec) {
		return this.resolveImmediately(spec);
	}
	,done: function(suites,status) {
		var _gthis = this;
		this.println("");
		var total = 0;
		var failures = 0;
		var pending = 0;
		var countTests = null;
		var printTests = null;
		countTests = function(s) {
			if(s.error != null) {
				failures += 1;
			}
			var _g = 0;
			var _g1 = s.steps;
			while(_g < _g1.length) {
				var sp = _g1[_g];
				++_g;
				switch(sp[1]) {
				case 0:
					countTests(sp[2]);
					break;
				case 1:
					var sp1 = sp[2];
					total += 1;
					if(sp1.status == buddy_SpecStatus.Failed) {
						failures += 1;
					} else if(sp1.status == buddy_SpecStatus.Pending) {
						pending += 1;
					}
					break;
				}
			}
		};
		Lambda.iter(suites,countTests);
		printTests = function(s1,indentLevel) {
			var print = function(str,color) {
				if(color == null) {
					color = 39;
				}
				_gthis.println(_gthis.strCol(color) + StringTools.lpad(str," ",str.length + (Math.max(0,indentLevel * 2) | 0)) + _gthis.strCol(39));
			};
			var printStack = function(indent,stack) {
				if(stack == null || stack.length == 0) {
					return;
				}
				var _g2 = 0;
				while(_g2 < stack.length) {
					var s2 = stack[_g2];
					++_g2;
					if(s2[1] == 2) {
						var line = s2[4];
						var file = s2[3];
						if(line > 0 && file.indexOf("buddy/internal/") != 0 && file.indexOf("buddy.SuitesRunner") != 0) {
							print(indent + ("@ " + file + ":" + line),33);
						}
					}
				}
			};
			var printTraces = function(spec) {
				var _g3 = 0;
				var _g11 = spec.traces;
				while(_g3 < _g11.length) {
					var t = _g11[_g3];
					++_g3;
					print("    " + t,33);
				}
			};
			if(s1.description.length > 0) {
				print(s1.description);
			}
			if(s1.error != null) {
				print("ERROR: " + Std.string(s1.error),31);
				printStack("  ",s1.stack);
				return;
			}
			var _g4 = 0;
			var _g12 = s1.steps;
			while(_g4 < _g12.length) {
				var step = _g12[_g4];
				++_g4;
				switch(step[1]) {
				case 0:
					printTests(step[2],indentLevel + 1);
					break;
				case 1:
					var sp2 = step[2];
					if(sp2.status == buddy_SpecStatus.Failed) {
						print("  " + sp2.description + " (FAILED)",31);
						var _g21 = 0;
						var _g31 = sp2.failures;
						while(_g21 < _g31.length) {
							var failure = _g31[_g21];
							++_g21;
							print("    " + Std.string(failure.error),33);
							printStack("      ",failure.stack);
						}
					} else {
						print("  " + sp2.description + " (" + Std.string(sp2.status) + ")",sp2.status == buddy_SpecStatus.Passed?32:33);
					}
					printTraces(sp2);
					break;
				}
			}
		};
		var f = printTests;
		Lambda.iter(suites,function(a1) {
			f(a1,-1);
		});
		var totalColor = failures > 0?31:32;
		this.println(this.strCol(totalColor) + ("" + total + " specs, " + failures + " failures, ") + this.strCol(pending > 0?33:totalColor) + ("" + pending + " pending") + this.strCol(39));
		return this.resolveImmediately(suites);
	}
	,println: function(s) {
		haxe_Log.trace(s,{ fileName : "TraceReporter.hx", lineNumber : 142, className : "buddy.reporting.TraceReporter", methodName : "println"});
	}
	,strCol: function(color) {
		if(this.colors) {
			return buddy_reporting__$TraceReporter_Color_$Impl_$.ansiCode(color);
		} else {
			return "";
		}
	}
	,resolveImmediately: function(o) {
		var def = new promhx_Deferred();
		var pr = def.promise();
		def.resolve(o);
		return pr;
	}
	,__class__: buddy_reporting_TraceReporter
};
var buddy_reporting_ConsoleReporter = function(colors) {
	if(colors == null) {
		colors = false;
	}
	this.progressString = "";
	buddy_reporting_TraceReporter.call(this,colors);
};
buddy_reporting_ConsoleReporter.__name__ = ["buddy","reporting","ConsoleReporter"];
buddy_reporting_ConsoleReporter.__super__ = buddy_reporting_TraceReporter;
buddy_reporting_ConsoleReporter.prototype = $extend(buddy_reporting_TraceReporter.prototype,{
	progressString: null
	,start: function() {
		return this.resolveImmediately(true);
	}
	,progress: function(spec) {
		var status;
		switch(spec.status[1]) {
		case 0:
			status = this.strCol(33) + "?";
			break;
		case 1:
			status = this.strCol(32) + ".";
			break;
		case 2:
			status = this.strCol(33) + "P";
			break;
		case 3:
			status = this.strCol(31) + "X";
			break;
		}
		this.progressString += status;
		this.print(status + this.strCol(39));
		return this.resolveImmediately(spec);
	}
	,done: function(suites,status) {
		return buddy_reporting_TraceReporter.prototype.done.call(this,suites,status);
	}
	,print: function(s) {
		buddy_internal_sys_NodeJs.print(s);
	}
	,println: function(s) {
		buddy_internal_sys_NodeJs.println(s);
	}
	,__class__: buddy_reporting_ConsoleReporter
});
var buddy_reporting__$TraceReporter_Color_$Impl_$ = {};
buddy_reporting__$TraceReporter_Color_$Impl_$.__name__ = ["buddy","reporting","_TraceReporter","Color_Impl_"];
buddy_reporting__$TraceReporter_Color_$Impl_$.ansiCode = function(this1) {
	return "\x1B" + ("[" + this1 + "m");
};
var buddy_tests_SelfTest = function() { };
buddy_tests_SelfTest.__name__ = ["buddy","tests","SelfTest"];
var buddy_tools_AsyncTools = function() { };
buddy_tools_AsyncTools.__name__ = ["buddy","tools","AsyncTools"];
buddy_tools_AsyncTools.wait = function(ms) {
	var def = new promhx_Deferred();
	var pr = def.promise();
	var done = function() {
		if(!pr._fulfilled) {
			def.resolve(true);
		}
	};
	haxe_Timer.delay(function() {
		done();
	},ms);
	return pr;
};
var haxe_StackItem = { __ename__ : ["haxe","StackItem"], __constructs__ : ["CFunction","Module","FilePos","Method","LocalFunction"] };
haxe_StackItem.CFunction = ["CFunction",0];
haxe_StackItem.CFunction.toString = $estr;
haxe_StackItem.CFunction.__enum__ = haxe_StackItem;
haxe_StackItem.Module = function(m) { var $x = ["Module",1,m]; $x.__enum__ = haxe_StackItem; $x.toString = $estr; return $x; };
haxe_StackItem.FilePos = function(s,file,line) { var $x = ["FilePos",2,s,file,line]; $x.__enum__ = haxe_StackItem; $x.toString = $estr; return $x; };
haxe_StackItem.Method = function(classname,method) { var $x = ["Method",3,classname,method]; $x.__enum__ = haxe_StackItem; $x.toString = $estr; return $x; };
haxe_StackItem.LocalFunction = function(v) { var $x = ["LocalFunction",4,v]; $x.__enum__ = haxe_StackItem; $x.toString = $estr; return $x; };
var haxe_CallStack = function() { };
haxe_CallStack.__name__ = ["haxe","CallStack"];
haxe_CallStack.getStack = function(e) {
	if(e == null) {
		return [];
	}
	var oldValue = Error.prepareStackTrace;
	Error.prepareStackTrace = function(error,callsites) {
		var stack = [];
		var _g = 0;
		while(_g < callsites.length) {
			var site = callsites[_g];
			++_g;
			if(haxe_CallStack.wrapCallSite != null) {
				site = haxe_CallStack.wrapCallSite(site);
			}
			var method = null;
			var fullName = site.getFunctionName();
			if(fullName != null) {
				var idx = fullName.lastIndexOf(".");
				if(idx >= 0) {
					var className = HxOverrides.substr(fullName,0,idx);
					var methodName = HxOverrides.substr(fullName,idx + 1,null);
					method = haxe_StackItem.Method(className,methodName);
				}
			}
			stack.push(haxe_StackItem.FilePos(method,site.getFileName(),site.getLineNumber()));
		}
		return stack;
	};
	var a = haxe_CallStack.makeStack(e.stack);
	Error.prepareStackTrace = oldValue;
	return a;
};
haxe_CallStack.callStack = function() {
	try {
		throw new Error();
	} catch( e ) {
		haxe_CallStack.lastException = e;
		if (e instanceof js__$Boot_HaxeError) e = e.val;
		var a = haxe_CallStack.getStack(e);
		a.shift();
		return a;
	}
};
haxe_CallStack.exceptionStack = function() {
	return haxe_CallStack.getStack(haxe_CallStack.lastException);
};
haxe_CallStack.toString = function(stack) {
	var b = new StringBuf();
	var _g = 0;
	while(_g < stack.length) {
		var s = stack[_g];
		++_g;
		b.b += "\nCalled from ";
		haxe_CallStack.itemToString(b,s);
	}
	return b.b;
};
haxe_CallStack.itemToString = function(b,s) {
	switch(s[1]) {
	case 0:
		b.b += "a C function";
		break;
	case 1:
		var m = s[2];
		b.b = (b.b += "module ") + (m == null?"null":"" + m);
		break;
	case 2:
		var line = s[4];
		var file = s[3];
		var s1 = s[2];
		if(s1 != null) {
			haxe_CallStack.itemToString(b,s1);
			b.b += " (";
		}
		b.b = (b.b += file == null?"null":"" + file) + " line ";
		b.b += line == null?"null":"" + line;
		if(s1 != null) {
			b.b += ")";
		}
		break;
	case 3:
		var meth = s[3];
		var cname = s[2];
		b.b = (b.b += cname == null?"null":"" + cname) + ".";
		b.b += meth == null?"null":"" + meth;
		break;
	case 4:
		var n = s[2];
		b.b = (b.b += "local function #") + (n == null?"null":"" + n);
		break;
	}
};
haxe_CallStack.makeStack = function(s) {
	if(s == null) {
		return [];
	} else if(typeof(s) == "string") {
		var stack = s.split("\n");
		if(stack[0] == "Error") {
			stack.shift();
		}
		var m = [];
		var rie10 = new EReg("^   at ([A-Za-z0-9_. ]+) \\(([^)]+):([0-9]+):([0-9]+)\\)$","");
		var _g = 0;
		while(_g < stack.length) {
			var line = stack[_g];
			++_g;
			if(rie10.match(line)) {
				var path = rie10.matched(1).split(".");
				var meth = path.pop();
				var file = rie10.matched(2);
				var line1 = Std.parseInt(rie10.matched(3));
				m.push(haxe_StackItem.FilePos(meth == "Anonymous function"?haxe_StackItem.LocalFunction():meth == "Global code"?null:haxe_StackItem.Method(path.join("."),meth),file,line1));
			} else {
				m.push(haxe_StackItem.Module(StringTools.trim(line)));
			}
		}
		return m;
	} else {
		return s;
	}
};
var haxe_IMap = function() { };
haxe_IMap.__name__ = ["haxe","IMap"];
haxe_IMap.prototype = {
	get: null
	,keys: null
	,__class__: haxe_IMap
};
var haxe_Log = function() { };
haxe_Log.__name__ = ["haxe","Log"];
haxe_Log.trace = function(v,infos) {
	js_Boot.__trace(v,infos);
};
var haxe_Timer = function(time_ms) {
	var me = this;
	this.id = setInterval(function() {
		me.run();
	},time_ms);
};
haxe_Timer.__name__ = ["haxe","Timer"];
haxe_Timer.delay = function(f,time_ms) {
	var t = new haxe_Timer(time_ms);
	t.run = function() {
		t.stop();
		f();
	};
	return t;
};
haxe_Timer.prototype = {
	id: null
	,stop: function() {
		if(this.id == null) {
			return;
		}
		clearInterval(this.id);
		this.id = null;
	}
	,run: function() {
	}
	,__class__: haxe_Timer
};
var haxe_ds_IntMap = function() {
	this.h = { };
};
haxe_ds_IntMap.__name__ = ["haxe","ds","IntMap"];
haxe_ds_IntMap.__interfaces__ = [haxe_IMap];
haxe_ds_IntMap.prototype = {
	h: null
	,get: function(key) {
		return this.h[key];
	}
	,keys: function() {
		var a = [];
		for( var key in this.h ) if(this.h.hasOwnProperty(key)) {
			a.push(key | 0);
		}
		return HxOverrides.iter(a);
	}
	,__class__: haxe_ds_IntMap
};
var haxe_ds_Option = { __ename__ : ["haxe","ds","Option"], __constructs__ : ["Some","None"] };
haxe_ds_Option.Some = function(v) { var $x = ["Some",0,v]; $x.__enum__ = haxe_ds_Option; $x.toString = $estr; return $x; };
haxe_ds_Option.None = ["None",1];
haxe_ds_Option.None.toString = $estr;
haxe_ds_Option.None.__enum__ = haxe_ds_Option;
var haxe_ds_StringMap = function() {
	this.h = { };
};
haxe_ds_StringMap.__name__ = ["haxe","ds","StringMap"];
haxe_ds_StringMap.__interfaces__ = [haxe_IMap];
haxe_ds_StringMap.prototype = {
	h: null
	,rh: null
	,get: function(key) {
		if(__map_reserved[key] != null) {
			return this.getReserved(key);
		}
		return this.h[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);
	}
	,keys: function() {
		return HxOverrides.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;
	}
	,__class__: haxe_ds_StringMap
};
var haxe_io_Bytes = function(data) {
	this.length = data.byteLength;
	this.b = new Uint8Array(data);
	this.b.bufferValue = data;
	data.hxBytes = this;
	data.bytes = this.b;
};
haxe_io_Bytes.__name__ = ["haxe","io","Bytes"];
haxe_io_Bytes.alloc = function(length) {
	return new haxe_io_Bytes(new ArrayBuffer(length));
};
haxe_io_Bytes.ofString = function(s) {
	var a = [];
	var i = 0;
	while(i < s.length) {
		var c = s.charCodeAt(i++);
		if(55296 <= c && c <= 56319) {
			c = c - 55232 << 10 | s.charCodeAt(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 haxe_io_Bytes(new Uint8Array(a).buffer);
};
haxe_io_Bytes.ofData = function(b) {
	var hb = b.hxBytes;
	if(hb != null) {
		return hb;
	}
	return new haxe_io_Bytes(b);
};
haxe_io_Bytes.fastGet = function(b,pos) {
	return b.bytes[pos];
};
haxe_io_Bytes.prototype = {
	length: null
	,b: null
	,__class__: haxe_io_Bytes
};
var haxe_rtti_Meta = function() { };
haxe_rtti_Meta.__name__ = ["haxe","rtti","Meta"];
haxe_rtti_Meta.getType = function(t) {
	var meta = haxe_rtti_Meta.getMeta(t);
	if(meta == null || meta.obj == null) {
		return { };
	} else {
		return meta.obj;
	}
};
haxe_rtti_Meta.getMeta = function(t) {
	return t.__meta__;
};
var js__$Boot_HaxeError = function(val) {
	Error.call(this);
	this.val = val;
	this.message = String(val);
	if(Error.captureStackTrace) {
		Error.captureStackTrace(this,js__$Boot_HaxeError);
	}
};
js__$Boot_HaxeError.__name__ = ["js","_Boot","HaxeError"];
js__$Boot_HaxeError.wrap = function(val) {
	if((val instanceof Error)) {
		return val;
	} else {
		return new js__$Boot_HaxeError(val);
	}
};
js__$Boot_HaxeError.__super__ = Error;
js__$Boot_HaxeError.prototype = $extend(Error.prototype,{
	val: null
	,__class__: js__$Boot_HaxeError
});
var js_Boot = function() { };
js_Boot.__name__ = ["js","Boot"];
js_Boot.__unhtml = function(s) {
	return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
};
js_Boot.__trace = function(v,i) {
	var msg = i != null?i.fileName + ":" + i.lineNumber + ": ":"";
	msg += js_Boot.__string_rec(v,"");
	if(i != null && i.customParams != null) {
		var _g = 0;
		var _g1 = i.customParams;
		while(_g < _g1.length) {
			var v1 = _g1[_g];
			++_g;
			msg += "," + js_Boot.__string_rec(v1,"");
		}
	}
	var d;
	var tmp;
	if(typeof(document) != "undefined") {
		d = document.getElementById("haxe:trace");
		tmp = d != null;
	} else {
		tmp = false;
	}
	if(tmp) {
		d.innerHTML += js_Boot.__unhtml(msg) + "<br/>";
	} else if(typeof console != "undefined" && console.log != null) {
		console.log(msg);
	}
};
js_Boot.getClass = function(o) {
	if((o instanceof Array) && o.__enum__ == null) {
		return Array;
	} else {
		var cl = o.__class__;
		if(cl != null) {
			return cl;
		}
		var name = js_Boot.__nativeClassName(o);
		if(name != null) {
			return js_Boot.__resolveNativeClass(name);
		}
		return null;
	}
};
js_Boot.__string_rec = function(o,s) {
	if(o == null) {
		return "null";
	}
	if(s.length >= 5) {
		return "<...>";
	}
	var t = typeof(o);
	if(t == "function" && (o.__name__ || o.__ename__)) {
		t = "object";
	}
	switch(t) {
	case "function":
		return "<function>";
	case "object":
		if(o instanceof Array) {
			if(o.__enum__) {
				if(o.length == 2) {
					return o[0];
				}
				var str = o[0] + "(";
				s += "\t";
				var _g1 = 2;
				var _g = o.length;
				while(_g1 < _g) {
					var i = _g1++;
					if(i != 2) {
						str += "," + js_Boot.__string_rec(o[i],s);
					} else {
						str += js_Boot.__string_rec(o[i],s);
					}
				}
				return str + ")";
			}
			var l = o.length;
			var i1;
			var str1 = "[";
			s += "\t";
			var _g11 = 0;
			var _g2 = l;
			while(_g11 < _g2) {
				var i2 = _g11++;
				str1 += (i2 > 0?",":"") + js_Boot.__string_rec(o[i2],s);
			}
			str1 += "]";
			return str1;
		}
		var tostr;
		try {
			tostr = o.toString;
		} catch( e ) {
			haxe_CallStack.lastException = e;
			return "???";
		}
		if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
			var s2 = o.toString();
			if(s2 != "[object Object]") {
				return s2;
			}
		}
		var k = null;
		var str2 = "{\n";
		s += "\t";
		var hasp = o.hasOwnProperty != null;
		for( var k in o ) {
		if(hasp && !o.hasOwnProperty(k)) {
			continue;
		}
		if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
			continue;
		}
		if(str2.length != 2) {
			str2 += ", \n";
		}
		str2 += s + k + " : " + js_Boot.__string_rec(o[k],s);
		}
		s = s.substring(1);
		str2 += "\n" + s + "}";
		return str2;
	case "string":
		return o;
	default:
		return String(o);
	}
};
js_Boot.__interfLoop = function(cc,cl) {
	if(cc == null) {
		return false;
	}
	if(cc == cl) {
		return true;
	}
	var intf = cc.__interfaces__;
	if(intf != null) {
		var _g1 = 0;
		var _g = intf.length;
		while(_g1 < _g) {
			var i = intf[_g1++];
			if(i == cl || js_Boot.__interfLoop(i,cl)) {
				return true;
			}
		}
	}
	return js_Boot.__interfLoop(cc.__super__,cl);
};
js_Boot.__instanceof = function(o,cl) {
	if(cl == null) {
		return false;
	}
	switch(cl) {
	case Array:
		if((o instanceof Array)) {
			return o.__enum__ == null;
		} else {
			return false;
		}
		break;
	case Bool:
		return typeof(o) == "boolean";
	case Dynamic:
		return true;
	case Float:
		return typeof(o) == "number";
	case Int:
		if(typeof(o) == "number") {
			return (o|0) === o;
		} else {
			return false;
		}
		break;
	case String:
		return typeof(o) == "string";
	default:
		if(o != null) {
			if(typeof(cl) == "function") {
				if(o instanceof cl) {
					return true;
				}
				if(js_Boot.__interfLoop(js_Boot.getClass(o),cl)) {
					return true;
				}
			} else if(typeof(cl) == "object" && js_Boot.__isNativeObj(cl)) {
				if(o instanceof cl) {
					return true;
				}
			}
		} else {
			return false;
		}
		if(cl == Class?o.__name__ != null:false) {
			return true;
		}
		if(cl == Enum?o.__ename__ != null:false) {
			return true;
		}
		return o.__enum__ == cl;
	}
};
js_Boot.__cast = function(o,t) {
	if(js_Boot.__instanceof(o,t)) {
		return o;
	} else {
		throw new js__$Boot_HaxeError("Cannot cast " + Std.string(o) + " to " + Std.string(t));
	}
};
js_Boot.__nativeClassName = function(o) {
	var name = js_Boot.__toStr.call(o).slice(8,-1);
	if(name == "Object" || name == "Function" || name == "Math" || name == "JSON") {
		return null;
	}
	return name;
};
js_Boot.__isNativeObj = function(o) {
	return js_Boot.__nativeClassName(o) != null;
};
js_Boot.__resolveNativeClass = function(name) {
	return $global[name];
};
var js_node_buffer_Buffer = require("buffer").Buffer;
var mustache__$Context_ContextImpl = function(view,parentContext,partialOverride) {
	this.view = view;
	var _g = new haxe_ds_StringMap();
	if(__map_reserved["."] != null) {
		_g.setReserved(".",view);
	} else {
		_g.h["."] = view;
	}
	this.cache = _g;
	this.parent = parentContext;
	this.partialOverride = partialOverride;
};
mustache__$Context_ContextImpl.__name__ = ["mustache","_Context","ContextImpl"];
mustache__$Context_ContextImpl.getField = function(object,name) {
	var value = Reflect.field(object,name);
	if(Reflect.isFunction(value)) {
		return haxe_ds_Option.Some(function() {
			return value.apply(object,[]);
		});
	}
	if(value != null || Object.prototype.hasOwnProperty.call(object,name)) {
		return haxe_ds_Option.Some(value);
	}
	var o = object;
	var cl = o == null?null:js_Boot.getClass(o);
	if(cl != null && Type.getInstanceFields(cl).indexOf(name) != -1) {
		return haxe_ds_Option.Some(value);
	}
	return haxe_ds_Option.None;
};
mustache__$Context_ContextImpl.prototype = {
	view: null
	,parent: null
	,cache: null
	,partialOverride: null
	,lookup: function(name) {
		var value = null;
		var _this = this.cache;
		if(__map_reserved[name] != null?_this.existsReserved(name):_this.h.hasOwnProperty(name)) {
			var _this1 = this.cache;
			if(__map_reserved[name] != null) {
				value = _this1.getReserved(name);
			} else {
				value = _this1.h[name];
			}
		} else {
			var context = this;
			while(context != null) {
				var found = false;
				if(name.indexOf(".") == -1) {
					var _g = mustache__$Context_ContextImpl.getField(context.view,name);
					switch(_g[1]) {
					case 0:
						found = true;
						value = _g[2];
						break;
					case 1:
						break;
					}
				} else {
					var names = name.split(".");
					var index = 0;
					value = context.view;
					while(value != null && index < names.length) {
						var _g1 = mustache__$Context_ContextImpl.getField(value,names[index++]);
						switch(_g1[1]) {
						case 0:
							if(index == names.length - 1) {
								found = true;
							}
							value = _g1[2];
							break;
						case 1:
							value = null;
							break;
						}
					}
				}
				if(found) {
					break;
				}
				context = context.parent;
			}
			var v = value;
			var _this2 = this.cache;
			if(__map_reserved[name] != null) {
				_this2.setReserved(name,v);
			} else {
				_this2.h[name] = v;
			}
		}
		if(Reflect.isFunction(value)) {
			value = value();
		}
		return value;
	}
	,__class__: mustache__$Context_ContextImpl
};
var mustache_Parser = function() { };
mustache_Parser.__name__ = ["mustache","Parser"];
mustache_Parser.parse = function(template,tags) {
	if(template.length == 0) {
		return [];
	}
	var openingTagRe;
	var closingTagRe;
	var closingCurlyRe;
	var compileTags = function(tags1) {
		if(tags1.length != 2) {
			throw new js__$Boot_HaxeError("Invalid tags: " + Std.string(tags1));
		}
		openingTagRe = new EReg(mustache_Parser.escapeRegExp(tags1[0]) + "\\s*","");
		closingTagRe = new EReg("\\s*" + mustache_Parser.escapeRegExp(tags1[1]),"");
		closingCurlyRe = new EReg("\\s*" + mustache_Parser.escapeRegExp("}" + tags1[1]),"");
	};
	compileTags(tags != null?tags:Mustache.tags);
	var sections = [];
	var tokens = [];
	var spaces = [];
	var hasTag = false;
	var nonSpace = false;
	var scanner = new mustache_Scanner(template);
	while(scanner.tail != "") {
		var start = scanner.pos;
		var value = scanner.scanUntil(openingTagRe);
		if(value.length > 0) {
			var _g1 = 0;
			var _g = value.length;
			while(_g1 < _g) {
				var chr = value.charAt(_g1++);
				if(mustache_Parser.spaceRe.match(chr)) {
					spaces.push(tokens.length);
				} else {
					nonSpace = true;
				}
				tokens.push(new mustache_Token(mustache_TokenType.Text,chr,start,start + 1));
				++start;
				if(chr == "\n") {
					if(hasTag && !nonSpace) {
						var _g2 = 0;
						while(_g2 < spaces.length) {
							var idx = spaces[_g2];
							++_g2;
							tokens[idx] = null;
						}
					}
					spaces = [];
					hasTag = false;
					nonSpace = false;
				}
			}
		}
		if(scanner.scan(openingTagRe).length == 0) {
			break;
		}
		hasTag = true;
		var type = scanner.scan(mustache_Parser.tagRe);
		if(type.length > 0) {
			scanner.scan(mustache_Parser.whiteRe);
		}
		if(type == "=") {
			value = scanner.scanUntil(mustache_Parser.equalsRe);
			scanner.scan(mustache_Parser.equalsRe);
			scanner.scanUntil(closingTagRe);
		} else if(type == "{") {
			value = scanner.scanUntil(closingCurlyRe);
			scanner.scan(mustache_Parser.curlyRe);
			scanner.scanUntil(closingTagRe);
			type = "&";
		} else {
			value = scanner.scanUntil(closingTagRe);
		}
		if(scanner.scan(closingTagRe).length == 0) {
			throw new js__$Boot_HaxeError("Unclosed tag at " + scanner.pos);
		}
		var tokenType;
		switch(type) {
		case "":
			tokenType = mustache_TokenType.Value(true);
			break;
		case "!":
			tokenType = mustache_TokenType.Comment;
			break;
		case "#":
			tokenType = mustache_TokenType.Section(false);
			break;
		case "$":
			tokenType = mustache_TokenType.Block;
			break;
		case "&":
			tokenType = mustache_TokenType.Value(false);
			break;
		case "/":
			tokenType = mustache_TokenType.SectionClose;
			break;
		case "<":
			tokenType = mustache_TokenType.PartialOverride;
			break;
		case "=":
			tokenType = mustache_TokenType.SetDelimiters;
			break;
		case ">":
			tokenType = mustache_TokenType.Partial;
			break;
		case "^":
			tokenType = mustache_TokenType.Section(true);
			break;
		default:
			throw new js__$Boot_HaxeError("unknown token type: " + type);
		}
		var token = new mustache_Token(tokenType,value,start,scanner.pos);
		tokens.push(token);
		switch(tokenType[1]) {
		case 1:
			nonSpace = true;
			break;
		case 3:
			var openSection = sections.pop();
			if(openSection == null) {
				throw new js__$Boot_HaxeError("Unopened section \"" + value + "\" at " + start);
			}
			if(openSection.value != value) {
				throw new js__$Boot_HaxeError("Unclosed section \"" + openSection.value + "\" at " + start);
			}
			break;
		case 6:
			compileTags(mustache_Parser.spaceRe.split(value));
			break;
		case 2:case 7:case 8:
			sections.push(token);
			break;
		default:
		}
	}
	var openSection1 = sections.pop();
	if(openSection1 != null) {
		throw new js__$Boot_HaxeError("Unclosed section \"" + openSection1.value + "\" at " + scanner.pos);
	}
	return mustache_Parser.nestTokens(mustache_Parser.squashTokens(tokens));
};
mustache_Parser.squashTokens = function(tokens) {
	var squashedTokens = [];
	var lastToken = null;
	var _g = 0;
	while(_g < tokens.length) {
		var token = tokens[_g];
		++_g;
		if(token != null) {
			if(token.type == mustache_TokenType.Text && lastToken != null && lastToken.type == mustache_TokenType.Text) {
				lastToken.value += token.value;
				lastToken.endIndex = token.endIndex;
			} else {
				squashedTokens.push(token);
				lastToken = token;
			}
		}
	}
	return squashedTokens;
};
mustache_Parser.nestTokens = function(tokens) {
	var nestedTokens = [];
	var collector = nestedTokens;
	var sections = [];
	var _g = 0;
	while(_g < tokens.length) {
		var token = tokens[_g];
		++_g;
		switch(token.type[1]) {
		case 3:
			sections.pop().sectionEndIndex = token.startIndex;
			if(sections.length > 0) {
				collector = sections[sections.length - 1].subTokens;
			} else {
				collector = nestedTokens;
			}
			break;
		case 2:case 7:case 8:
			collector.push(token);
			sections.push(token);
			collector = token.subTokens = [];
			break;
		default:
			collector.push(token);
		}
	}
	return nestedTokens;
};
mustache_Parser.escapeRegExp = function(string) {
	return mustache_Parser.escapeRegExpRe.map(string,function(r) {
		return "\\" + r.matched(0);
	});
};
var mustache_Scanner = function(string) {
	this.string = string;
	this.tail = string;
	this.pos = 0;
};
mustache_Scanner.__name__ = ["mustache","Scanner"];
mustache_Scanner.prototype = {
	string: null
	,tail: null
	,pos: null
	,scan: function(re) {
		if(!re.match(this.tail)) {
			return "";
		}
		var p = re.matchedPos();
		if(p.pos != 0) {
			return "";
		}
		this.tail = this.tail.substring(p.len);
		this.pos += p.len;
		return re.matched(0);
	}
	,scanUntil: function(re) {
		var match;
		if(re.match(this.tail)) {
			var p = re.matchedPos();
			if(p.pos == 0) {
				match = "";
			} else {
				match = this.tail.substring(0,p.pos);
				this.tail = this.tail.substring(p.pos);
			}
		} else {
			match = this.tail;
			this.tail = "";
		}
		this.pos += match.length;
		return match;
	}
	,__class__: mustache_Scanner
};
var mustache_TokenType = { __ename__ : ["mustache","TokenType"], __constructs__ : ["Text","Value","Section","SectionClose","Partial","Comment","SetDelimiters","PartialOverride","Block"] };
mustache_TokenType.Text = ["Text",0];
mustache_TokenType.Text.toString = $estr;
mustache_TokenType.Text.__enum__ = mustache_TokenType;
mustache_TokenType.Value = function(escaped) { var $x = ["Value",1,escaped]; $x.__enum__ = mustache_TokenType; $x.toString = $estr; return $x; };
mustache_TokenType.Section = function(inverted) { var $x = ["Section",2,inverted]; $x.__enum__ = mustache_TokenType; $x.toString = $estr; return $x; };
mustache_TokenType.SectionClose = ["SectionClose",3];
mustache_TokenType.SectionClose.toString = $estr;
mustache_TokenType.SectionClose.__enum__ = mustache_TokenType;
mustache_TokenType.Partial = ["Partial",4];
mustache_TokenType.Partial.toString = $estr;
mustache_TokenType.Partial.__enum__ = mustache_TokenType;
mustache_TokenType.Comment = ["Comment",5];
mustache_TokenType.Comment.toString = $estr;
mustache_TokenType.Comment.__enum__ = mustache_TokenType;
mustache_TokenType.SetDelimiters = ["SetDelimiters",6];
mustache_TokenType.SetDelimiters.toString = $estr;
mustache_TokenType.SetDelimiters.__enum__ = mustache_TokenType;
mustache_TokenType.PartialOverride = ["PartialOverride",7];
mustache_TokenType.PartialOverride.toString = $estr;
mustache_TokenType.PartialOverride.__enum__ = mustache_TokenType;
mustache_TokenType.Block = ["Block",8];
mustache_TokenType.Block.toString = $estr;
mustache_TokenType.Block.__enum__ = mustache_TokenType;
var mustache_Token = function(type,value,startIndex,endIndex,subTokens,sectionEndIndex) {
	this.type = type;
	this.value = value;
	this.startIndex = startIndex;
	this.endIndex = endIndex;
	this.subTokens = subTokens;
	this.sectionEndIndex = sectionEndIndex;
};
mustache_Token.__name__ = ["mustache","Token"];
mustache_Token.prototype = {
	type: null
	,value: null
	,startIndex: null
	,endIndex: null
	,subTokens: null
	,sectionEndIndex: null
	,__class__: mustache_Token
};
var promhx_base_AsyncBase = function(d) {
	this._resolved = false;
	this._pending = false;
	this._errorPending = false;
	this._fulfilled = false;
	this._update = [];
	this._error = [];
	this._errored = false;
	if(d != null) {
		var next = this;
		var f = function(x) {
			return x;
		};
		d._update.push({ async : next, linkf : function(x1) {
			var tmp = f(x1);
			next.handleResolve(tmp);
		}});
		promhx_base_AsyncBase.immediateLinkUpdate(d,next,f);
	}
};
promhx_base_AsyncBase.__name__ = ["promhx","base","AsyncBase"];
promhx_base_AsyncBase.immediateLinkUpdate = function(current,next,f) {
	if(current._errored && !current._errorPending && current._error.length <= 0) {
		next.handleError(current._errorVal);
	}
	if(current._resolved && !current._pending) {
		try {
			next.handleResolve(f(current._val));
		} catch( e ) {
			haxe_CallStack.lastException = e;
			if (e instanceof js__$Boot_HaxeError) e = e.val;
			next.handleError(e);
		}
	}
};
promhx_base_AsyncBase.prototype = {
	_val: null
	,_resolved: null
	,_fulfilled: null
	,_pending: null
	,_update: null
	,_error: null
	,_errored: null
	,_errorMap: null
	,_errorVal: null
	,_errorPending: null
	,catchError: function(f) {
		this._error.push(f);
		return this;
	}
	,handleResolve: function(val) {
		this._resolve(val);
	}
	,_resolve: function(val) {
		var _gthis = this;
		if(this._pending) {
			var f = $bind(this,this._resolve);
			var a1 = val;
			var tmp = function() {
				f(a1);
			};
			promhx_base_EventLoop.queue.add(tmp);
			promhx_base_EventLoop.continueOnNextLoop();
		} else {
			this._resolved = true;
			this._pending = true;
			promhx_base_EventLoop.queue.add(function() {
				_gthis._val = val;
				var _g = 0;
				var _g1 = _gthis._update;
				while(_g < _g1.length) {
					var up = _g1[_g];
					++_g;
					try {
						up.linkf(val);
					} catch( e ) {
						haxe_CallStack.lastException = e;
						if (e instanceof js__$Boot_HaxeError) e = e.val;
						up.async.handleError(e);
					}
				}
				_gthis._fulfilled = true;
				_gthis._pending = false;
			});
			promhx_base_EventLoop.continueOnNextLoop();
		}
	}
	,handleError: function(error) {
		this._handleError(error);
	}
	,_handleError: function(error) {
		var _gthis = this;
		var update_errors = function(e) {
			if(_gthis._error.length > 0) {
				var _g = 0;
				var _g1 = _gthis._error;
				while(_g < _g1.length) {
					var ef = _g1[_g];
					++_g;
					ef(e);
				}
			} else if(_gthis._update.length > 0) {
				var _g2 = 0;
				var _g11 = _gthis._update;
				while(_g2 < _g11.length) {
					var up = _g11[_g2];
					++_g2;
					up.async.handleError(e);
				}
			} else {
				haxe_Log.trace("Call Stack: " + haxe_CallStack.toString(haxe_CallStack.callStack()),{ fileName : "AsyncBase.hx", lineNumber : 192, className : "promhx.base.AsyncBase", methodName : "_handleError"});
				throw js__$Boot_HaxeError.wrap(e);
			}
			_gthis._errorPending = false;
		};
		if(!this._errorPending) {
			this._errorPending = true;
			this._errored = true;
			this._errorVal = error;
			promhx_base_EventLoop.queue.add(function() {
				if(_gthis._errorMap != null) {
					try {
						var tmp = _gthis._errorMap(error);
						_gthis._resolve(tmp);
					} catch( e1 ) {
						haxe_CallStack.lastException = e1;
						if (e1 instanceof js__$Boot_HaxeError) e1 = e1.val;
						update_errors(e1);
					}
				} else {
					update_errors(error);
				}
			});
			promhx_base_EventLoop.continueOnNextLoop();
		}
	}
	,then: function(f) {
		var ret = new promhx_base_AsyncBase(null);
		var next = ret;
		var f1 = f;
		this._update.push({ async : next, linkf : function(x) {
			var tmp = f1(x);
			next.handleResolve(tmp);
		}});
		promhx_base_AsyncBase.immediateLinkUpdate(this,next,f1);
		return ret;
	}
	,__class__: promhx_base_AsyncBase
};
var promhx_Deferred = $hx_exports["promhx"]["Deferred"] = function() {
	promhx_base_AsyncBase.call(this);
};
promhx_Deferred.__name__ = ["promhx","Deferred"];
promhx_Deferred.__super__ = promhx_base_AsyncBase;
promhx_Deferred.prototype = $extend(promhx_base_AsyncBase.prototype,{
	resolve: function(val) {
		this.handleResolve(val);
	}
	,promise: function() {
		return new promhx_Promise(this);
	}
	,__class__: promhx_Deferred
});
var promhx_Promise = $hx_exports["promhx"]["Promise"] = function(d) {
	promhx_base_AsyncBase.call(this,d);
	this._rejected = false;
};
promhx_Promise.__name__ = ["promhx","Promise"];
promhx_Promise.__super__ = promhx_base_AsyncBase;
promhx_Promise.prototype = $extend(promhx_base_AsyncBase.prototype,{
	_rejected: null
	,handleResolve: function(val) {
		if(this._resolved) {
			throw new js__$Boot_HaxeError(promhx_error_PromiseError.AlreadyResolved("Promise has already been resolved"));
		}
		this._resolve(val);
	}
	,then: function(f) {
		var ret = new promhx_Promise(null);
		var next = ret;
		var f1 = f;
		this._update.push({ async : next, linkf : function(x) {
			var tmp = f1(x);
			next.handleResolve(tmp);
		}});
		promhx_base_AsyncBase.immediateLinkUpdate(this,next,f1);
		return ret;
	}
	,handleError: function(error) {
		this._rejected = true;
		this._handleError(error);
	}
	,__class__: promhx_Promise
});
var promhx_base_EventLoop = function() { };
promhx_base_EventLoop.__name__ = ["promhx","base","EventLoop"];
promhx_base_EventLoop.f = function() {
	var fn = promhx_base_EventLoop.queue.pop();
	if(fn != null) {
		fn();
	}
	if(!promhx_base_EventLoop.queue.isEmpty()) {
		promhx_base_EventLoop.continueOnNextLoop();
	}
};
promhx_base_EventLoop.continueOnNextLoop = function() {
	if(promhx_base_EventLoop.nextLoop != null) {
		promhx_base_EventLoop.nextLoop(promhx_base_EventLoop.f);
	} else {
		setImmediate(promhx_base_EventLoop.f);
	}
};
var promhx_error_PromiseError = { __ename__ : ["promhx","error","PromiseError"], __constructs__ : ["AlreadyResolved","DownstreamNotFullfilled"] };
promhx_error_PromiseError.AlreadyResolved = function(message) { var $x = ["AlreadyResolved",0,message]; $x.__enum__ = promhx_error_PromiseError; $x.toString = $estr; return $x; };
promhx_error_PromiseError.DownstreamNotFullfilled = function(message) { var $x = ["DownstreamNotFullfilled",1,message]; $x.__enum__ = promhx_error_PromiseError; $x.toString = $estr; return $x; };
var utest_Assert = function() { };
utest_Assert.__name__ = ["utest","Assert"];
utest_Assert.isTrue = function(cond,msg,pos) {
	if(utest_Assert.results == null) {
		throw new js__$Boot_HaxeError("Assert.results is not currently bound to any assert context");
	}
	if(null == msg) {
		msg = "expected true";
	}
	if(cond) {
		utest_Assert.results.add(utest_Assertation.Success(pos));
	} else {
		utest_Assert.results.add(utest_Assertation.Failure(msg,pos));
	}
};
utest_Assert.equals = function(expected,value,msg,pos) {
	if(msg == null) {
		msg = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value);
	}
	utest_Assert.isTrue(expected == value,msg,pos);
};
utest_Assert.match = function(pattern,value,msg,pos) {
	if(msg == null) {
		msg = "the value " + utest_Assert.q(value) + " does not match the provided pattern";
	}
	utest_Assert.isTrue(pattern.match(value),msg,pos);
};
utest_Assert._floatEquals = function(expected,value,approx) {
	if(isNaN(expected)) {
		return isNaN(value);
	} else if(isNaN(value)) {
		return false;
	} else if(!isFinite(expected) && !isFinite(value)) {
		return expected > 0 == value > 0;
	}
	if(null == approx) {
		approx = 1e-5;
	}
	return Math.abs(value - expected) <= approx;
};
utest_Assert.getTypeName = function(v) {
	var _g = Type["typeof"](v);
	switch(_g[1]) {
	case 0:
		return "`null`";
	case 1:
		return "Int";
	case 2:
		return "Float";
	case 3:
		return "Bool";
	case 4:
		return "Object";
	case 5:
		return "function";
	case 6:
		return Type.getClassName(_g[2]);
	case 7:
		return Type.getEnumName(_g[2]);
	case 8:
		return "`Unknown`";
	}
};
utest_Assert.isIterable = function(v,isAnonym) {
	if(!Lambda.has(isAnonym?Reflect.fields(v):Type.getInstanceFields(v == null?null:js_Boot.getClass(v)),"iterator")) {
		return false;
	}
	return Reflect.isFunction(Reflect.field(v,"iterator"));
};
utest_Assert.isIterator = function(v,isAnonym) {
	var fields = isAnonym?Reflect.fields(v):Type.getInstanceFields(v == null?null:js_Boot.getClass(v));
	if(!Lambda.has(fields,"next") || !Lambda.has(fields,"hasNext")) {
		return false;
	}
	if(Reflect.isFunction(Reflect.field(v,"next"))) {
		return Reflect.isFunction(Reflect.field(v,"hasNext"));
	} else {
		return false;
	}
};
utest_Assert.sameAs = function(expected,value,status,approx) {
	var texpected = utest_Assert.getTypeName(expected);
	var tvalue = utest_Assert.getTypeName(value);
	if(texpected != tvalue && !(texpected == "Int" && tvalue == "Float" || texpected == "Float" && tvalue == "Int")) {
		status.error = "expected type " + texpected + " but it is " + tvalue + (status.path == ""?"":" for field " + status.path);
		return false;
	}
	var _g = Type["typeof"](expected);
	switch(_g[1]) {
	case 1:case 2:
		if(!utest_Assert._floatEquals(expected,value,approx)) {
			status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
			return false;
		}
		return true;
	case 0:case 3:
		if(expected != value) {
			status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
			return false;
		}
		return true;
	case 4:
		if(status.recursive || status.path == "") {
			var tfields = Reflect.fields(value);
			var fields = Reflect.fields(expected);
			var path = status.path;
			var _g1 = 0;
			while(_g1 < fields.length) {
				var field = fields[_g1];
				++_g1;
				HxOverrides.remove(tfields,field);
				status.path = path == ""?field:path + "." + field;
				if(!Object.prototype.hasOwnProperty.call(value,field)) {
					status.error = "expected field " + status.path + " does not exist in " + utest_Assert.q(value);
					return false;
				}
				var e = Reflect.field(expected,field);
				if(Reflect.isFunction(e)) {
					continue;
				}
				if(!utest_Assert.sameAs(e,Reflect.field(value,field),status,approx)) {
					return false;
				}
			}
			if(tfields.length > 0) {
				status.error = "the tested object has extra field(s) (" + tfields.join(", ") + ") not included in the expected ones";
				return false;
			}
		}
		if(utest_Assert.isIterator(expected,true)) {
			if(!utest_Assert.isIterator(value,true)) {
				status.error = "expected Iterable but it is not " + (status.path == ""?"":" for field " + status.path);
				return false;
			}
			if(status.recursive || status.path == "") {
				var evalues = Lambda.array({ iterator : function() {
					return expected;
				}});
				var vvalues = Lambda.array({ iterator : function() {
					return value;
				}});
				if(evalues.length != vvalues.length) {
					status.error = "expected " + evalues.length + " values in Iterator but they are " + vvalues.length + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path1 = status.path;
				var _g11 = 0;
				var _g2 = evalues.length;
				while(_g11 < _g2) {
					var i = _g11++;
					status.path = path1 == ""?"iterator[" + i + "]":path1 + "[" + i + "]";
					if(!utest_Assert.sameAs(evalues[i],vvalues[i],status,approx)) {
						status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
						return false;
					}
				}
			}
			return true;
		}
		if(utest_Assert.isIterable(expected,true)) {
			if(!utest_Assert.isIterable(value,true)) {
				status.error = "expected Iterator but it is not " + (status.path == ""?"":" for field " + status.path);
				return false;
			}
			if(status.recursive || status.path == "") {
				var evalues1 = Lambda.array(expected);
				var vvalues1 = Lambda.array(value);
				if(evalues1.length != vvalues1.length) {
					status.error = "expected " + evalues1.length + " values in Iterable but they are " + vvalues1.length + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path2 = status.path;
				var _g12 = 0;
				var _g3 = evalues1.length;
				while(_g12 < _g3) {
					var i1 = _g12++;
					status.path = path2 == ""?"iterable[" + i1 + "]":path2 + "[" + i1 + "]";
					if(!utest_Assert.sameAs(evalues1[i1],vvalues1[i1],status,approx)) {
						return false;
					}
				}
			}
			return true;
		}
		return true;
	case 5:
		if(!Reflect.compareMethods(expected,value)) {
			status.error = "expected same function reference" + (status.path == ""?"":" for field " + status.path);
			return false;
		}
		return true;
	case 6:
		var cexpected = Type.getClassName(_g[2]);
		var o = value;
		var cvalue = Type.getClassName(o == null?null:js_Boot.getClass(o));
		if(cexpected != cvalue) {
			status.error = "expected instance of " + utest_Assert.q(cexpected) + " but it is " + utest_Assert.q(cvalue) + (status.path == ""?"":" for field " + status.path);
			return false;
		}
		if(typeof(expected) == "string" && expected != value) {
			status.error = "expected string '" + Std.string(expected) + "' but it is '" + Std.string(value) + "'";
			return false;
		}
		if((expected instanceof Array) && expected.__enum__ == null) {
			if(status.recursive || status.path == "") {
				if(expected.length != value.length) {
					status.error = "expected " + Std.string(expected.length) + " elements but they are " + Std.string(value.length) + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path3 = status.path;
				var _g13 = 0;
				var _g4 = expected.length;
				while(_g13 < _g4) {
					var i2 = _g13++;
					status.path = path3 == ""?"array[" + i2 + "]":path3 + "[" + i2 + "]";
					if(!utest_Assert.sameAs(expected[i2],value[i2],status,approx)) {
						status.error = "expected array element at [" + i2 + "] to be " + utest_Assert.q(expected[i2]) + " but it is " + utest_Assert.q(value[i2]) + (status.path == ""?"":" for field " + status.path);
						return false;
					}
				}
			}
			return true;
		}
		if(js_Boot.__instanceof(expected,Date)) {
			if(expected.getTime() != value.getTime()) {
				status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
				return false;
			}
			return true;
		}
		if(js_Boot.__instanceof(expected,haxe_io_Bytes)) {
			if(status.recursive || status.path == "") {
				var ebytes = expected;
				var vbytes = value;
				if(ebytes.length != vbytes.length) {
					return false;
				}
				var _g14 = 0;
				var _g5 = ebytes.length;
				while(_g14 < _g5) {
					var i3 = _g14++;
					if(ebytes.b[i3] != vbytes.b[i3]) {
						status.error = "expected byte " + ebytes.b[i3] + " but it is " + vbytes.b[i3] + (status.path == ""?"":" for field " + status.path);
						return false;
					}
				}
			}
			return true;
		}
		if(js_Boot.__instanceof(expected,haxe_IMap)) {
			if(status.recursive || status.path == "") {
				var map = js_Boot.__cast(expected , haxe_IMap);
				var vmap = js_Boot.__cast(value , haxe_IMap);
				var _g6 = [];
				var tmp = map.keys();
				while(tmp.hasNext()) _g6.push(tmp.next());
				var keys = _g6;
				var _g15 = [];
				var tmp1 = vmap.keys();
				while(tmp1.hasNext()) _g15.push(tmp1.next());
				var vkeys = _g15;
				if(keys.length != vkeys.length) {
					status.error = "expected " + keys.length + " keys but they are " + vkeys.length + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path4 = status.path;
				var _g21 = 0;
				while(_g21 < keys.length) {
					var key = keys[_g21];
					++_g21;
					status.path = path4 == ""?"hash[" + Std.string(key) + "]":path4 + "[" + Std.string(key) + "]";
					if(!utest_Assert.sameAs(map.get(key),vmap.get(key),status,approx)) {
						status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
						return false;
					}
				}
			}
			return true;
		}
		if(utest_Assert.isIterator(expected,false)) {
			if(status.recursive || status.path == "") {
				var evalues2 = Lambda.array({ iterator : function() {
					return expected;
				}});
				var vvalues2 = Lambda.array({ iterator : function() {
					return value;
				}});
				if(evalues2.length != vvalues2.length) {
					status.error = "expected " + evalues2.length + " values in Iterator but they are " + vvalues2.length + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path5 = status.path;
				var _g16 = 0;
				var _g7 = evalues2.length;
				while(_g16 < _g7) {
					var i4 = _g16++;
					status.path = path5 == ""?"iterator[" + i4 + "]":path5 + "[" + i4 + "]";
					if(!utest_Assert.sameAs(evalues2[i4],vvalues2[i4],status,approx)) {
						status.error = "expected " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path);
						return false;
					}
				}
			}
			return true;
		}
		if(utest_Assert.isIterable(expected,false)) {
			if(status.recursive || status.path == "") {
				var evalues3 = Lambda.array(expected);
				var vvalues3 = Lambda.array(value);
				if(evalues3.length != vvalues3.length) {
					status.error = "expected " + evalues3.length + " values in Iterable but they are " + vvalues3.length + (status.path == ""?"":" for field " + status.path);
					return false;
				}
				var path6 = status.path;
				var _g17 = 0;
				var _g8 = evalues3.length;
				while(_g17 < _g8) {
					var i5 = _g17++;
					status.path = path6 == ""?"iterable[" + i5 + "]":path6 + "[" + i5 + "]";
					if(!utest_Assert.sameAs(evalues3[i5],vvalues3[i5],status,approx)) {
						return false;
					}
				}
			}
			return true;
		}
		if(status.recursive || status.path == "") {
			var o1 = expected;
			var fields1 = Type.getInstanceFields(o1 == null?null:js_Boot.getClass(o1));
			var path7 = status.path;
			var _g9 = 0;
			while(_g9 < fields1.length) {
				var field1 = fields1[_g9];
				++_g9;
				status.path = path7 == ""?field1:path7 + "." + field1;
				var e1 = Reflect.field(expected,field1);
				if(Reflect.isFunction(e1)) {
					continue;
				}
				if(!utest_Assert.sameAs(e1,Reflect.field(value,field1),status,approx)) {
					return false;
				}
			}
		}
		return true;
	case 7:
		var eexpected = Type.getEnumName(_g[2]);
		var evalue = Type.getEnumName(Type.getEnum(value));
		if(eexpected != evalue) {
			status.error = "expected enumeration of " + utest_Assert.q(eexpected) + " but it is " + utest_Assert.q(evalue) + (status.path == ""?"":" for field " + status.path);
			return false;
		}
		if(status.recursive || status.path == "") {
			if(expected[1] != value[1]) {
				status.error = "expected enum constructor " + utest_Assert.q(expected[0]) + " but it is " + utest_Assert.q(value[0]) + (status.path == ""?"":" for field " + status.path);
				return false;
			}
			var eparams = expected.slice(2);
			var vparams = value.slice(2);
			var path8 = status.path;
			var _g18 = 0;
			var _g10 = eparams.length;
			while(_g18 < _g10) {
				var i6 = _g18++;
				status.path = path8 == ""?"enum[" + i6 + "]":path8 + "[" + i6 + "]";
				if(!utest_Assert.sameAs(eparams[i6],vparams[i6],status,approx)) {
					status.error = "expected enum param " + utest_Assert.q(expected) + " but it is " + utest_Assert.q(value) + (status.path == ""?"":" for field " + status.path) + " with " + status.error;
					return false;
				}
			}
		}
		return true;
	case 8:
		throw new js__$Boot_HaxeError("Unable to compare two unknown types");
		break;
	}
};
utest_Assert.q = function(v) {
	if(typeof(v) == "string") {
		return "\"" + StringTools.replace(v,"\"","\\\"") + "\"";
	} else {
		return Std.string(v);
	}
};
utest_Assert.same = function(expected,value,recursive,msg,approx,pos) {
	if(null == approx) {
		approx = 1e-5;
	}
	var status = { recursive : null == recursive?true:recursive, path : "", error : null};
	if(utest_Assert.sameAs(expected,value,status,approx)) {
		utest_Assert.pass(msg,pos);
	} else {
		utest_Assert.fail(msg == null?status.error:msg,pos);
	}
};
utest_Assert.pass = function(msg,pos) {
	if(msg == null) {
		msg = "pass expected";
	}
	utest_Assert.isTrue(true,msg,pos);
};
utest_Assert.fail = function(msg,pos) {
	if(msg == null) {
		msg = "failure expected";
	}
	utest_Assert.isTrue(false,msg,pos);
};
var utest_Assertation = { __ename__ : ["utest","Assertation"], __constructs__ : ["Success","Failure","Error","SetupError","TeardownError","TimeoutError","AsyncError","Warning"] };
utest_Assertation.Success = function(pos) { var $x = ["Success",0,pos]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.Failure = function(msg,pos) { var $x = ["Failure",1,msg,pos]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.Error = function(e,stack) { var $x = ["Error",2,e,stack]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.SetupError = function(e,stack) { var $x = ["SetupError",3,e,stack]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.TeardownError = function(e,stack) { var $x = ["TeardownError",4,e,stack]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.TimeoutError = function(missedAsyncs,stack) { var $x = ["TimeoutError",5,missedAsyncs,stack]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.AsyncError = function(e,stack) { var $x = ["AsyncError",6,e,stack]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
utest_Assertation.Warning = function(msg) { var $x = ["Warning",7,msg]; $x.__enum__ = utest_Assertation; $x.toString = $estr; return $x; };
function $iterator(o) { if( o instanceof Array ) return function() { return HxOverrides.iter(o); }; return typeof(o.iterator) == 'function' ? $bind(o,o.iterator) : o.iterator; }
var $_, $fid = 0;
function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $fid++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = function(){ return f.method.apply(f.scope, arguments); }; f.scope = o; f.method = m; o.hx__closures__[m.__id__] = f; } return f; }
String.prototype.__class__ = String;
String.__name__ = ["String"];
Array.__name__ = ["Array"];
Date.prototype.__class__ = Date;
Date.__name__ = ["Date"];
var Int = { __name__ : ["Int"]};
var Dynamic = { __name__ : ["Dynamic"]};
var Float = Number;
Float.__name__ = ["Float"];
var Bool = Boolean;
Bool.__ename__ = ["Bool"];
var Class = { __name__ : ["Class"]};
var Enum = { };
var __map_reserved = {}
buddy_BuddySuite.useDefaultTrace = false;
mustache_Writer.entityMap = (function($this) {
	var $r;
	var _g = new haxe_ds_StringMap();
	if(__map_reserved["&"] != null) {
		_g.setReserved("&","&amp;");
	} else {
		_g.h["&"] = "&amp;";
	}
	if(__map_reserved["<"] != null) {
		_g.setReserved("<","&lt;");
	} else {
		_g.h["<"] = "&lt;";
	}
	if(__map_reserved[">"] != null) {
		_g.setReserved(">","&gt;");
	} else {
		_g.h[">"] = "&gt;";
	}
	if(__map_reserved["\""] != null) {
		_g.setReserved("\"","&quot;");
	} else {
		_g.h["\""] = "&quot;";
	}
	if(__map_reserved["'"] != null) {
		_g.setReserved("'","&#39;");
	} else {
		_g.h["'"] = "&#39;";
	}
	if(__map_reserved["/"] != null) {
		_g.setReserved("/","&#x2F;");
	} else {
		_g.h["/"] = "&#x2F;";
	}
	if(__map_reserved["`"] != null) {
		_g.setReserved("`","&#x60;");
	} else {
		_g.h["`"] = "&#x60;";
	}
	if(__map_reserved["="] != null) {
		_g.setReserved("=","&#x3D;");
	} else {
		_g.h["="] = "&#x3D;";
	}
	$r = _g;
	return $r;
}(this));
mustache_Writer.escapeRe = new EReg("[&<>\"'`=/]","g");
Mustache.tags = ["{{","}}"];
Mustache.defaultWriter = new mustache_Writer();
TestSpec.specFiles = (function($this) {
	var $r;
	var result = [];
	{
		var _g = 0;
		var _g1 = js_node_Fs.readdirSync("spec/specs");
		while(_g < _g1.length) {
			var file = _g1[_g];
			++_g;
			var p = new haxe_io_Path(file);
			if(p.ext == "json" && p.file != "~lambdas") {
				result.push(p.file);
			}
		}
	}
	result.push("inheritance");
	$r = result;
	return $r;
}(this));
js_Boot.__toStr = ({ }).toString;
mustache_Parser.escapeRegExpRe = new EReg("[\\-\\[\\]{}()*+?.,\\\\\\^$|#\\s]","g");
mustache_Parser.tagRe = new EReg("#|\\^|/|>|\\{|&|=|<|\\$|!","");
mustache_Parser.whiteRe = new EReg("\\s*","");
mustache_Parser.spaceRe = new EReg("\\s+","");
mustache_Parser.equalsRe = new EReg("\\s*=","");
mustache_Parser.curlyRe = new EReg("\\s*\\}","");
promhx_base_EventLoop.queue = new List();
TestMain.main();
})(typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this, typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this);