NodeMain.js

(function () { "use strict";
var $estr = function() { return js.Boot.__string_rec(this,''); };
var Base64 = function() { }
Base64.__name__ = true;
Base64.encode = function(str) {
	var r = haxe.BaseCode.encode(str,Base64.chars);
	switch(r.length % 4) {
	case 2:
		r += "==";
		break;
	case 3:
		r += "=";
		break;
	}
	return r;
}
Base64.decode = function(str) {
	return haxe.BaseCode.decode(HxOverrides.substr(str,0,str.lastIndexOf("=")),Base64.chars);
}
var ClientAdapter = function() { }
ClientAdapter.__name__ = true;
ClientAdapter.prototype = {
	__class__: ClientAdapter
}
var ServerAdapter = function() { }
ServerAdapter.__name__ = true;
ServerAdapter.prototype = {
	__class__: ServerAdapter
}
var DevToolAdapter = function() {
	var _g = this;
	var connect = js.Node.require("connect");
	var WebSocketServer = js.Node.require("websocket").server;
	this.httpServer = connect.createServer(connect.errorHandler({ showStack : true, showMessage : true, dumpExceptions : true}),(Reflect.field(connect,"static"))(js.Node.__dirname,{ redirect : true}));
	var server = this.httpServer.listen(8080);
	this.log(" Server is listening on port 8080");
	this.wsServer =  new WebSocketServer({'httpServer': server,'autoAcceptConnections':false});
	this.wsServer.on("request",function(request) {
		var lastrequest = null;
		var eventid = 0;
		if(!_g.originIsAllowed(request.origin)) {
			request.reject();
			_g.log(" Connection from origin " + request.origin + " rejected.");
			return;
		}
		var cookies = null;
		_g.wsConnection = request.accept(null,request.origin,cookies,function() {
			_g.handleDevToolsConnect();
			_g.log(" Connection accepted.");
		});
		_g.wsConnection.on("message",function(message) {
			if(message.type == "utf8") {
				_g.log("Received Message: " + message.utf8Data);
				_g.handleDevToolRequest(message.utf8Data);
			} else if(message.type == "binary") _g.log("Received Binary Message of " + message.binaryData.length + " bytes");
		});
		_g.wsConnection.on("close",function(reasonCode,description) {
			_g.log(" Peer " + _g.wsConnection.remoteAddress + " disconnected.");
			_g.wsConnection = null;
		});
	});
};
DevToolAdapter.__name__ = true;
DevToolAdapter.__interfaces__ = [ServerAdapter];
DevToolAdapter.prototype = {
	log: function(msg) {
		console.log(Std.string(new Date()) + " [DEVTOOL] " + msg);
	}
	,sendNotification: function(method,params) {
		if(this.wsConnection == null) return;
		var packet = js.Node.stringify({ method : method, params : params});
		this.wsConnection.sendUTF(packet);
		this.log("Sent Notification: " + packet);
	}
	,setRequestHandler: function(handler) {
		this.requestHandler = handler;
	}
	,sendAsyncResponse: function(tid,responseObj) {
		if(this.wsConnection == null) return;
		var packet = js.Node.stringify({ result : responseObj, id : tid});
		this.wsConnection.sendUTF(packet);
		this.log("Sent Response: " + packet);
	}
	,handleDevToolRequest: function(buffer) {
		var _g = this;
		var clientRequest = js.Node.parse(buffer);
		this.requestHandler(clientRequest.id,clientRequest.method,clientRequest.params,function(result) {
			_g.sendAsyncResponse(clientRequest.id,result);
		});
	}
	,handleDevToolsConnect: function() {
		this.sendNotification("Debugger.enabled",true);
	}
	,originIsAllowed: function(origin) {
		this.log("Request from Origin:" + origin);
		return true;
	}
	,isConnected: function() {
		return this.wsConnection != null && this.wsConnection.connected;
	}
	,__class__: DevToolAdapter
}
var Hash = function() {
	this.h = { };
};
Hash.__name__ = true;
Hash.prototype = {
	toString: function() {
		var s = new StringBuf();
		s.b += Std.string("{");
		var it = this.keys();
		while( it.hasNext() ) {
			var i = it.next();
			s.b += Std.string(i);
			s.b += Std.string(" => ");
			s.b += Std.string(Std.string(this.get(i)));
			if(it.hasNext()) s.b += Std.string(", ");
		}
		s.b += Std.string("}");
		return s.b;
	}
	,iterator: function() {
		return { ref : this.h, it : this.keys(), hasNext : function() {
			return this.it.hasNext();
		}, next : function() {
			var i = this.it.next();
			return this.ref["$" + i];
		}};
	}
	,keys: function() {
		var a = [];
		for( var key in this.h ) {
		if(this.h.hasOwnProperty(key)) a.push(key.substr(1));
		}
		return HxOverrides.iter(a);
	}
	,remove: function(key) {
		key = "$" + key;
		if(!this.h.hasOwnProperty(key)) return false;
		delete(this.h[key]);
		return true;
	}
	,exists: function(key) {
		return this.h.hasOwnProperty("$" + key);
	}
	,get: function(key) {
		return this.h["$" + key];
	}
	,set: function(key,value) {
		this.h["$" + key] = value;
	}
	,__class__: Hash
}
var HxOverrides = function() { }
HxOverrides.__name__ = true;
HxOverrides.dateStr = function(date) {
	var m = date.getMonth() + 1;
	var d = date.getDate();
	var h = date.getHours();
	var mi = date.getMinutes();
	var s = date.getSeconds();
	return date.getFullYear() + "-" + (m < 10?"0" + m:"" + m) + "-" + (d < 10?"0" + d:"" + d) + " " + (h < 10?"0" + h:"" + h) + ":" + (mi < 10?"0" + mi:"" + mi) + ":" + (s < 10?"0" + s:"" + s);
}
HxOverrides.strDate = function(s) {
	switch(s.length) {
	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 k = s.split("-");
		return new Date(k[0],k[1] - 1,k[2],0,0,0);
	case 19:
		var k = s.split(" ");
		var y = k[0].split("-");
		var t = k[1].split(":");
		return new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
	default:
		throw "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(pos != null && pos != 0 && len != null && len < 0) return "";
	if(len == null) len = s.length;
	if(pos < 0) {
		pos = s.length + pos;
		if(pos < 0) pos = 0;
	} else if(len < 0) len = s.length + len - pos;
	return s.substr(pos,len);
}
HxOverrides.remove = function(a,obj) {
	var i = 0;
	var l = a.length;
	while(i < l) {
		if(a[i] == obj) {
			a.splice(i,1);
			return true;
		}
		i++;
	}
	return false;
}
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 IntIter = function(min,max) {
	this.min = min;
	this.max = max;
};
IntIter.__name__ = true;
IntIter.prototype = {
	next: function() {
		return this.min++;
	}
	,hasNext: function() {
		return this.min < this.max;
	}
	,__class__: IntIter
}
var Lambda = function() { }
Lambda.__name__ = true;
Lambda.array = function(it) {
	var a = new Array();
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var i = $it0.next();
		a.push(i);
	}
	return a;
}
Lambda.list = function(it) {
	var l = new List();
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var i = $it0.next();
		l.add(i);
	}
	return l;
}
Lambda.map = function(it,f) {
	var l = new List();
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		l.add(f(x));
	}
	return l;
}
Lambda.mapi = function(it,f) {
	var l = new List();
	var i = 0;
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		l.add(f(i++,x));
	}
	return l;
}
Lambda.has = function(it,elt,cmp) {
	if(cmp == null) {
		var $it0 = $iterator(it)();
		while( $it0.hasNext() ) {
			var x = $it0.next();
			if(x == elt) return true;
		}
	} else {
		var $it1 = $iterator(it)();
		while( $it1.hasNext() ) {
			var x = $it1.next();
			if(cmp(x,elt)) return true;
		}
	}
	return false;
}
Lambda.exists = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		if(f(x)) return true;
	}
	return false;
}
Lambda.foreach = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		if(!f(x)) return false;
	}
	return true;
}
Lambda.iter = function(it,f) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		f(x);
	}
}
Lambda.filter = function(it,f) {
	var l = new List();
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		if(f(x)) l.add(x);
	}
	return l;
}
Lambda.fold = function(it,f,first) {
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		first = f(x,first);
	}
	return first;
}
Lambda.count = function(it,pred) {
	var n = 0;
	if(pred == null) {
		var $it0 = $iterator(it)();
		while( $it0.hasNext() ) {
			var _ = $it0.next();
			n++;
		}
	} else {
		var $it1 = $iterator(it)();
		while( $it1.hasNext() ) {
			var x = $it1.next();
			if(pred(x)) n++;
		}
	}
	return n;
}
Lambda.empty = function(it) {
	return !$iterator(it)().hasNext();
}
Lambda.indexOf = function(it,v) {
	var i = 0;
	var $it0 = $iterator(it)();
	while( $it0.hasNext() ) {
		var v2 = $it0.next();
		if(v == v2) return i;
		i++;
	}
	return -1;
}
Lambda.concat = function(a,b) {
	var l = new List();
	var $it0 = $iterator(a)();
	while( $it0.hasNext() ) {
		var x = $it0.next();
		l.add(x);
	}
	var $it1 = $iterator(b)();
	while( $it1.hasNext() ) {
		var x = $it1.next();
		l.add(x);
	}
	return l;
}
var List = function() {
	this.length = 0;
};
List.__name__ = true;
List.prototype = {
	map: function(f) {
		var b = new List();
		var l = this.h;
		while(l != null) {
			var v = l[0];
			l = l[1];
			b.add(f(v));
		}
		return b;
	}
	,filter: function(f) {
		var l2 = new List();
		var l = this.h;
		while(l != null) {
			var v = l[0];
			l = l[1];
			if(f(v)) l2.add(v);
		}
		return l2;
	}
	,join: function(sep) {
		var s = new StringBuf();
		var first = true;
		var l = this.h;
		while(l != null) {
			if(first) first = false; else s.b += Std.string(sep);
			s.b += Std.string(l[0]);
			l = l[1];
		}
		return s.b;
	}
	,toString: function() {
		var s = new StringBuf();
		var first = true;
		var l = this.h;
		s.b += Std.string("{");
		while(l != null) {
			if(first) first = false; else s.b += Std.string(", ");
			s.b += Std.string(Std.string(l[0]));
			l = l[1];
		}
		s.b += Std.string("}");
		return s.b;
	}
	,iterator: function() {
		return { h : this.h, hasNext : function() {
			return this.h != null;
		}, next : function() {
			if(this.h == null) return null;
			var x = this.h[0];
			this.h = this.h[1];
			return x;
		}};
	}
	,remove: function(v) {
		var prev = null;
		var l = this.h;
		while(l != null) {
			if(l[0] == v) {
				if(prev == null) this.h = l[1]; else prev[1] = l[1];
				if(this.q == l) this.q = prev;
				this.length--;
				return true;
			}
			prev = l;
			l = l[1];
		}
		return false;
	}
	,clear: function() {
		this.h = null;
		this.q = null;
		this.length = 0;
	}
	,isEmpty: function() {
		return this.h == null;
	}
	,pop: function() {
		if(this.h == null) return null;
		var x = this.h[0];
		this.h = this.h[1];
		if(this.h == null) this.q = null;
		this.length--;
		return x;
	}
	,last: function() {
		return this.q == null?null:this.q[0];
	}
	,first: function() {
		return this.h == null?null:this.h[0];
	}
	,push: function(item) {
		var x = [item,this.h];
		this.h = x;
		if(this.q == null) this.q = x;
		this.length++;
	}
	,add: function(item) {
		var x = [item];
		if(this.h == null) this.h = x; else this.q[1] = x;
		this.q = x;
		this.length++;
	}
	,__class__: List
}
var NodeMain = function() {
	this.devAdapter = new DevToolAdapter();
	this.devAdapter.setRequestHandler($bind(this,this.onDevToolRequest));
	this.StartXDebugServer();
	this.debuggerContext = new Hash();
};
NodeMain.__name__ = true;
NodeMain.main = function() {
	new NodeMain();
}
NodeMain.prototype = {
	evaluateOnCallFrame: function(txid,params) {
		var _g = this;
		var RemoteObject = { };
		RemoteObject.type = "undefined";
		this.xdebugAdapter.sendRequest("property_get",{ n : params.expression},function(result) {
			console.log(result);
			if(result.response.error != null) RemoteObject.description = result.response.error._; else {
				var returnArray = result.response.property;
				if(returnArray.length == 1) {
					var phpProperty = returnArray[0].$;
					var phpValue = returnArray[0]._;
					console.log(phpProperty);
					RemoteObject.type = phpProperty.type;
					if(RemoteObject.type == "object" || RemoteObject.type == "array") {
						_g.debuggerContext.set(phpProperty.address,returnArray);
						RemoteObject.className = phpProperty.classname;
						RemoteObject.objectId = phpProperty.address;
						RemoteObject.subtype = "array";
						RemoteObject.description = returnArray;
					} else RemoteObject.description = phpProperty.encoding == "base64"?Base64.decode(phpValue):phpValue;
					if(params.returnByValue) RemoteObject.value = phpProperty.encoding == "base64"?Base64.decode(phpValue):phpValue;
				}
			}
			_g.devAdapter.sendAsyncResponse(txid,{ result : RemoteObject});
		});
	}
	,getScriptSource: function(params) {
		if(this.debuggerContext.exists(params.scriptId)) return { scriptSource : this.debuggerContext.get(params.scriptId).toString()}; else return { };
	}
	,onXDebugInit: function(xdebugInit) {
		if(this.devAdapter.isConnected()) {
			console.log("New Debugging Session:" + Std.string(xdebugInit));
			this.xdebugAdapter.sendRequest("feature_set",{ n : "show_hidden", v : 1});
			this.xdebugAdapter.sendRequest("feature_set",{ n : "max_depth", v : 3});
			this.xdebugAdapter.sendRequest("feature_set",{ n : "max_children", v : 30});
			this.xdebugAdapter.sendRequest("feature_get",{ n : "max_data"});
			this.updateParsedScripts(xdebugInit.fileuri);
			this.xdebugAdapter.sendRequest("step_into",null);
		} else {
			this.xdebugAdapter.sendRequest("run",null);
			this.xdebugAdapter.sendRequest("run",null);
		}
	}
	,onXDebugStatus: function(command,status,reason,data) {
		console.log("onXDebugStatus");
		switch(status) {
		case "break":
			var breakInfo = data['xdebug:message'][0].$;
			console.log(breakInfo);
			var scriptID = this.updateParsedScripts(breakInfo.filename);
			var frameID = scriptID + ":" + Math.ceil(Math.random() * 1000);
			this.devAdapter.sendNotification("Debugger.paused",{ callFrames : [{ callFrameId : frameID, functionName : "", location : { columnNumber : 0, lineNumber : Std.parseInt(breakInfo.lineno) - 1, scriptId : scriptID}, scopeChain : [], 'this' : null}], reason : "other"});
			break;
		case "stopping":
			console.log("Terminted");
			js.Node.process.exit(0);
			break;
		}
	}
	,updateParsedScripts: function(fileuri) {
		var md5 = js.Node.crypto.createHash("MD5");
		var uri = js.Node.url.parse(fileuri);
		var ScriptID = js.Node.path.basename(uri.pathname);
		if(this.debuggerContext.exists(ScriptID)) return ScriptID;
		var fileData = js.Node.fs.readFileSync(js.Node.queryString.unescape(uri.pathname));
		this.debuggerContext.set(ScriptID,fileData);
		console.log(fileData);
		var lines = fileData.toString().split("\n");
		lines.pop();
		var endLine = lines.length;
		var endColumn = lines.pop().length + 1;
		this.devAdapter.sendNotification("Debugger.scriptParsed",{ scriptId : ScriptID, url : fileuri, startLine : 0, startColumn : 0, endLine : endLine, endColumn : endColumn});
		return ScriptID;
	}
	,onXDebugNotification: function(method,params) {
		switch(method) {
		case "init":
			this.onXDebugInit(params.init.$);
			break;
		case "response":
			if(params.response.$.status != null) {
				var command = params.response.$.command;
				var status = params.response.$.status;
				var reason = params.response.$.reason;
				delete params.response.$;
				this.onXDebugStatus(command,status,reason,params.response);
			}
			break;
		}
	}
	,setBreakpointByURL: function(txid,params) {
		var _g = this;
		var breakPoint = { };
		if(params.lineNumber != "" && params.condition == "") breakPoint.t = "line";
		breakPoint.s = "enabled";
		breakPoint.f = params.url;
		breakPoint.n = params.lineNumber + 1;
		this.xdebugAdapter.sendRequest("breakpoint_set",breakPoint,function(result) {
			var response = result.response.$;
			_g.devAdapter.sendAsyncResponse(txid,{ breakpointId : response.id, locations : [{ columnNumber : 0, lineNumber : params.lineNumber, scriptId : _g.updateParsedScripts(params.url)}]});
		});
	}
	,removeBreakpoint: function(params) {
		this.xdebugAdapter.sendRequest("breakpoint_remove",{ d : params.breakpointId});
		return { };
	}
	,onDevToolRequest: function(txid,method,params,callBack) {
		switch(method) {
		case "Debugger.getScriptSource":
			callBack(this.getScriptSource(params));
			break;
		case "Console.enable":
			callBack(true);
			break;
		case "Debugger.enable":
			callBack(true);
			break;
		case "Debugger.canSetScriptSource":
			callBack(true);
			break;
		case "Debugger.stepOver":
			this.xdebugAdapter.sendRequest("step_over",null);
			callBack({ });
			break;
		case "Debugger.stepInto":
			this.xdebugAdapter.sendRequest("step_into",null);
			callBack({ });
			break;
		case "Debugger.resume":
			this.xdebugAdapter.sendRequest("run",null);
			callBack({ });
			break;
		case "Debugger.evaluateOnCallFrame":
			this.evaluateOnCallFrame(txid,params);
			break;
		case "Debugger.setBreakpointByUrl":
			this.setBreakpointByURL(txid,params);
			break;
		case "Debugger.removeBreakpoint":
			callBack(this.removeBreakpoint(params));
			break;
		case "Debugger.pause":
			this.xdebugAdapter.sendRequest("break",null);
			callBack({ });
			break;
		default:
			callBack({ });
		}
	}
	,StartXDebugServer: function() {
		var _g = this;
		var net = js.Node.require("net");
		this.server = net.createServer(function(c) {
			console.log("Server Session Connected");
			if(_g.xdebugAdapter != null) _g.xdebugAdapter = null;
			_g.xdebugAdapter = new XDebugAdapter(c);
			_g.xdebugAdapter.setNotificationHandler($bind(_g,_g.onXDebugNotification));
			c.on("end",function() {
				console.log("Server Disconnected");
				_g.xdebugAdapter = null;
			});
		});
		this.server.listen(9000,null,function() {
			console.log("Server Started");
		});
	}
	,__class__: NodeMain
}
var Reflect = function() { }
Reflect.__name__ = true;
Reflect.hasField = function(o,field) {
	return Object.prototype.hasOwnProperty.call(o,field);
}
Reflect.field = function(o,field) {
	var v = null;
	try {
		v = o[field];
	} catch( e ) {
	}
	return v;
}
Reflect.setField = function(o,field,value) {
	o[field] = value;
}
Reflect.getProperty = function(o,field) {
	var tmp;
	return o == null?null:o.__properties__ && (tmp = o.__properties__["get_" + field])?o[tmp]():o[field];
}
Reflect.setProperty = function(o,field,value) {
	var tmp;
	if(o.__properties__ && (tmp = o.__properties__["set_" + field])) o[tmp](value); else o[field] = value;
}
Reflect.callMethod = function(o,func,args) {
	return func.apply(o,args);
}
Reflect.fields = function(o) {
	var a = [];
	if(o != null) {
		var hasOwnProperty = Object.prototype.hasOwnProperty;
		for( var f in o ) {
		if(hasOwnProperty.call(o,f)) a.push(f);
		}
	}
	return a;
}
Reflect.isFunction = function(f) {
	return typeof(f) == "function" && !(f.__name__ || f.__ename__);
}
Reflect.compare = function(a,b) {
	return a == b?0:a > b?1:-1;
}
Reflect.compareMethods = function(f1,f2) {
	if(f1 == f2) return true;
	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) return false;
	return f1.scope == f2.scope && f1.method == f2.method && f1.method != null;
}
Reflect.isObject = function(v) {
	if(v == null) return false;
	var t = typeof(v);
	return t == "string" || t == "object" && !v.__enum__ || t == "function" && (v.__name__ || v.__ename__);
}
Reflect.deleteField = function(o,f) {
	if(!Reflect.hasField(o,f)) return false;
	delete(o[f]);
	return true;
}
Reflect.copy = function(o) {
	var o2 = { };
	var _g = 0, _g1 = Reflect.fields(o);
	while(_g < _g1.length) {
		var f = _g1[_g];
		++_g;
		o2[f] = Reflect.field(o,f);
	}
	return o2;
}
Reflect.makeVarArgs = function(f) {
	return function() {
		var a = Array.prototype.slice.call(arguments);
		return f(a);
	};
}
var Std = function() { }
Std.__name__ = true;
Std["is"] = function(v,t) {
	return js.Boot.__instanceof(v,t);
}
Std.string = function(s) {
	return js.Boot.__string_rec(s,"");
}
Std["int"] = function(x) {
	return x | 0;
}
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;
}
Std.parseFloat = function(x) {
	return parseFloat(x);
}
Std.random = function(x) {
	return Math.floor(Math.random() * x);
}
var StringBuf = function() {
	this.b = "";
};
StringBuf.__name__ = true;
StringBuf.prototype = {
	toString: function() {
		return this.b;
	}
	,addSub: function(s,pos,len) {
		this.b += HxOverrides.substr(s,pos,len);
	}
	,addChar: function(c) {
		this.b += String.fromCharCode(c);
	}
	,add: function(x) {
		this.b += Std.string(x);
	}
	,__class__: StringBuf
}
var StringTools = function() { }
StringTools.__name__ = true;
StringTools.urlEncode = function(s) {
	return encodeURIComponent(s);
}
StringTools.urlDecode = function(s) {
	return decodeURIComponent(s.split("+").join(" "));
}
StringTools.htmlEscape = function(s) {
	return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
}
StringTools.htmlUnescape = function(s) {
	return s.split("&gt;").join(">").split("&lt;").join("<").split("&amp;").join("&");
}
StringTools.startsWith = function(s,start) {
	return s.length >= start.length && HxOverrides.substr(s,0,start.length) == start;
}
StringTools.endsWith = function(s,end) {
	var elen = end.length;
	var slen = s.length;
	return slen >= elen && HxOverrides.substr(s,slen - elen,elen) == end;
}
StringTools.isSpace = function(s,pos) {
	var c = HxOverrides.cca(s,pos);
	return c >= 9 && c <= 13 || c == 32;
}
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.rpad = function(s,c,l) {
	var sl = s.length;
	var cl = c.length;
	while(sl < l) if(l - sl < cl) {
		s += HxOverrides.substr(c,0,l - sl);
		sl = l;
	} else {
		s += c;
		sl += cl;
	}
	return s;
}
StringTools.lpad = function(s,c,l) {
	var ns = "";
	var sl = s.length;
	if(sl >= l) return s;
	var cl = c.length;
	while(sl < l) if(l - sl < cl) {
		ns += HxOverrides.substr(c,0,l - sl);
		sl = l;
	} else {
		ns += c;
		sl += cl;
	}
	return ns + s;
}
StringTools.replace = function(s,sub,by) {
	return s.split(sub).join(by);
}
StringTools.hex = function(n,digits) {
	var s = "";
	var hexChars = "0123456789ABCDEF";
	do {
		s = hexChars.charAt(n & 15) + s;
		n >>>= 4;
	} while(n > 0);
	if(digits != null) while(s.length < digits) s = "0" + s;
	return s;
}
StringTools.fastCodeAt = function(s,index) {
	return s.charCodeAt(index);
}
StringTools.isEOF = function(c) {
	return c != c;
}
var XDebugAdapter = function(xdebugSocket) {
	var _g = this;
	this.xmlParser = js.Node.require("xml2js").parseString;
	this.eventid = 1;
	this.eventCallbacks = new Hash();
	this.buffer = new haxe.io.BytesBuffer();
	this.xdebugSocket = xdebugSocket;
	this.xdebugSocket.on("end",function() {
		_g.log("Server Disconnected");
	});
	this.xdebugSocket.on("data",function(buffer) {
		_g.log("Data Received <-- " + Std.string(buffer));
		_g.parseXdebugResponse(buffer);
	});
	this.xdebugSocket.on("error",function(error) {
		_g.log("Error Received: " + error);
	});
};
XDebugAdapter.__name__ = true;
XDebugAdapter.__interfaces__ = [ClientAdapter];
XDebugAdapter.prototype = {
	setNotificationHandler: function(handler) {
		this.notificationHandler = handler;
	}
	,sendRequest: function(method,params,responseCallback) {
		this.sendXdebugRequest(method,params,null,responseCallback);
	}
	,handleXDebugResponse: function(err,message) {
		if(err) {
			this.log("Response Error:" + Std.string(err));
			return;
		}
		if(message == null) return;
		this.log("Message Parsed:" + Std.string(message));
		var method = "";
		var _g = 0, _g1 = Reflect.fields(message);
		while(_g < _g1.length) {
			var fname = _g1[_g];
			++_g;
			method = fname;
			break;
		}
		this.log("Method Requested:" + method);
		if(Reflect.hasField(message,"response")) {
			var txid = message.response.$.transaction_id;
			if(this.eventCallbacks.exists("request_" + txid)) {
				(this.eventCallbacks.get("request_" + txid))(message);
				return;
			}
		}
		this.notificationHandler(method,message);
	}
	,parseXdebugResponse: function(buffer) {
		this.buffer.add(haxe.io.Bytes.ofString(buffer.toString("utf8")));
		var packetData = this.buffer.getBytes();
		var startPos = 0;
		var $char;
		var buflenStr;
		do {
			buflenStr = "";
			while(startPos < packetData.length && ($char = packetData.b[startPos++]) != 0) buflenStr += String.fromCharCode($char);
			var buflenInt = Std.parseInt(buflenStr);
			if(buflenInt > packetData.length - startPos) break;
			var xmlpayload = packetData.readString(startPos,buflenInt);
			this.xmlParser(xmlpayload,{ trim : true},$bind(this,this.handleXDebugResponse));
			startPos += buflenInt;
		} while(startPos < packetData.length);
		this.buffer = new haxe.io.BytesBuffer();
		this.buffer.add(packetData.sub(startPos,packetData.length - startPos));
	}
	,sendXdebugRequest: function(command,args,data,callBack) {
		var packet = new haxe.io.BytesBuffer();
		var _cmdarg = "";
		var _g = 0, _g1 = Reflect.fields(args);
		while(_g < _g1.length) {
			var i = _g1[_g];
			++_g;
			_cmdarg += " -" + i + " " + Std.string(Reflect.field(args,i));
		}
		packet.add(haxe.io.Bytes.ofString(command + " -i " + this.eventid));
		if(_cmdarg != null) packet.add(haxe.io.Bytes.ofString(_cmdarg));
		if(data != null) packet.add(data);
		packet.b.push(0);
		if(null != callBack && Reflect.isFunction(callBack)) this.eventCallbacks.set("request_" + this.eventid,callBack);
		this.log("Sending --> " + Std.string(packet));
		if(this.xdebugSocket == null) return;
		this.xdebugSocket.write(packet.getBytes().b);
		this.eventid++;
	}
	,log: function(msg) {
		console.log(Std.string(new Date()) + " [XDEBUG] " + msg);
	}
	,__class__: XDebugAdapter
}
var haxe = {}
haxe.BaseCode = function(base) {
	var len = base.length;
	var nbits = 1;
	while(len > 1 << nbits) nbits++;
	if(nbits > 8 || len != 1 << nbits) throw "BaseCode : base length must be a power of two.";
	this.base = base;
	this.nbits = nbits;
};
haxe.BaseCode.__name__ = true;
haxe.BaseCode.encode = function(s,base) {
	var b = new haxe.BaseCode(haxe.io.Bytes.ofString(base));
	return b.encodeString(s);
}
haxe.BaseCode.decode = function(s,base) {
	var b = new haxe.BaseCode(haxe.io.Bytes.ofString(base));
	return b.decodeString(s);
}
haxe.BaseCode.prototype = {
	decodeString: function(s) {
		return this.decodeBytes(haxe.io.Bytes.ofString(s)).toString();
	}
	,encodeString: function(s) {
		return this.encodeBytes(haxe.io.Bytes.ofString(s)).toString();
	}
	,decodeBytes: function(b) {
		var nbits = this.nbits;
		var base = this.base;
		if(this.tbl == null) this.initTable();
		var tbl = this.tbl;
		var size = b.length * nbits >> 3;
		var out = haxe.io.Bytes.alloc(size);
		var buf = 0;
		var curbits = 0;
		var pin = 0;
		var pout = 0;
		while(pout < size) {
			while(curbits < 8) {
				curbits += nbits;
				buf <<= nbits;
				var i = tbl[b.b[pin++]];
				if(i == -1) throw "BaseCode : invalid encoded char";
				buf |= i;
			}
			curbits -= 8;
			out.b[pout++] = buf >> curbits & 255;
		}
		return out;
	}
	,initTable: function() {
		var tbl = new Array();
		var _g = 0;
		while(_g < 256) {
			var i = _g++;
			tbl[i] = -1;
		}
		var _g1 = 0, _g = this.base.length;
		while(_g1 < _g) {
			var i = _g1++;
			tbl[this.base.b[i]] = i;
		}
		this.tbl = tbl;
	}
	,encodeBytes: function(b) {
		var nbits = this.nbits;
		var base = this.base;
		var size = b.length * 8 / nbits | 0;
		var out = haxe.io.Bytes.alloc(size + (b.length * 8 % nbits == 0?0:1));
		var buf = 0;
		var curbits = 0;
		var mask = (1 << nbits) - 1;
		var pin = 0;
		var pout = 0;
		while(pout < size) {
			while(curbits < nbits) {
				curbits += 8;
				buf <<= 8;
				buf |= b.b[pin++];
			}
			curbits -= nbits;
			out.b[pout++] = base.b[buf >> curbits & mask];
		}
		if(curbits > 0) out.b[pout++] = base.b[buf << nbits - curbits & mask];
		return out;
	}
	,__class__: haxe.BaseCode
}
haxe.io = {}
haxe.io.Bytes = function(length,b) {
	this.length = length;
	this.b = b;
};
haxe.io.Bytes.__name__ = true;
haxe.io.Bytes.alloc = function(length) {
	return new haxe.io.Bytes(length,new Buffer(length));
}
haxe.io.Bytes.ofString = function(s) {
	var nb = new Buffer(s,"utf8");
	return new haxe.io.Bytes(nb.length,nb);
}
haxe.io.Bytes.ofData = function(b) {
	return new haxe.io.Bytes(b.length,b);
}
haxe.io.Bytes.prototype = {
	getData: function() {
		return this.b;
	}
	,toString: function() {
		return this.readString(0,this.length);
	}
	,readString: function(pos,len) {
		if(pos < 0 || len < 0 || pos + len > this.length) throw haxe.io.Error.OutsideBounds;
		var s = "";
		var b = this.b;
		var fcc = String.fromCharCode;
		var i = pos;
		var max = pos + len;
		while(i < max) {
			var c = b[i++];
			if(c < 128) {
				if(c == 0) break;
				s += fcc(c);
			} else if(c < 224) s += fcc((c & 63) << 6 | b[i++] & 127); else if(c < 240) {
				var c2 = b[i++];
				s += fcc((c & 31) << 12 | (c2 & 127) << 6 | b[i++] & 127);
			} else {
				var c2 = b[i++];
				var c3 = b[i++];
				s += fcc((c & 15) << 18 | (c2 & 127) << 12 | c3 << 6 & 127 | b[i++] & 127);
			}
		}
		return s;
	}
	,compare: function(other) {
		var b1 = this.b;
		var b2 = other.b;
		var len = this.length < other.length?this.length:other.length;
		var _g = 0;
		while(_g < len) {
			var i = _g++;
			if(b1[i] != b2[i]) return b1[i] - b2[i];
		}
		return this.length - other.length;
	}
	,sub: function(pos,len) {
		if(pos < 0 || len < 0 || pos + len > this.length) throw haxe.io.Error.OutsideBounds;
		var nb = new Buffer(len), slice = this.b.slice(pos,pos + len);
		slice.copy(nb,0,0,len);
		return new haxe.io.Bytes(len,nb);
	}
	,blit: function(pos,src,srcpos,len) {
		if(pos < 0 || srcpos < 0 || len < 0 || pos + len > this.length || srcpos + len > src.length) throw haxe.io.Error.OutsideBounds;
		src.b.copy(this.b,pos,srcpos,srcpos + len);
	}
	,set: function(pos,v) {
		this.b[pos] = v;
	}
	,get: function(pos) {
		return this.b[pos];
	}
	,__class__: haxe.io.Bytes
}
haxe.io.BytesBuffer = function() {
	this.b = new Array();
};
haxe.io.BytesBuffer.__name__ = true;
haxe.io.BytesBuffer.prototype = {
	getBytes: function() {
		var nb = new Buffer(this.b);
		var bytes = new haxe.io.Bytes(nb.length,nb);
		this.b = null;
		return bytes;
	}
	,addBytes: function(src,pos,len) {
		if(pos < 0 || len < 0 || pos + len > src.length) throw haxe.io.Error.OutsideBounds;
		var b1 = this.b;
		var b2 = src.b;
		var _g1 = pos, _g = pos + len;
		while(_g1 < _g) {
			var i = _g1++;
			this.b.push(b2[i]);
		}
	}
	,add: function(src) {
		var b1 = this.b;
		var b2 = src.b;
		var _g1 = 0, _g = src.length;
		while(_g1 < _g) {
			var i = _g1++;
			this.b.push(b2[i]);
		}
	}
	,addByte: function($byte) {
		this.b.push($byte);
	}
	,__class__: haxe.io.BytesBuffer
}
haxe.io.Error = { __ename__ : true, __constructs__ : ["Blocked","Overflow","OutsideBounds","Custom"] }
haxe.io.Error.Blocked = ["Blocked",0];
haxe.io.Error.Blocked.toString = $estr;
haxe.io.Error.Blocked.__enum__ = haxe.io.Error;
haxe.io.Error.Overflow = ["Overflow",1];
haxe.io.Error.Overflow.toString = $estr;
haxe.io.Error.Overflow.__enum__ = haxe.io.Error;
haxe.io.Error.OutsideBounds = ["OutsideBounds",2];
haxe.io.Error.OutsideBounds.toString = $estr;
haxe.io.Error.OutsideBounds.__enum__ = haxe.io.Error;
haxe.io.Error.Custom = function(e) { var $x = ["Custom",3,e]; $x.__enum__ = haxe.io.Error; $x.toString = $estr; return $x; }
var js = {}
js.Boot = function() { }
js.Boot.__name__ = true;
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,"");
	var d;
	if(typeof(document) != "undefined" && (d = document.getElementById("haxe:trace")) != null) d.innerHTML += js.Boot.__unhtml(msg) + "<br/>"; else if(typeof(console) != "undefined" && console.log != null) console.log(msg);
}
js.Boot.__clear_trace = function() {
	var d = document.getElementById("haxe:trace");
	if(d != null) d.innerHTML = "";
}
js.Boot.isClass = function(o) {
	return o.__name__;
}
js.Boot.isEnum = function(e) {
	return e.__ename__;
}
js.Boot.getClass = function(o) {
	return o.__class__;
}
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 "object":
		if(o instanceof Array) {
			if(o.__enum__) {
				if(o.length == 2) return o[0];
				var str = o[0] + "(";
				s += "\t";
				var _g1 = 2, _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 i;
			var str = "[";
			s += "\t";
			var _g = 0;
			while(_g < l) {
				var i1 = _g++;
				str += (i1 > 0?",":"") + js.Boot.__string_rec(o[i1],s);
			}
			str += "]";
			return str;
		}
		var tostr;
		try {
			tostr = o.toString;
		} catch( e ) {
			return "???";
		}
		if(tostr != null && tostr != Object.toString) {
			var s2 = o.toString();
			if(s2 != "[object Object]") return s2;
		}
		var k = null;
		var str = "{\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(str.length != 2) str += ", \n";
		str += s + k + " : " + js.Boot.__string_rec(o[k],s);
		}
		s = s.substring(1);
		str += "\n" + s + "}";
		return str;
	case "function":
		return "<function>";
	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, _g = intf.length;
		while(_g1 < _g) {
			var i = _g1++;
			var i1 = intf[i];
			if(i1 == cl || js.Boot.__interfLoop(i1,cl)) return true;
		}
	}
	return js.Boot.__interfLoop(cc.__super__,cl);
}
js.Boot.__instanceof = function(o,cl) {
	try {
		if(o instanceof cl) {
			if(cl == Array) return o.__enum__ == null;
			return true;
		}
		if(js.Boot.__interfLoop(o.__class__,cl)) return true;
	} catch( e ) {
		if(cl == null) return false;
	}
	switch(cl) {
	case Int:
		return Math.ceil(o%2147483648.0) === o;
	case Float:
		return typeof(o) == "number";
	case Bool:
		return o === true || o === false;
	case String:
		return typeof(o) == "string";
	case Dynamic:
		return true;
	default:
		if(o == null) return false;
		if(cl == Class && o.__name__ != null) return true; else null;
		if(cl == Enum && o.__ename__ != null) return true; else null;
		return o.__enum__ == cl;
	}
}
js.Boot.__cast = function(o,t) {
	if(js.Boot.__instanceof(o,t)) return o; else throw "Cannot cast " + Std.string(o) + " to " + Std.string(t);
}
js.Lib = function() { }
js.Lib.__name__ = true;
js.Lib.debug = function() {
	debugger;
}
js.Lib.alert = function(v) {
	alert(js.Boot.__string_rec(v,""));
}
js.Lib["eval"] = function(code) {
	return eval(code);
}
js.Lib.setErrorHandler = function(f) {
	js.Lib.onerror = f;
}
js.NodeC = function() { }
js.NodeC.__name__ = true;
js.Node = function() { }
js.Node.__name__ = true;
js.Node.newSocket = function(options) {
	return new js.Node.net.Socket(options);
}
js.node = {}
js.node.ConnectStatic = function() { }
js.node.ConnectStatic.__name__ = true;
js.node.ConnectStatic.Static = function(c,path,options) {
	return c.static(path, options);
}
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 $_;
function $bind(o,m) { var f = function(){ return f.method.apply(f.scope, arguments); }; f.scope = o; f.method = m; return f; };
if(Array.prototype.indexOf) HxOverrides.remove = function(a,o) {
	var i = a.indexOf(o);
	if(i == -1) return false;
	a.splice(i,1);
	return true;
}; else null;
Math.__name__ = ["Math"];
Math.NaN = Number.NaN;
Math.NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
Math.POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
Math.isFinite = function(i) {
	return isFinite(i);
};
Math.isNaN = function(i) {
	return isNaN(i);
};
String.prototype.__class__ = String;
String.__name__ = true;
Array.prototype.__class__ = Array;
Array.__name__ = true;
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 Void = { __ename__ : ["Void"]};
if(typeof document != "undefined") js.Lib.document = document;
if(typeof window != "undefined") {
	js.Lib.window = window;
	js.Lib.window.onerror = function(msg,url,line) {
		var f = js.Lib.onerror;
		if(f == null) return false;
		return f(msg,[url + ":" + line]);
	};
}
js.Node.__filename = __filename;
js.Node.__dirname = __dirname;
js.Node.setTimeout = setTimeout;
js.Node.clearTimeout = clearTimeout;
js.Node.setInterval = setInterval;
js.Node.clearInterval = clearInterval;
js.Node.global = global;
js.Node.process = process;
js.Node.require = require;
js.Node.console = console;
js.Node.module = module;
js.Node.stringify = JSON.stringify;
js.Node.parse = JSON.parse;
js.Node.util = js.Node.require("util");
js.Node.fs = js.Node.require("fs");
js.Node.net = js.Node.require("net");
js.Node.http = js.Node.require("http");
js.Node.https = js.Node.require("https");
js.Node.path = js.Node.require("path");
js.Node.url = js.Node.require("url");
js.Node.os = js.Node.require("os");
js.Node.crypto = js.Node.require("crypto");
js.Node.dns = js.Node.require("dns");
js.Node.queryString = js.Node.require("querystring");
js.Node.assert = js.Node.require("assert");
js.Node.childProcess = js.Node.require("child_process");
js.Node.vm = js.Node.require("vm");
js.Node.tls = js.Node.require("tls");
js.Node.dgram = js.Node.require("dgram");
js.Node.assert = js.Node.require("assert");
js.Node.repl = js.Node.require("repl");
js.Node.cluster = js.Node.require("cluster");
Base64.chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
js.NodeC.UTF8 = "utf8";
js.NodeC.ASCII = "ascii";
js.NodeC.BINARY = "binary";
js.NodeC.BASE64 = "base64";
js.NodeC.HEX = "hex";
js.NodeC.EVENT_EVENTEMITTER_NEWLISTENER = "newListener";
js.NodeC.EVENT_EVENTEMITTER_ERROR = "error";
js.NodeC.EVENT_STREAM_DATA = "data";
js.NodeC.EVENT_STREAM_END = "end";
js.NodeC.EVENT_STREAM_ERROR = "error";
js.NodeC.EVENT_STREAM_CLOSE = "close";
js.NodeC.EVENT_STREAM_DRAIN = "drain";
js.NodeC.EVENT_STREAM_CONNECT = "connect";
js.NodeC.EVENT_STREAM_SECURE = "secure";
js.NodeC.EVENT_STREAM_TIMEOUT = "timeout";
js.NodeC.EVENT_STREAM_PIPE = "pipe";
js.NodeC.EVENT_PROCESS_EXIT = "exit";
js.NodeC.EVENT_PROCESS_UNCAUGHTEXCEPTION = "uncaughtException";
js.NodeC.EVENT_PROCESS_SIGINT = "SIGINT";
js.NodeC.EVENT_PROCESS_SIGUSR1 = "SIGUSR1";
js.NodeC.EVENT_CHILDPROCESS_EXIT = "exit";
js.NodeC.EVENT_HTTPSERVER_REQUEST = "request";
js.NodeC.EVENT_HTTPSERVER_CONNECTION = "connection";
js.NodeC.EVENT_HTTPSERVER_CLOSE = "close";
js.NodeC.EVENT_HTTPSERVER_UPGRADE = "upgrade";
js.NodeC.EVENT_HTTPSERVER_CLIENTERROR = "clientError";
js.NodeC.EVENT_HTTPSERVERREQUEST_DATA = "data";
js.NodeC.EVENT_HTTPSERVERREQUEST_END = "end";
js.NodeC.EVENT_CLIENTREQUEST_RESPONSE = "response";
js.NodeC.EVENT_CLIENTRESPONSE_DATA = "data";
js.NodeC.EVENT_CLIENTRESPONSE_END = "end";
js.NodeC.EVENT_NETSERVER_CONNECTION = "connection";
js.NodeC.EVENT_NETSERVER_CLOSE = "close";
js.NodeC.FILE_READ = "r";
js.NodeC.FILE_READ_APPEND = "r+";
js.NodeC.FILE_WRITE = "w";
js.NodeC.FILE_WRITE_APPEND = "a+";
js.NodeC.FILE_READWRITE = "a";
js.NodeC.FILE_READWRITE_APPEND = "a+";
NodeMain.main();
})();

//@ sourceMappingURL=NodeMain.js.map