// Generated by Haxe 3.4.2 (git build master @ 890f8c7)
if (process.version < "v4.0.0") console.warn("Module " + (typeof(module) == "undefined" ? "" : module.filename) + " requires node.js version 4.0.0 or higher");
(function() {

// From: https://github.com/sokra/source-map-visualization

// app.less
var CSS = `
* {
	font-family: Monaco,Menlo,Consolas,Courier New,monospace;
	font-size: 12px;
}
span.original-item {
	border-left: 1px solid black;
	margin: 1px;
	min-width: 3px;
}
span.generated-item {
	margin: 1px;
}
span.selected {
	background: black;
	color: white;
}
.style-0 {
	background: #FFFF66;
}
.style-1 {
	background: #FFFFFF;
}
.style-2 {
	background: #FFBBBB;
}
.style-3 {
	background: #AAFFFF;
}
.style-4 {
	background: #FFAAFF;
}

pre {
	overflow-x: auto;
}

pre code {
	white-space: pre-wrap;
	word-break: normal;
	word-wrap: normal;
}

table {
	width: 100%;
}

tr, td {
	vertical-align: top;
	margin: 0;
	width: 33%;
}`;

// app.js, after HTML generation
var SCRIPT = `
	$("body").delegate(".original-item, .generated-item, .mapping-item", "mouseenter", function() {
		$(".selected").removeClass("selected");
		var mappedItems = $(this).data('mapped');
		if (!mappedItems){
			var source = $(this).data("source");
			var line = $(this).data("line");
			var column = $(this).data("column");
			mappedItems = $(".item-" + source + "-" + line + "-" + column);
			var twinItem = mappedItems.not('.mapping-item').not(this);
			$(this).data('mapped', mappedItems)
			$(this).data('twin', twinItem)
		}
		$(mappedItems).addClass("selected");
	}).delegate(".original-item, .generated-item, .mapping-item", "click", function() {
		var twinItem = $(this).data('twin');
		var elem = $(twinItem).get(0)
		if (elem && elem.scrollIntoViewIfNeeded)
			elem.scrollIntoViewIfNeeded();
	});
`;


// generateHtml.js
var SourceMap = require("source-map");
var LINESTYLES = 5;
var MAX_LINES = 5000;

function formatSource(source) {
	return source.replace(/</g, "&lt;").split('/').pop();
}

global.generateHtml = function(map, generatedCode, sources) {
	var generatedSide = [];
	var originalSide = [];
	var mappingsSide = [];

	function addTo(side, line, html) {
		side[line] = (side[line] || "") + html;
	}

	function span(text, options) {
		var attrs = {};
		if(options) {
			if(options.generated) {
				attrs["class"] = "generated-item";
			} else if(options.mapping) {
				attrs["class"] = "mapping-item";
			} else {
				attrs["class"] = "original-item";
			}
			if(typeof options.source !== "undefined") {
				attrs["class"] += " item-" + options.source + "-" + options.line + "-" + options.column;
			}
			attrs["class"] += " style-" + (options.line%LINESTYLES);
			if (options.name) attrs["title"] = options.name;
			attrs["data-source"] = options.source;
			attrs["data-line"] = options.line;
			attrs["data-column"] = options.column;
		}
		return "<span " + Object.keys(attrs).filter(function(key) {
			return typeof attrs[key] !== "undefined";
		}).map(function(key) {
			return key + "=\"" + attrs[key] + "\"";
		}).join(" ") + ">" + (text + "").replace(/</g, "&lt;") + "</span>";
	}

	var mapSources = map.sources;

	var generatedLine = 1;
	var nodes = SourceMap.SourceNode.fromStringWithSourceMap(generatedCode, map).children;
	nodes.forEach(function(item, idx) {
		if(generatedLine > MAX_LINES) return;
		if(typeof item === "string") {
			item.split("\n").forEach(function(line) {
				addTo(generatedSide, generatedLine, line);
				generatedLine++;
			});
			generatedLine--;
		} else {
			var str = item.toString();
			var source = mapSources.indexOf(item.source);
			str.split("\n").forEach(function(line) {
				addTo(generatedSide, generatedLine, span(line, {
					generated: true,
					source: source,
					line: item.line,
					column: item.column,
					name: item.name
				}));
				generatedLine++
			});
			generatedLine--;
		}
	});


	var lastGenLine = 1;
	var lastOrgSource = "";
	var mappingsLine = 1;
	map.eachMapping(function(mapping) {
		if(mapping.generatedLine > MAX_LINES) return;
		while(lastGenLine < mapping.generatedLine) {
			mappingsLine++;
			lastGenLine++;
			addTo(mappingsSide, mappingsLine, lastGenLine + ": ");
		}
		if(typeof mapping.originalLine == "number") {
			if(lastOrgSource !== mapping.source && mapSources.length > 1) {
				addTo(mappingsSide, mappingsLine, "<b>[" + formatSource(mapping.source) + "]</b> ");
				lastOrgSource = mapping.source;
			}
			var source = mapSources.indexOf(mapping.source);
			addTo(mappingsSide, mappingsLine, span(mapping.generatedColumn + "->" + mapping.originalLine + ":" + mapping.originalColumn, {
				mapping: true,
				source: source,
				line: mapping.originalLine,
				column: mapping.originalColumn
			}));
		} else {
			addTo(mappingsSide, mappingsLine, span(mapping.generatedColumn, {
				mapping: true
			}));
		}
		addTo(mappingsSide, mappingsLine, "  ");
	});


	var originalLine = 1;
	var line = 1, column = 0, currentOutputLine = 1, targetOutputLine = -1, limited = false;
	var lastMapping = null;
	var currentSource = null;
	var exampleLines;
	var mappingsBySource = {};
	map.eachMapping(function(mapping) {
		if(typeof mapping.originalLine !== "number") return;
		if(mapping.generatedLine > MAX_LINES) return limited = true;
		if(!mappingsBySource[mapping.source]) mappingsBySource[mapping.source] = [];
		mappingsBySource[mapping.source].push(mapping);
	}, undefined, SourceMap.SourceMapConsumer.ORIGINAL_ORDER);
	Object.keys(mappingsBySource).map(function(source) {
		return [source, mappingsBySource[source][0].generatedLine];
	}).sort(function(a, b) {
		if(a[0] === "?") return 1;
		if(b[0] === "?") return -1;
		return a[1] - b[1];
	}).forEach(function(arr) {
		var source = arr[0];
		var mappings = mappingsBySource[source];

		if(currentSource) endFile();
		lastMapping = null;
		line = 1;
		column = 0;
		targetOutputLine = -1;
		if(mapSources.length > 1) {
			currentOutputLine++;
		}
		var startLine = mappings.map(function(mapping) {
			return mapping.generatedLine - mapping.originalLine + 1;
		}).sort(function(a, b) { return a - b });
		startLine = startLine[0];
		while(currentOutputLine < startLine) {
			originalLine++;
			currentOutputLine++;
		}
		if(mapSources.length > 1) {
			addTo(originalSide, originalLine, "<h4>[" + formatSource(source) + "]</h4>");
			originalLine++;
		}
		var exampleSource = sources[mapSources.indexOf(source)];
		if(!exampleSource) throw new Error("Source '" + source + "' missing");
		exampleLines = exampleSource.split("\n");
		currentSource = source;
		mappings.forEach(function(mapping, idx) {
			if(lastMapping) {
				var source = mapSources.indexOf(lastMapping.source);
				if(line < mapping.originalLine) {
					addTo(originalSide, originalLine, span(exampleLines.shift(), {
						original: true,
						source: source,
						line: lastMapping.originalLine,
						column: lastMapping.originalColumn
					}));
					originalLine++;
					line++; column = 0;
					currentOutputLine++;
					while(line < mapping.originalLine) {
						addTo(originalSide, originalLine, exampleLines.shift());
						originalLine++;
						line++; column = 0;
						currentOutputLine++;
					}
					startLine = [];
					for(var i = idx; i < mappings.length && mappings[i].originalLine <= mapping.originalLine + 1; i++) {
						startLine.push(mappings[i].generatedLine - mappings[i].originalLine + mapping.originalLine);
					}
					startLine.sort(function(a, b) { return a - b });
					startLine = startLine[0];
					while(typeof startLine !== "undefined" && currentOutputLine < startLine) {
						addTo(originalSide, originalLine, "~");
						originalLine++;
						currentOutputLine++;
					}
					if(column < mapping.originalColumn) {
						addTo(originalSide, originalLine, shiftColumns(mapping.originalColumn - column));
					}
				}
				if(mapping.originalColumn > column) {
					addTo(originalSide, originalLine, span(shiftColumns(mapping.originalColumn - column), {
						original: true,
						source: source,
						line: lastMapping.originalLine,
						column: lastMapping.originalColumn
					}));
				}
			} else {
				while(line < mapping.originalLine) {
					addTo(originalSide, originalLine, exampleLines.shift());
					originalLine++;
					line++; column = 0;
				}
				if(column < mapping.originalColumn) {
					addTo(originalSide, originalLine, shiftColumns(mapping.originalColumn - column));
				}
			}
			lastMapping = mapping;
		});
	});
	function endFile() {
		if(lastMapping) {
			var source = mapSources.indexOf(lastMapping.source);
			addTo(originalSide, originalLine, span(exampleLines.shift(), {
				original: true,
				source: source,
				line: lastMapping.originalLine,
				column: lastMapping.originalColumn
			}));
		}
		if(!limited) {
			exampleLines.forEach(function(line) {
				originalLine++;
				currentOutputLine++;
				addTo(originalSide, originalLine, line);
			});
		}
	}
	endFile();

	function shiftColumns(count) {
		var nextLine = exampleLines[0];
		exampleLines[0] = nextLine.substr(count);
		column += count;
		return nextLine.substr(0, count);
	}

	var length = Math.max(originalSide.length, generatedSide.length, mappingsSide.length);

	var tableRows = [];

	for(var i = 0; i < length; i++) {
		tableRows[i] = [
			originalSide[i] || "",
			generatedSide[i] || "",
			mappingsSide[i] || ""
		].map(function(cell) {
			return "<td>" + cell + "</td>";
		}).join("");
	}

	return "<!DOCTYPE html>\n<html>\n<style>" + CSS + "</style>\n<table><tbody>\n" + tableRows.map(function(row) {
		return "<tr>" + row + "</tr>\n";
	}).join("") + "</tbody></table>\n"
	+ '<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"/></script><script>' + SCRIPT + "</script></html>";


}

})();

(function ($hx_exports) { "use strict";
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 Bundler = function(parser,sourceMap,extractor) {
	this.parser = parser;
	this.sourceMap = sourceMap;
	this.extractor = extractor;
};
Bundler.prototype = {
	generate: function(src,output,webpackMode,debugSourceMap) {
		this.webpackMode = webpackMode;
		this.debugSourceMap = debugSourceMap;
		console.log("Emit " + output);
		var result = [];
		var buffer = this.emitBundle(src,this.extractor.main,true);
		result.push({ name : "Main", map : this.writeMap(output,buffer), source : this.write(output,buffer.src), debugMap : buffer.debugMap});
		var _g = 0;
		var _g1 = this.extractor.bundles;
		while(_g < _g1.length) {
			var bundle = _g1[_g];
			++_g;
			var bundleOutput = js_node_Path.join(js_node_Path.dirname(output),bundle.name + ".js");
			console.log("Emit " + bundleOutput);
			buffer = this.emitBundle(src,bundle,false);
			result.push({ name : bundle.name, map : this.writeMap(bundleOutput,buffer), source : this.write(bundleOutput,buffer.src), debugMap : buffer.debugMap});
		}
		return result;
	}
	,writeMap: function(output,buffer) {
		if(buffer.map == null) {
			return null;
		}
		return { path : "" + output + ".map", content : this.sourceMap.emitFile(output,buffer.map).toString()};
	}
	,write: function(output,buffer) {
		if(buffer == null) {
			return null;
		}
		return { path : output, content : buffer};
	}
	,hasChanged: function(output,buffer) {
		if(!js_node_Fs.statSync(output).isFile()) {
			return true;
		}
		var original = js_node_Fs.readFileSync(output).toString();
		return original != buffer;
	}
	,emitBundle: function(src,bundle,isMain) {
		var output = this.emitJS(src,bundle,isMain);
		var map = this.sourceMap.emitMappings(output.mapNodes,output.mapOffset);
		var debugMap = this.debugSourceMap ? this.emitDebugMap(output.buffer,bundle,map) : null;
		return { src : output.buffer, map : map, debugMap : debugMap};
	}
	,emitDebugMap: function(src,bundle,map) {
		var rawMap = JSON.parse(map.toString());
		var consumer = new sourcemap_SourceMapConsumer(rawMap);
		var _g = [];
		var _g1 = 0;
		var _g2 = rawMap.sources;
		while(_g1 < _g2.length) {
			var source = _g2[_g1];
			++_g1;
			var fileName = source.split("file:///").pop();
			_g.push(js_node_Fs.readFileSync(fileName).toString());
		}
		var sources = _g;
		return Bundler.generateHtml(consumer,src,sources);
	}
	,emitJS: function(src,bundle,isMain) {
		var mapOffset = 0;
		var exports = bundle.exports;
		var buffer = "";
		var body = this.parser.rootBody.slice();
		body.shift();
		if(isMain) {
			buffer += this.getBeforeBodySrc(src);
			mapOffset += this.getBeforeBodyOffset();
		} else {
			++mapOffset;
		}
		var run = isMain ? body.pop() : null;
		var inc = bundle.nodes;
		var incAll = isMain && bundle.nodes.length == 0;
		var mapNodes = [];
		var frag = isMain || bundle.isLib ? Bundler.FRAGMENTS.MAIN : Bundler.FRAGMENTS.CHILD;
		if(this.webpackMode) {
			buffer += "/* eslint-disable */ \"use strict\"\n";
			++mapOffset;
			buffer += frag.EXPORTS;
			++mapOffset;
			buffer += frag.SHARED;
			++mapOffset;
		} else {
			buffer += "(function ($hx_exports, $global) { \"use-strict\";\n";
			++mapOffset;
			buffer += frag.SHARED;
			++mapOffset;
			buffer += "var require = (function(r){ return function require(m) { return r[m]; } })($s.__registry__);\n";
			++mapOffset;
		}
		if(bundle.shared.length > 0) {
			var tmp;
			if(isMain) {
				tmp = bundle.shared;
			} else {
				var _g = [];
				var _g1 = 0;
				var _g2 = bundle.shared;
				while(_g1 < _g2.length) {
					var node = _g2[_g1];
					++_g1;
					_g.push("" + node + " = $" + "s." + node);
				}
				tmp = _g;
			}
			buffer += "var " + tmp.join(", ") + ";\n";
			++mapOffset;
		}
		var _g3 = 0;
		while(_g3 < body.length) {
			var node1 = body[_g3];
			++_g3;
			if(!incAll && node1.__tag__ != null && inc.indexOf(node1.__tag__) < 0) {
				if(!isMain || node1.__tag__ != "__reserved__") {
					continue;
				}
			}
			mapNodes.push(node1);
			buffer += HxOverrides.substr(src,node1.start,node1.end - node1.start);
			buffer += "\n";
		}
		buffer += this.emitHot(inc);
		if(exports.length > 0) {
			var _g4 = 0;
			while(_g4 < exports.length) {
				var node2 = exports[_g4];
				++_g4;
				buffer += "$" + "s." + node2 + " = " + node2 + "; ";
			}
			buffer += "\n";
		}
		if(run != null) {
			buffer += HxOverrides.substr(src,run.start,run.end - run.start);
			buffer += "\n";
		}
		if(!this.webpackMode) {
			buffer += "})(" + "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" + ");\n";
		}
		return { buffer : buffer, mapNodes : mapNodes, mapOffset : mapOffset};
	}
	,getBeforeBodyOffset: function() {
		return this.parser.rootExpr.loc.start.line;
	}
	,getBeforeBodySrc: function(src) {
		return HxOverrides.substr(src,0,this.parser.rootExpr.start);
	}
	,emitHot: function(inc) {
		var names = [];
		var _g = 0;
		var _g1 = Reflect.fields(this.parser.isHot);
		while(_g < _g1.length) {
			var name = _g1[_g];
			++_g;
			if(this.parser.isHot[name] && inc.indexOf(name) >= 0) {
				names.push(name);
			}
		}
		if(names.length == 0) {
			return "";
		}
		return "if ($" + "global.__REACT_HOT_LOADER__)\n" + ("  [" + names.join(",") + "].map(function(c) {\n") + "    __REACT_HOT_LOADER__.register(c,c.displayName,c.__fileName__);\n" + "  });\n";
	}
};
var EReg = function(r,opt) {
	this.r = new RegExp(r,opt.split("u").join(""));
};
EReg.prototype = {
	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;
	}
};
var Extractor = function(parser) {
	this.bundles = [];
	this.parser = parser;
};
Extractor.prototype = {
	process: function(mainModule,modules,debugMode) {
		if(this.parser.typesCount == 0) {
			console.log("Warning: unable to process (no type metadata)");
			this.main = { isLib : false, name : "Main", nodes : [], exports : [], shared : []};
			return;
		}
		console.log("Bundling...");
		var g = this.parser.graph;
		var _g = 0;
		while(_g < modules.length) {
			var $module = modules[_g];
			++_g;
			this.unlink(g,$module);
		}
		var mainNodes = graphlib_Alg.preorder(g,mainModule);
		if(debugMode) {
			var _g1 = 0;
			var _g11 = Reflect.fields(this.parser.isEnum);
			while(_g1 < _g11.length) {
				var key = _g11[_g1];
				++_g1;
				mainNodes.push(key);
			}
		}
		this.bundles = modules.map($bind(this,this.processModule));
		var dupes = this.deduplicate(this.bundles,mainNodes,debugMode);
		mainNodes = this.addOnce(mainNodes,dupes.removed);
		var mainExports = dupes.shared;
		var mainShared = this.bundles.filter(function(bundle) {
			return !bundle.isLib;
		}).map(function(bundle1) {
			return bundle1.name;
		});
		var _g2 = 0;
		var _g12 = this.bundles;
		while(_g2 < _g12.length) {
			var bundle2 = _g12[_g2];
			++_g2;
			if(bundle2.isLib) {
				mainNodes = this.remove(bundle2.nodes,mainNodes);
				mainExports = this.remove(bundle2.nodes,mainExports);
				bundle2.exports = bundle2.nodes.slice();
			}
		}
		this.main = { isLib : false, name : "Main", nodes : mainNodes, exports : mainExports, shared : mainShared};
	}
	,processModule: function(name) {
		var g = this.parser.graph;
		if(name.indexOf("=") > 0) {
			var parts = name.split("=");
			var test = new EReg("^" + parts[1].split(",").join("|"),"");
			var ret = { isLib : true, name : parts[0], nodes : g.nodes().filter(function(n) {
				return test.match(n);
			}), exports : [], shared : []};
			return ret;
		} else {
			return { isLib : false, name : name, nodes : graphlib_Alg.preorder(g,name), exports : [name], shared : []};
		}
	}
	,deduplicate: function(bundles,mainNodes,debugMode) {
		console.log("Extract common chunks..." + (debugMode ? " (fast)" : ""));
		var map = new haxe_ds_StringMap();
		var _g = 0;
		while(_g < mainNodes.length) {
			var node = mainNodes[_g];
			++_g;
			if(__map_reserved[node] != null) {
				map.setReserved(node,true);
			} else {
				map.h[node] = true;
			}
		}
		var dupes = [];
		var _g1 = 0;
		while(_g1 < bundles.length) {
			var bundle = bundles[_g1];
			++_g1;
			var _g11 = 0;
			var _g2 = bundle.nodes;
			while(_g11 < _g2.length) {
				var node1 = _g2[_g11];
				++_g11;
				if(__map_reserved[node1] != null ? map.existsReserved(node1) : map.h.hasOwnProperty(node1)) {
					if(dupes.indexOf(node1) < 0) {
						dupes.push(node1);
					}
				} else if(bundle.isLib || !debugMode) {
					if(__map_reserved[node1] != null) {
						map.setReserved(node1,true);
					} else {
						map.h[node1] = true;
					}
				}
			}
		}
		var shared = [];
		var g = this.parser.graph;
		var _g3 = 0;
		while(_g3 < dupes.length) {
			var node2 = dupes[_g3];
			++_g3;
			var pre = g.predecessors(node2).filter(function(preNode) {
				return dupes.indexOf(preNode) < 0;
			});
			if(pre.length > 0) {
				shared.push(node2);
			}
		}
		var _g4 = 0;
		while(_g4 < bundles.length) {
			var bundle1 = [bundles[_g4]];
			++_g4;
			if(!bundle1[0].isLib) {
				var bundle2 = bundle1[0].nodes;
				var tmp = (function(bundle3) {
					return function(node3) {
						if(dupes.indexOf(node3) < 0) {
							return true;
						}
						if(shared.indexOf(node3) >= 0) {
							bundle3[0].shared.push(node3);
						}
						return false;
					};
				})(bundle1);
				bundle1[0].nodes = bundle2.filter(tmp);
			}
		}
		console.log("Moved " + dupes.length + " common chunks (" + shared.length + " shared)");
		return { removed : dupes, shared : shared};
	}
	,remove: function(source,target) {
		return source.filter(function(node) {
			return target.indexOf(node) < 0;
		});
	}
	,addOnce: function(source,target) {
		var temp = target.slice();
		var _g = 0;
		while(_g < source.length) {
			var node = source[_g];
			++_g;
			if(target.indexOf(node) < 0) {
				temp.push(node);
			}
		}
		return temp;
	}
	,unlink: function(g,name) {
		if(name.indexOf("=") > 0) {
			return;
		}
		var pred = g.predecessors(name);
		if(pred == null) {
			console.log("Cannot unlink " + name);
			return;
		}
		var _g = 0;
		while(_g < pred.length) {
			var p = pred[_g];
			++_g;
			g.removeEdge(p,name);
		}
	}
};
var HxOverrides = function() { };
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);
};
var Main = function() { };
Main.run = $hx_exports["run"] = function(input,output,modules,debugMode,webpackMode,debugSourceMap,dump) {
	var src = js_node_Fs.readFileSync(input).toString();
	var parser = new Parser(src);
	var sourceMap = new SourceMap(input,src);
	if(dump) {
		Main.dumpGraph(output,parser);
	}
	var extractor = new Extractor(parser);
	extractor.process(parser.mainModule,modules,debugMode);
	var bundler = new Bundler(parser,sourceMap,extractor);
	var dir = js_node_Path.dirname(output);
	if(!js_node_Fs.statSync(dir).isDirectory()) {
		js_node_Fs.mkdirSync(dir);
	}
	return bundler.generate(src,output,webpackMode,debugSourceMap);
};
Main.dumpGraph = function(output,parser) {
	var g = parser.graph;
	console.log("Dump graph: " + output + ".graph");
	var out = "";
	var _g = 0;
	var _g1 = g.nodes();
	while(_g < _g1.length) {
		var node = _g1[_g];
		++_g;
		if(node.charAt(0) != "$") {
			var toNode = g.inEdges(node).map(function(n) {
				return n.v.split("_").join(".");
			}).filter(function(l) {
				return l.charAt(0) != "$";
			});
			if(toNode.length == 0) {
				continue;
			}
			out += "+ " + node + " < " + toNode.join(", ") + "\n";
			var fromNode = g.outEdges(node).map(function(n1) {
				return n1.w.split("_").join(".");
			}).filter(function(l1) {
				return l1.charAt(0) != "$";
			});
			var _g2 = 0;
			while(_g2 < fromNode.length) {
				var dest = fromNode[_g2];
				++_g2;
				out += "  - " + dest + "\n";
			}
		}
	}
	js_node_Fs.writeFileSync(output + ".graph",out);
};
var Parser = function(src) {
	this.reservedTypes = { "String" : true, "Math" : true, "Array" : true, "Int" : true, "Float" : true, "Bool" : true, "Class" : true, "Date" : true, "Dynamic" : true, "Enum" : true, __map_reserved : true};
	this.mainModule = "Main";
	var t0 = new Date().getTime();
	this.processInput(src);
	var t1 = new Date().getTime();
	console.log("Parsed in: " + (t1 - t0) + "ms");
	this.buildGraph();
	var t2 = new Date().getTime();
	console.log("Graph processed in: " + (t2 - t1) + "ms");
};
Parser.prototype = {
	processInput: function(src) {
		var program = acorn_Acorn.parse(src,{ ecmaVersion : 5, locations : true, ranges : true});
		this.walkProgram(program);
	}
	,buildGraph: function() {
		var g = new graphlib_Graph({ directed : true, compound : true});
		var cpt = 0;
		var refs = 0;
		var _g = 0;
		var _g1 = Reflect.fields(this.types);
		while(_g < _g1.length) {
			var t = _g1[_g];
			++_g;
			++cpt;
			g.setNode(t,t);
		}
		var _g2 = 0;
		var _g11 = Reflect.fields(this.types);
		while(_g2 < _g11.length) {
			var t1 = _g11[_g2];
			++_g2;
			refs += this.walk(g,t1,this.types[t1]);
		}
		console.log("Stats: " + cpt + " types, " + refs + " references");
		this.typesCount = cpt;
		this.graph = g;
	}
	,walk: function(g,id,nodes) {
		var _gthis = this;
		var refs = 0;
		var visitors = { Identifier : function(node) {
			var name = node.name;
			if(name != id && Object.prototype.hasOwnProperty.call(_gthis.types,name)) {
				g.setEdge(id,name);
				refs += 1;
			}
		}};
		var _g = 0;
		while(_g < nodes.length) {
			var decl = nodes[_g];
			++_g;
			acorn_Walk.simple(decl,visitors);
		}
		return refs;
	}
	,walkProgram: function(program) {
		this.types = { };
		this.isHot = { };
		this.isEnum = { };
		this.isRequire = { };
		var body = this.getBodyNodes(program);
		this.rootExpr = body.pop();
		var _g = this.rootExpr.type;
		if(_g == "ExpressionStatement") {
			this.walkRootExpression(this.rootExpr.expression);
		} else {
			throw new js__$Boot_HaxeError("Expecting last node to be an ExpressionStatement");
		}
	}
	,walkRootExpression: function(expr) {
		var _g = expr.type;
		if(_g == "CallExpression") {
			this.walkRootFunction(expr.callee);
		} else {
			throw new js__$Boot_HaxeError("Expecting last node statement to be a function call");
		}
	}
	,walkRootFunction: function(callee) {
		var block = this.getBodyNodes(callee)[0];
		var _g = block.type;
		if(_g == "BlockStatement") {
			var body = this.getBodyNodes(block);
			this.walkDeclarations(body);
		} else {
			throw new js__$Boot_HaxeError("Expecting block of statements inside root function");
		}
	}
	,walkDeclarations: function(body) {
		this.rootBody = body;
		var _g = 0;
		while(_g < body.length) {
			var node = body[_g];
			++_g;
			var _g1 = node.type;
			switch(_g1) {
			case "ExpressionStatement":
				this.inspectExpression(node.expression,node);
				break;
			case "FunctionDeclaration":
				this.inspectFunction(node.id,node);
				break;
			case "IfStatement":
				if(node.consequent.type == "ExpressionStatement") {
					this.inspectExpression(node.consequent.expression,node);
				} else {
					this.inspectIfStatement(node.test,node);
				}
				break;
			case "VariableDeclaration":
				this.inspectDeclarations(node.declarations,node);
				break;
			default:
				console.log("WARNING: Unexpected " + node.type + ", Line " + node.loc.start.line);
			}
		}
	}
	,inspectIfStatement: function(test,def) {
		if(test.type == "BinaryExpression") {
			var path = this.getIdentifier(test.left);
			if(path.length > 1 && path[1] == "prototype") {
				this.tag(path[0],def);
			}
		}
	}
	,inspectFunction: function(id,def) {
		var path = this.getIdentifier(id);
		if(path.length > 0) {
			var name = path[0];
			if(name == "$extend" || name == "$bind" || name == "$iterator") {
				this.tag(name,def);
			}
		}
	}
	,inspectExpression: function(expression,def) {
		var _g = expression.type;
		switch(_g) {
		case "AssignmentExpression":
			var path = this.getIdentifier(expression.left);
			if(path.length > 0) {
				var name = path[0];
				switch(name) {
				case "$hxClasses":
					var moduleName = this.getIdentifier(expression.right);
					if(moduleName.length == 1) {
						this.tag(moduleName[0],def);
					}
					break;
				case "$hx_exports":
					break;
				default:
					if(Object.prototype.hasOwnProperty.call(this.types,name)) {
						if(path[1] == "displayName") {
							this.trySetHot(name);
						} else if(path[1] == "__fileName__") {
							this.trySetHot(name);
						}
					}
					this.tag(name,def);
				}
			}
			break;
		case "CallExpression":
			var path1 = this.getIdentifier(expression.callee.object);
			var prop = this.getIdentifier(expression.callee.property);
			if(prop.length > 0 && path1.length > 0 && Object.prototype.hasOwnProperty.call(this.types,path1[0])) {
				var name1 = path1[0];
				if(prop.length == 1 && prop[0] == "main") {
					this.mainModule = name1;
				}
				this.tag(name1,def);
			}
			break;
		default:
		}
	}
	,trySetHot: function(name) {
		if(Object.prototype.hasOwnProperty.call(this.isHot,name)) {
			this.isHot[name] = true;
		} else {
			this.isHot[name] = false;
		}
	}
	,inspectDeclarations: function(declarations,def) {
		var _g = 0;
		while(_g < declarations.length) {
			var decl = declarations[_g];
			++_g;
			if(decl.id != null) {
				var name = decl.id.name;
				if(decl.init != null) {
					var init = decl.init;
					var _g1 = init.type;
					switch(_g1) {
					case "AssignmentExpression":
						var right = init.right;
						if(right.type == "FunctionExpression") {
							this.tag(name,def);
						} else if(right.type == "ObjectExpression") {
							if(this.isEnumDecl(right)) {
								this.isEnum[name] = true;
							}
							this.tag(name,def);
						}
						break;
					case "CallExpression":
						if(this.isRequireDecl(init.callee)) {
							this.required(name,def);
						}
						break;
					case "FunctionExpression":
						this.tag(name,def);
						break;
					case "Identifier":
						if(name.charAt(0) != "$") {
							this.tag(name,def);
						}
						break;
					case "LogicalExpression":
						if(name.indexOf("Array") >= 0) {
							this.tag(name,def);
						}
						break;
					case "MemberExpression":
						if(init.object.type == "CallExpression" && this.isRequireDecl(init.object.callee)) {
							this.required(name,def);
						}
						break;
					case "ObjectExpression":
						if(this.isEnumDecl(init)) {
							this.isEnum[name] = true;
						}
						this.tag(name,def);
						break;
					default:
					}
				}
			}
		}
	}
	,required: function(name,def) {
		this.isRequire[name] = true;
		this.tag(name,def);
	}
	,tag: function(name,def) {
		if(!Object.prototype.hasOwnProperty.call(this.types,name)) {
			if(this.reservedTypes[name]) {
				if(name != "__map_reserved") {
					def.__tag__ = "__reserved__";
				}
				return;
			}
			this.types[name] = [def];
		} else {
			this.types[name].push(def);
		}
		def.__tag__ = name;
	}
	,isReserved: function(name) {
		return this.reservedTypes[name];
	}
	,isEnumDecl: function(node) {
		var props = node.properties;
		if(node.type == "ObjectExpression" && props != null && props.length > 0) {
			return this.getIdentifier(props[0].key)[0] == "__ename__";
		} else {
			return false;
		}
	}
	,isRequireDecl: function(node) {
		if(node != null && node.type == "Identifier") {
			return node.name == "require";
		} else {
			return false;
		}
	}
	,getBodyNodes: function(node) {
		if((node.body instanceof Array) && node.body.__enum__ == null) {
			return node.body;
		} else {
			return [node.body];
		}
	}
	,getIdentifier: function(left) {
		var _g = left.type;
		switch(_g) {
		case "Identifier":
			return [left.name];
		case "Literal":
			return [left.raw];
		case "MemberExpression":
			return this.getIdentifier(left.object).concat(this.getIdentifier(left.property));
		default:
			return [];
		}
	}
};
var Reflect = function() { };
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;
};
var SourceMap = function(input,src) {
	var p = src.lastIndexOf("//# sourceMappingURL=");
	if(p < 0) {
		return;
	}
	this.fileName = StringTools.trim(HxOverrides.substr(src,p + "//# sourceMappingURL=".length,null));
	this.fileName = js_node_Path.join(js_node_Path.dirname(input),this.fileName);
	var raw = JSON.parse(js_node_Fs.readFileSync(this.fileName).toString());
	this.source = new sourcemap_SourceMapConsumer(raw);
};
SourceMap.prototype = {
	emitMappings: function(nodes,offset) {
		if(nodes.length == 0 || this.source == null) {
			return null;
		}
		var inc = [];
		var line = offset;
		var _g = 0;
		while(_g < nodes.length) {
			var node = nodes[_g];
			++_g;
			var _g2 = node.loc.start.line;
			var _g1 = node.loc.end.line + 1;
			while(_g2 < _g1) {
				var i = _g2++;
				inc[i] = line++;
			}
		}
		var output = new sourcemap_SourceMapGenerator();
		var sourceFiles = { };
		try {
			this.source.eachMapping(function(mapping) {
				if(!isNaN(inc[mapping.generatedLine])) {
					sourceFiles[mapping.source] = true;
					var mapLine = inc[mapping.generatedLine];
					var column = mapping.originalColumn >= 0 ? mapping.originalColumn : 0;
					output.addMapping({ source : mapping.source, original : { line : mapping.originalLine, column : column}, generated : { line : mapLine, column : mapping.generatedColumn}});
				}
			});
			var _g3 = 0;
			var _g11 = Reflect.fields(sourceFiles);
			while(_g3 < _g11.length) {
				var sourceName = _g11[_g3];
				++_g3;
				var src = this.source.sourceContentFor(sourceName,true);
				if(src != null) {
					output.setSourceContent(sourceName,src);
				}
			}
			return output;
		} catch( err ) {
			console.log("Invalid source-map");
		}
		return output;
	}
	,emitFile: function(output,map) {
		if(map == null) {
			return null;
		}
		map.file = js_node_Path.basename(output);
		return map;
	}
};
var StringTools = function() { };
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));
};
var acorn_Acorn = require("acorn");
var acorn_Walk = require("acorn/dist/walk");
var graphlib_Graph = require("graphlib").Graph;
var graphlib_Alg = require("graphlib/lib/alg");
var haxe_IMap = function() { };
var haxe_ds_StringMap = function() {
	this.h = { };
};
haxe_ds_StringMap.__interfaces__ = [haxe_IMap];
haxe_ds_StringMap.prototype = {
	setReserved: function(key,value) {
		if(this.rh == null) {
			this.rh = { };
		}
		this.rh["$" + key] = value;
	}
	,existsReserved: function(key) {
		if(this.rh == null) {
			return false;
		}
		return this.rh.hasOwnProperty("$" + key);
	}
};
var haxe_io_Bytes = function() { };
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.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,{
});
var js_node_Fs = require("fs");
var js_node_Path = require("path");
var js_node_buffer_Buffer = require("buffer").Buffer;
var sourcemap_SourceMapConsumer = require("source-map").SourceMapConsumer;
var sourcemap_SourceMapGenerator = require("source-map").SourceMapGenerator;
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; }
var __map_reserved = {}
Bundler.REQUIRE = "var require = (function(r){ return function require(m) { return r[m]; } })($s.__registry__);\n";
Bundler.SCOPE = "typeof exports != \"undefined\" ? exports : typeof window != \"undefined\" ? window : typeof self != \"undefined\" ? self : this";
Bundler.GLOBAL = "typeof window != \"undefined\" ? window : typeof global != \"undefined\" ? global : typeof self != \"undefined\" ? self : this";
Bundler.FUNCTION_START = "(function ($hx_exports, $global) { \"use-strict\";\n";
Bundler.FUNCTION_END = "})(" + "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" + ");\n";
Bundler.WP_START = "/* eslint-disable */ \"use strict\"\n";
Bundler.FRAGMENTS = { MAIN : { EXPORTS : "var $hx_exports = exports, $global = global;\n", SHARED : "var $s = $global.$hx_scope = $global.$hx_scope || {};\n"}, CHILD : { EXPORTS : "var $hx_exports = exports, $global = global;\n", SHARED : "var $s = $global.$hx_scope;\n"}};
Bundler.generateHtml = global.generateHtml;
SourceMap.SRC_REF = "//# sourceMappingURL=";
})(typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this);