diff --git a/cgi.d b/cgi.d
deleted file mode 120000
index 283c969..0000000
--- a/cgi.d
+++ /dev/null
@@ -1 +0,0 @@
-../../djs/proxy/cgi.d
\ No newline at end of file
diff --git a/cgi.d b/cgi.d
new file mode 100644
index 0000000..b1289f2
--- /dev/null
+++ b/cgi.d
@@ -0,0 +1,1106 @@
+module arsd.cgi;
+
+// FIXME: would be cool to flush part of a dom document before complete
+// somehow in here and dom.d.
+
+
+// FIXME: 100 Continue in the nph section? Probably belongs on the
+// httpd class though.
+
+public import std.string;
+import std.uri;
+import std.exception;
+import std.base64;
+//import std.algorithm;
+public import std.stdio;
+static import std.date;
+public import std.conv;
+import std.range;
+
+import std.process;
+
+T[] consume(T)(T[] range, int count) {
+	if(count > range.length)
+		count = range.length;
+	return range[count..$];
+}
+
+int locationOf(T)(T[] data, string item) {
+	const(ubyte[]) d = cast(const(ubyte[])) data;
+	const(ubyte[]) i = cast(const(ubyte[])) item;
+
+	for(int a = 0; a < d.length; a++) {
+		if(a + i.length > d.length)
+			return -1;
+		if(d[a..a+i.length] == i)
+			return a;
+	}
+
+	return -1;
+}
+
+/+
+/// If you pass -1 to Cgi.this() as maxContentLength, it
+/// lets you use one of these instead of buffering the data
+/// itself.
+
+/// The benefit is you can handle data of any size without needing
+/// a buffering solution. The downside is this is one-way and the order
+/// of elements might not be what you want. If you need buffering, you've
+/// gotta do it yourself.
+struct CgiVariableStream {
+	bool empty() {
+		return true;
+	}
+
+	void popFront() {
+
+	}
+
+	/// If you want to do an upload progress bar, these functions
+	/// might help.
+	int bytesReceived() {
+
+	}
+
+	/// ditto
+	/// But, note this won't necessarily be known, so it may return zero!
+	int bytesExpected() {
+
+	}
+
+
+	/// The stream returns these Elements.
+	struct Element {
+		enum Type { String, File }
+
+		/// Since the last popFront, is this a new element or a
+		/// continuation of the last?
+		bool isNew;
+
+		/// Is this the last piece of this element?
+		/// Note that sometimes isComplete will only be true with an empty
+		/// payload, since it can't be sure until it actually receives the terminator.
+		/// This, unless you are buffering parts, you can't depend on it.
+		bool isComplete;
+
+		/// Metainfo from the part header is preserved
+		string name;
+		string fileName;
+		string contentType;
+
+		ubyte[] content;
+	}
+}
++/
+/// The main interface with the web request
+class Cgi {
+  public:
+	enum RequestMethod { GET, HEAD, POST, PUT, DELETE, // GET and POST are the ones that really work
+		// these are defined in the standard, but idk if they are useful for anything
+		OPTIONS, TRACE, CONNECT,
+		// this is an extension for when the method is not specified and you want to assume
+		CommandLine }
+
+	/** Initializes it using the CGI interface */
+	this(int maxContentLength = 5_000_000,
+		// use this to override the environment variable functions
+		string delegate(string env) getenv = null,
+		// and this should return a chunk of data. return empty when done
+		const(ubyte)[] delegate() readdata = null,
+		// finally, use this to do custom output if needed
+		void delegate(const(ubyte)[]) _rawDataOutput = null
+		)
+	{
+		rawDataOutput = _rawDataOutput;
+		if(getenv is null)
+			getenv = delegate string(string env) { return .getenv(env); };
+
+		// FIXME: this is wrong on IIS!
+		requestUri = getenv("REQUEST_URI");
+		cookie = getenv("HTTP_COOKIE");
+		referrer = getenv("HTTP_REFERER");
+		userAgent = getenv("HTTP_USER_AGENT");
+		queryString = getenv("QUERY_STRING");
+		remoteAddress = getenv("REMOTE_ADDR");
+		host = getenv("HTTP_HOST");
+		pathInfo = getenv("PATH_INFO");
+		scriptName = getenv("SCRIPT_NAME");
+		authorization = getenv("HTTP_AUTHORIZATION");
+		// this is a hack because Apache is a shitload of fuck and
+		// refuses to send the real header to us. Compatible
+		// programs should send both the standard and X- versions
+
+		// NOTE: if you have access to .htaccess or httpd.conf, you can make this
+		// unnecessary with mod_rewrite, so it is commented
+
+		//if(authorization.length == 0) // if the std is there, use it
+		//	authorization = getenv("HTTP_X_AUTHORIZATION");
+
+		if(getenv("SERVER_PORT").length)
+			port = to!int(getenv("SERVER_PORT"));
+		else
+			port = 0; // this was probably called from the command line
+
+		auto rm = getenv("REQUEST_METHOD");
+		if(rm.length)
+			requestMethod = to!RequestMethod(getenv("REQUEST_METHOD"));
+		else
+			requestMethod = RequestMethod.CommandLine;
+
+		https = getenv("HTTPS") == "on";
+
+		// FIXME: DOCUMENT_ROOT?
+
+		immutable(ubyte)[] data;
+		string contentType;
+
+		// FIXME: what about PUT?
+		if(requestMethod == RequestMethod.POST) {
+			contentType = getenv("CONTENT_TYPE");
+
+			// FIXME: is this ever not going to be set? I guess it depends
+			// on if the server de-chunks and buffers... seems like it has potential
+			// to be slow if they did that. The spec says it is always there though.
+			// And it has worked reliably for me all year in the live environment,
+			// but some servers might be different.
+			int contentLength = to!int(getenv("CONTENT_LENGTH"));
+			if(contentLength) {
+				if(maxContentLength > 0 && contentLength > maxContentLength) {
+					setResponseStatus("413 Request entity too large");
+					write("You tried to upload a file that is too large.");
+					close();
+					throw new Exception("POST too large");
+				}
+
+			if(readdata is null)
+			foreach(ubyte[] chunk; stdin.byChunk(4096)) { // FIXME: maybe it should pass the range directly to the parser
+				if(chunk.length > contentLength) {
+					data ~= chunk[0..contentLength];
+					contentLength = 0;
+					break;
+				} else {
+					data ~= chunk;
+					contentLength -= chunk.length;
+				}
+				if(contentLength == 0)
+					break;
+			}
+			else {
+				// we have a custom data source..
+				auto chunk = readdata();
+				while(chunk.length) {
+					// FIXME: DRY
+					if(chunk.length > contentLength) {
+						data ~= chunk[0..contentLength];
+						contentLength = 0;
+						break;
+					} else {
+						data ~= chunk;
+						contentLength -= chunk.length;
+					}
+					if(contentLength == 0)
+						break;
+
+					chunk = readdata();
+				}
+			}
+
+			}
+
+			version(preserveData)
+				originalPostData = data;
+		}
+
+		mixin(createVariableHashes());
+		// fixme: remote_user script name
+	}
+
+	/** Initializes it from some almost* raw HTTP request data
+		headers[0] should be the "GET / HTTP/1.1" line
+
+		* Note the data should /not/ be chunked at this point.
+
+		headers: each http header, excluding the \r\n at the end, but including the request line at headers[0]
+		data: the request data (usually POST variables)
+		address: the remote IP
+		_rawDataOutput: delegate to accept response data. If not null, this is called for all data output, which
+			will include HTTP headers and the status line. The data may also be chunked; it is already suitable for
+			being sent directly down the wire.
+
+			If null, the data is sent to stdout.
+
+
+
+		FIXME: data should be able to be streaming, for large files
+	*/
+	this(string[] headers, immutable(ubyte)[] data, string address, void delegate(const(ubyte)[]) _rawDataOutput = null, int pathInfoStarts = 0) {
+		auto parts = headers[0].split(" ");
+
+		https = false;
+		port = 80; // FIXME
+
+		rawDataOutput = _rawDataOutput;
+		nph = true;
+
+		requestMethod = to!RequestMethod(parts[0]);
+
+		requestUri = parts[1];
+
+		scriptName = requestUri[0 .. pathInfoStarts];
+
+		int question = requestUri.indexOf("?");
+		if(question == -1) {
+			queryString = "";
+			pathInfo = requestUri[pathInfoStarts..$];
+		} else {
+			queryString = requestUri[question+1..$];
+			pathInfo = requestUri[pathInfoStarts..question];
+		}
+
+		remoteAddress = address;
+
+		if(headers[0].indexOf("HTTP/1.0")) {
+			http10 = true;
+			autoBuffer = true;
+		}
+
+		string contentType = "";
+
+		foreach(header; headers[1..$]) {
+			int colon = header.indexOf(":");
+			if(colon == -1)
+				throw new Exception("HTTP headers should have a colon!");
+			string name = header[0..colon].toLower;
+			string value = header[colon+2..$]; // skip the colon and the space
+
+			switch(name) {
+				case "authorization":
+					authorization = value;
+				break;
+				case "content-type":
+					contentType = value;
+				break;
+				case "host":
+					host = value;
+				break;
+				case "user-agent":
+					userAgent = value;
+				break;
+				case "referer":
+					referrer = value;
+				break;
+				case "cookie":
+					cookie ~= value;
+				break;
+				default:
+					// ignore it
+			}
+		}
+
+		// Need to set up get, post, and cookies
+		mixin(createVariableHashes());
+	}
+
+	// This gets mixed in because it is shared but set inside invariant constructors
+	pure private static string createVariableHashes() {
+	return q{
+		if(queryString.length == 0)
+			get = null;//get.init;
+		else {
+			auto _get = decodeVariables(queryString);
+			getArray = assumeUnique(_get);
+
+			string[string] ga;
+
+			// Some sites are shit and don't let you handle multiple parameters.
+			// If so, compile this in and encode it as a single parameter
+			version(with_cgi_packed) {
+				auto idx = pathInfo.indexOf("PACKED");
+				if(idx != -1) {
+					auto pi = pathInfo[idx + "PACKED".length .. $];
+
+					auto _unpacked = decodeVariables(
+						cast(string) base64UrlDecode(pi));
+
+					foreach(k, v; _unpacked)
+						ga[k] = v[$-1];
+
+					pathInfo = pathInfo[0 .. idx];
+				}
+
+				if("arsd_packed_data" in getArray) {
+					auto _unpacked = decodeVariables(
+						cast(string) base64UrlDecode(getArray["arsd_packed_data"][0]));
+
+					foreach(k, v; _unpacked)
+						ga[k] = v[$-1];
+				}
+			}
+
+			foreach(k, v; getArray)
+				ga[k] = v[$-1];
+
+			get = assumeUnique(ga);
+		}
+
+		if(cookie.length == 0)
+			cookies = null;//cookies.init;
+		else {
+			auto _cookies = decodeVariables(cookie, "; ");
+			cookiesArray = assumeUnique(_cookies);
+
+			string[string] ca;
+			foreach(k, v; cookiesArray)
+				ca[k] = v[$-1];
+
+			cookies = assumeUnique(ca);
+		}
+
+		if(data.length == 0)
+			post = null;//post.init;
+		else {
+			int terminator = contentType.indexOf(";");
+			if(terminator == -1)
+				terminator = contentType.length;
+			switch(contentType[0..terminator]) {
+				default: assert(0);
+				case "multipart/form-data":
+					string[][string] _post;
+
+					UploadedFile[string] _files;
+
+					int b = contentType[terminator..$].indexOf("boundary=") + terminator;
+					assert(b >= 0, "no boundary");
+					immutable boundary = contentType[b+9..$];
+
+					int pos = 0;
+
+					// all boundaries except the first should have a \r\n before them
+					while(pos < data.length) {
+						assert(data[pos] == '-', "no leading dash");
+						pos++;
+						assert(data[pos] == '-', "no second leading dash");
+						pos++;
+						//writefln("**expected** %s\n** got**     %s", boundary, cast(string) data[pos..pos+boundary.length]);
+						assert(data[pos..pos+boundary.length] == cast(const(ubyte[])) boundary, "not lined up on boundary");
+						pos += boundary.length;
+						if(data[pos] == '\r' && data[pos+1] == '\n') {
+							pos += 2;
+						} else {
+							assert(data[pos] == '-', "improper ending #1");
+							assert(data[pos+1] == '-', "improper ending #2");
+							if(pos+2 != data.length) {
+								pos += 2;
+								assert(data[pos] == '\r', "not new line part 1");
+								assert(data[pos + 1] == '\n', "not new line part 2");
+								assert(pos + 2 == data.length, "wtf, wrong length");
+							}
+							break;
+						}
+
+						auto nextloc = locationOf(data[pos..$], boundary) + pos - 2; // the -2 is a HACK
+						assert(nextloc > 0, "empty piece");
+						assert(nextloc != -1, "no next boundary");
+						immutable thisOne = data[pos..nextloc-2]; // the 2 skips the leading \r\n of the next boundary
+
+						// thisOne has the headers and the data
+						int headerEndLocation = locationOf(thisOne, "\r\n\r\n");
+						assert(headerEndLocation >= 0, "no header");
+						auto thisOnesHeaders = thisOne[0..headerEndLocation];
+						auto thisOnesData = thisOne[headerEndLocation+4..$];
+
+						string[] pieceHeaders = split(cast(string) thisOnesHeaders, "\r\n");
+
+						UploadedFile piece;
+						bool isFile = false;
+
+						foreach(h; pieceHeaders) {
+							int p = h.indexOf(":");
+							assert(p != -1, "no colon in header");
+							string hn = h[0..p];
+							string hv = h[p+2..$];
+
+							switch(hn.toLower) {
+								default: assert(0);
+								case "content-disposition":
+									auto info = hv.split("; ");
+									foreach(i; info[1..$]) { // skipping the form-data
+										auto o = i.split("="); // FIXME
+										string pn = o[0];
+										string pv = o[1][1..$-1];
+
+										if(pn == "name") {
+											piece.name = pv;
+										} else if (pn == "filename") {
+											piece.filename = pv;
+											isFile = true;
+										}
+									}
+								break;
+								case "content-type":
+									piece.contentType = hv;
+								break;
+							}
+						}
+
+						piece.content = thisOnesData;
+
+						//writefln("Piece: [%s] (%s) %d\n***%s****", piece.name, piece.filename, piece.content.length, cast(string) piece.content);
+
+						if(isFile)
+							_files[piece.name] = piece;
+						else
+							_post[piece.name] ~= cast(string) piece.content;
+
+						pos = nextloc;
+					}
+
+					postArray = assumeUnique(_post);
+					files = assumeUnique(_files);
+				break;
+				case "application/x-www-form-urlencoded":
+					auto _post = decodeVariables(cast(string) data);
+					postArray = assumeUnique(_post);
+				break;
+			}
+			string[string] pa;
+			foreach(k, v; postArray)
+				pa[k] = v[$-1];
+
+			post = assumeUnique(pa);
+		}
+	};
+	}
+
+	struct UploadedFile {
+		string name;
+		string filename;
+		string contentType;
+		immutable(ubyte)[] content;
+	}
+
+	void requireBasicAuth(string user, string pass, string message = null) {
+		if(authorization != "Basic " ~ Base64.encode(cast(immutable(ubyte)[]) (user ~ ":" ~ pass))) {
+			setResponseStatus("401 Authorization Required");
+			header ("WWW-Authenticate: Basic realm=\""~message~"\"");
+			close();
+			throw new Exception("Not authorized");
+		}
+	}
+
+	/// Very simple caching controls - setCache(false) means it will never be cached.
+	/// setCache(true) means it will always be cached for as long as possible.
+	/// Use setResponseExpires and updateResponseExpires for more control
+	void setCache(bool allowCaching) {
+		noCache = !allowCaching;
+	}
+
+	/// This gets a full url for the current request, including port, protocol, host, path, and query
+	string getCurrentCompleteUri() const {
+		return format("http%s://%s%s%s",
+			https ? "s" : "",
+			host,
+			port == 80 ? "" : ":" ~ to!string(port),
+			requestUri);
+	}
+
+	/// Sets the HTTP status of the response. For example, "404 File Not Found" or "500 Internal Server Error".
+	/// It assumes "200 OK", and automatically changes to "302 Found" if you call setResponseLocation().
+	/// Note setResponseStatus() must be called *before* you write() any data to the output.
+	void setResponseStatus(string status) {
+		assert(!outputtedResponseData);
+		responseStatus = status;
+	}
+	private string responseStatus = null;
+
+	/// Sets the location header, which the browser will redirect the user to automatically.
+	/// Note setResponseLocation() must be called *before* you write() any data to the output.
+	/// The optional important argument is used if it's a default suggestion rather than something to insist upon.
+	void setResponseLocation(string uri, bool important = true) {
+		if(!important && isCurrentResponseLocationImportant)
+			return; // important redirects always override unimportant ones
+
+		assert(!outputtedResponseData);
+		responseStatus = "302 Found";
+		responseLocation = uri.strip;
+		isCurrentResponseLocationImportant = important;
+	}
+	private string responseLocation = null;
+	private bool isCurrentResponseLocationImportant = false;
+
+	/// Sets the Expires: http header. See also: updateResponseExpires, setPublicCaching
+	/// The parameter is in unix_timestamp * 1000. Try setResponseExpires(getUTCtime() + SOME AMOUNT) for normal use.
+	/// Note: the when parameter is different than setCookie's expire parameter.
+	void setResponseExpires(long when, bool isPublic = false) {
+		responseExpires = when;
+		setCache(true); // need to enable caching so the date has meaning
+
+		responseIsPublic = isPublic;
+	}
+	private long responseExpires = long.min;
+	private bool responseIsPublic = false;
+
+	/// This is like setResponseExpires, but it can be called multiple times. The setting most in the past is the one kept.
+	/// If you have multiple functions, they all might call updateResponseExpires about their own return value. The program
+	/// output as a whole is as cacheable as the least cachable part in the chain.
+
+	/// setCache(false) always overrides this - it is, by definition, the strictest anti-cache statement available.
+	/// Conversely, setting here overrides setCache(true), since any expiration date is in the past of infinity.
+	void updateResponseExpires(long when, bool isPublic) {
+		if(responseExpires == long.min)
+			setResponseExpires(when, isPublic);
+		else if(when < responseExpires)
+			setResponseExpires(when, responseIsPublic && isPublic); // if any part of it is private, it all is
+	}
+
+	/*
+	/// Set to true if you want the result to be cached publically - that is, is the content shared?
+	/// Should generally be false if the user is logged in. It assumes private cache only.
+	/// setCache(true) also turns on public caching, and setCache(false) sets to private.
+	void setPublicCaching(bool allowPublicCaches) {
+		publicCaching = allowPublicCaches;
+	}
+	private bool publicCaching = false;
+	*/
+
+	/// Sets an HTTP cookie, automatically encoding the data to the correct string.
+	/// expiresIn is how many milliseconds in the future the cookie will expire.
+	/// TIP: to make a cookie accessible from subdomains, set the domain to .yourdomain.com.
+	/// Note setCookie() must be called *before* you write() any data to the output.
+	void setCookie(string name, string data, long expiresIn = 0, string path = null, string domain = null, bool httpOnly = false) {
+		assert(!outputtedResponseData);
+		string cookie = name ~ "=";
+		cookie ~= data;
+		if(path !is null)
+			cookie ~= "; path=" ~ path;
+		if(expiresIn != 0)
+			cookie ~= "; expires=" ~ printDate(expiresIn + std.date.getUTCtime());
+		if(domain !is null)
+			cookie ~= "; domain=" ~ domain;
+		if(httpOnly == true )
+			cookie ~= "; HttpOnly";
+
+		responseCookies ~= cookie;
+	}
+	private string[] responseCookies;
+
+	/// Clears a previously set cookie with the given name, path, and domain.
+	void clearCookie(string name, string path = null, string domain = null) {
+		assert(!outputtedResponseData);
+		setCookie(name, "", 1, path, domain);
+	}
+
+	/// Sets the content type of the response, for example "text/html" (the default) for HTML, or "image/png" for a PNG image
+	void setResponseContentType(string ct) {
+		assert(!outputtedResponseData);
+		responseContentType = ct;
+	}
+	private string responseContentType = null;
+
+	/// Adds a custom header. It should be the name: value, but without any line terminator.
+	/// For example: header("X-My-Header: Some value");
+	/// Note you should use the specialized functions in this object if possible to avoid
+	/// duplicates in the output.
+	void header(string h) {
+		customHeaders ~= h;
+	}
+
+	private string[] customHeaders;
+
+	/// Writes the data to the output, flushing headers if they have not yet been sent.
+	void write(const(void)[] t, bool isAll = false) {
+		assert(!closed, "Output has already been closed");
+		if(!outputtedResponseData && (!autoBuffer || isAll)) {
+			string[] hd;
+			// Flush the headers
+			if(responseStatus !is null) {
+				if(nph) {
+					if(http10)
+						hd ~= "HTTP/1.0 " ~ responseStatus;
+					else
+						hd ~= "HTTP/1.1 " ~ responseStatus;
+				} else
+					hd ~= "Status: " ~ responseStatus;
+			} else if (nph) {
+				if(http10)
+					hd ~= "HTTP/1.0 200 OK";
+				else
+					hd ~= "HTTP/1.1 200 OK";
+			}
+			if(nph) { // we're responsible for setting the date too according to http 1.1
+				hd ~= "Date: " ~ printDate(std.date.getUTCtime());
+				if(!isAll) {
+					if(!http10) {
+						hd ~= "Transfer-Encoding: chunked";
+						responseChunked = true;
+					}
+				} else
+					hd ~= "Content-Length: " ~ to!string(t.length);
+
+			}
+
+			// FIXME: what if the user wants to set his own content-length?
+			// The custom header function can do it, so maybe that's best.
+			// Or we could reuse the isAll param.
+			if(responseLocation !is null) {
+				hd ~= "Location: " ~ responseLocation;
+			}
+			if(!noCache && responseExpires != long.min) { // an explicit expiration date is set
+				hd ~= "Expires: " ~ printDate(responseExpires);
+				// FIXME: assuming everything is private unless you use nocache - generally right for dynamic pages, but not necessarily
+				hd ~= "Cache-Control: "~(responseIsPublic ? "public" : "private")~", no-cache=\"set-cookie\"";
+			}
+			if(responseCookies !is null && responseCookies.length > 0) {
+				foreach(c; responseCookies)
+					hd ~= "Set-Cookie: " ~ c;
+			}
+			if(noCache) { // we specifically do not want caching (this is actually the default)
+				hd ~= "Cache-Control: private, no-cache=\"set-cookie\"";
+				hd ~= "Expires: 0";
+				hd ~= "Pragma: no-cache";
+			} else {
+				if(responseExpires == long.min) { // caching was enabled, but without a date set - that means assume cache forever
+					hd ~= "Cache-Control: public";
+					hd ~= "Expires: Tue, 31 Dec 2030 14:00:00 GMT"; // FIXME: should not be more than one year in the future
+				}
+			}
+			if(responseContentType !is null) {
+				hd ~= "Content-Type: " ~ responseContentType;
+			} else
+				hd ~= "Content-Type: text/html; charset=utf-8";
+
+			if(customHeaders !is null)
+				hd ~= customHeaders;
+
+			// FIXME: what about duplicated headers?
+
+			foreach(h; hd) {
+				if(rawDataOutput !is null)
+					rawDataOutput(cast(const(ubyte)[]) (h ~ "\r\n"));
+				else
+					writeln(h);
+			}
+			if(rawDataOutput !is null)
+				rawDataOutput(cast(const(ubyte)[]) ("\r\n"));
+			else
+				writeln("");
+
+			outputtedResponseData = true;
+		}
+
+		if(requestMethod != RequestMethod.HEAD && t.length > 0) {
+			if (autoBuffer) {
+				outputBuffer ~= cast(ubyte[]) t;
+			}
+			if(!autoBuffer || isAll) {
+				if(rawDataOutput !is null)
+					if(nph && responseChunked)
+						rawDataOutput(makeChunk(cast(const(ubyte)[]) t));
+					else
+						rawDataOutput(cast(const(ubyte)[]) t);
+				else
+					stdout.rawWrite(t);
+			}
+		}
+	}
+
+	void flush() {
+		if(rawDataOutput is null)
+			stdout.flush();
+	}
+
+	version(autoBuffer)
+		bool autoBuffer = true;
+	else
+		bool autoBuffer = false;
+	ubyte[] outputBuffer;
+
+	/// Flushes the buffers to the network, signifying that you are done.
+	/// You should always call this explicitly when you are done outputting data.
+	void close() {
+		if(closed)
+			return; // don't double close
+
+		if(!outputtedResponseData)
+			write("");
+
+		// writing auto buffered data
+		if(requestMethod != RequestMethod.HEAD && autoBuffer) {
+			if(!nph)
+				stdout.rawWrite(outputBuffer);
+			else
+				write(outputBuffer, true); // tell it this is everything
+		}
+
+		// closing the last chunk...
+		if(nph && rawDataOutput !is null && responseChunked)
+			rawDataOutput(cast(const(ubyte)[]) "0\r\n\r\n");
+
+		closed = true;
+	}
+
+	// Closes without doing anything, shouldn't be used often
+	void rawClose() {
+		closed = true;
+	}
+
+	/// Gets a request variable as a specific type, or the default value of it isn't there
+	/// or isn't convertable to the request type. Checks both GET and POST variables.
+	T request(T = string)(in string name, in T def = T.init) const nothrow {
+		try {
+			return
+				(name in post) ? to!T(post[name]) :
+				(name in get)  ? to!T(get[name]) :
+				def;
+		} catch(Exception e) { return def; }
+	}
+
+	private void delegate(const(ubyte)[]) rawDataOutput = null;
+
+	private bool outputtedResponseData;
+	private bool nph;
+	private bool http10;
+	private bool closed;
+	private bool responseChunked = false;
+
+	private bool noCache = true;
+
+	version(preserveData)
+	immutable(ubyte)[] originalPostData;
+
+	immutable(char[]) host;
+	immutable(char[]) userAgent;
+	immutable(char[]) pathInfo;
+	immutable(char[]) scriptName;
+	immutable(char[]) authorization;
+
+	immutable(char[]) queryString;
+	immutable(char[]) referrer;
+	immutable(char[]) cookie;
+	immutable(char[]) requestUri;
+
+	immutable(RequestMethod) requestMethod;
+
+	immutable(string[string]) get;
+	immutable(string[string]) post;
+	immutable(string[string]) cookies;
+	immutable(UploadedFile)[string] files;
+
+	// Use these if you expect multiple items submitted with the same name. btw, assert(get[name] is getArray[name][$-1); should pass. Same for post and cookies.
+	// the order of the arrays is the order the data arrives
+	immutable(string[][string]) getArray;
+	immutable(string[][string]) postArray;
+	immutable(string[][string]) cookiesArray;
+
+	immutable(char[]) remoteAddress;
+
+	immutable bool https;
+	immutable int port;
+  private:
+	//RequestMethod _requestMethod;
+}
+/*
+import std.file;
+struct Session {
+	this(Cgi cgi) {
+		sid = "test.sid";
+
+		cgi.setCookie("arsd_sid", sid);
+	}
+
+	void loadFromFile() {
+		if(exists("/tmp/arsd-cgi-session-" ~ sid)) {
+
+		}
+	}
+
+	void saveToFile() {
+		std.file.write("/tmp/arsd-cgi-session-" ~ sid,
+
+		);
+	}
+
+	~this() {
+		saveToFile();
+	}
+
+	@disable this(this) { }
+
+	string sid;
+	string[string] session;
+}
+*/
+string[][string] decodeVariables(string data, string separator = "&") {
+	auto vars = data.split(separator);
+	string[][string] _get;
+	foreach(var; vars) {
+		int equal = var.indexOf("=");
+		if(equal == -1) {
+			_get[decodeComponent(var)] ~= "";
+		} else {
+			//_get[decodeComponent(var[0..equal])] ~= decodeComponent(var[equal + 1 .. $].replace("+", " "));
+			// stupid + -> space conversion.
+			_get[decodeComponent(var[0..equal]).replace("+", " ")] ~= decodeComponent(var[equal + 1 .. $].replace("+", " "));
+		}
+	}
+	return _get;
+}
+
+string[string] decodeVariablesSingle(string data) {
+	string[string] va;
+	auto varArray = decodeVariables(data);
+	foreach(k, v; varArray)
+		va[k] = v[$-1];
+
+	return va;
+}
+
+string encodeVariables(string[string] data) {
+	string ret;
+
+	bool outputted = false;
+	foreach(k, v; data) {
+		if(outputted)
+			ret ~= "&";
+		else
+			outputted = true;
+
+		ret ~= std.uri.encodeComponent(k) ~ "=" ~ std.uri.encodeComponent(v);
+	}
+
+	return ret;
+}
+
+string encodeVariables(string[][string] data) {
+	string ret;
+
+	bool outputted = false;
+	foreach(k, arr; data) {
+		foreach(v; arr) {
+			if(outputted)
+				ret ~= "&";
+			else
+				outputted = true;
+			ret ~= std.uri.encodeComponent(k) ~ "=" ~ std.uri.encodeComponent(v);
+		}
+	}
+
+	return ret;
+}
+
+const(ubyte)[] makeChunk(const(ubyte)[] data) {
+	const(ubyte)[] ret;
+
+	ret = cast(const(ubyte)[]) toHex(data.length);
+	ret ~= cast(const(ubyte)[]) "\r\n";
+	ret ~= data;
+	ret ~= cast(const(ubyte)[]) "\r\n";
+
+	return ret;
+}
+
+string toHex(int num) {
+	string ret;
+	while(num) {
+		int v = num % 16;
+		num /= 16;
+		char d = cast(char) ((v < 10) ? v + '0' : (v-10) + 'a');
+		ret ~= d;
+	}
+
+	return to!string(array(ret.retro));
+}
+
+mixin template GenericMain(alias fun, T...) { // kinda hacky - the T... is passed to Cgi's constructor in standard cgi mode, and ignored elsewhere
+version(embedded_httpd)
+	import arsd.httpd;
+
+	void main() {
+		version(embedded_httpd) {
+			serveHttp(&fun, 8080);//5005);
+			return;
+		}
+
+		version(fastcgi) {
+			FCGX_Stream* input, output, error;
+			FCGX_ParamArray env;
+
+			const(ubyte)[] getFcgiChunk() {
+				const(ubyte)[] ret;
+				while(FCGX_HasSeenEOF(input) != -1)
+					ret ~= cast(ubyte) FCGX_GetChar(input);
+				return ret;
+			}
+
+			void writeFcgi(const(ubyte)[] data) {
+				FCGX_PutStr(data.ptr, data.length, output);
+			}
+
+			while(FCGX_Accept(&input, &output, &error, &env) >= 0) {
+				string[string] fcgienv;
+
+				for(auto e = env; e !is null && *e !is null; e++) {
+					string cur = to!string(*e);
+					auto idx = cur.indexOf("=");
+					string name, value;
+					if(idx == -1)
+						name = cur;
+					else {
+						name = cur[0 .. idx];
+						value = cur[idx + 1 .. $];
+					}
+
+					fcgienv[name] = value;
+				}
+
+				string getFcgiEnvVar(string what) {
+					if(what in fcgienv)
+						return fcgienv[what];
+					return "";
+				}
+
+				auto cgi = new Cgi(5_000_000, &getFcgiEnvVar, &getFcgiChunk, &writeFcgi);
+				try {
+					fun(cgi);
+					cgi.close();
+				} catch(Throwable t) {
+					auto msg = t.toString;
+					FCGX_PutStr(cast(ubyte*) msg.ptr, msg.length, error);
+					msg = "Status: 500 Internal Server Error\n";
+					msg ~= "Content-Type: text/plain\n\n";
+					debug msg ~= t.toString;
+					else  msg ~= "An unexpected error has occurred.";
+
+					FCGX_PutStr(cast(ubyte*) msg.ptr, msg.length, output);
+				}
+			}
+
+			return;
+		}
+
+		auto cgi = new Cgi(T);
+
+		try {
+			fun(cgi);
+			cgi.close();
+		} catch (Throwable c) {
+			// FIXME: this sucks
+			string message = "An unexpected error has occurred.";
+
+			debug message = c.toString();
+
+			writefln("Status: 500 Internal Server Error\nContent-Type: text/html\n\n%s", "<html><head><title>Internal Server Error</title></head><body><br><br><br><br><code><pre>"~(std.array.replace(std.array.replace(message, "<", "&lt;"), ">", "&gt;"))~"</pre></code></body></html>");
+
+			string str = c.toString();
+			int idx = str.indexOf("\n");
+			if(idx != -1)
+				str = str[0..idx];
+			stderr.writeln(str);
+		}
+	}
+}
+
+string printDate(long date) {
+	return std.date.toUTCString(date).replace("UTC", "GMT"); // the standard is stupid
+}
+
+
+version(with_cgi_packed) {
+// This is temporary until Phobos supports base64
+import std.base64;
+immutable(ubyte)[] base64UrlDecode(string e) {
+	string encoded = e.idup;
+	while (encoded.length % 4) {
+		encoded ~= "="; // add padding
+	}
+
+	// convert base64 URL to standard base 64
+	encoded = encoded.replace("-", "+");
+	encoded = encoded.replace("_", "/");
+
+	return cast(immutable(ubyte)[]) Base64.decode(encoded);
+}
+	// should be set as arsd_packed_data
+	string packedDataEncode(in string[string] variables) {
+		string result;
+
+		bool outputted = false;
+		foreach(k, v; variables) {
+			if(outputted)
+				result ~= "&";
+			else
+				outputted = true;
+
+			result ~= std.uri.encodeComponent(k) ~ "=" ~ std.uri.encodeComponent(v);
+		}
+
+		result = cast(string) Base64.encode(cast(ubyte[]) result);
+
+		// url variant
+		result.replace("=", "");
+		result.replace("+", "-");
+		result.replace("/", "_");
+
+		return result;
+	}
+}
+
+
+// Referencing this gigantic typeid seems to remind the compiler
+// to actually put the symbol in the object file. I guess the immutable
+// assoc array array isn't actually included in druntime
+void hackAroundLinkerError() {
+      writeln(typeid(const(immutable(char)[][])[immutable(char)[]]));
+      writeln(typeid(immutable(char)[][][immutable(char)[]]));
+      writeln(typeid(Cgi.UploadedFile[immutable(char)[]]));
+      writeln(typeid(immutable(Cgi.UploadedFile)[immutable(char)[]]));
+      writeln(typeid(immutable(char[])[immutable(char)[]]));
+}
+
+
+
+
+
+version(fastcgi) {
+	pragma(lib, "fcgi");
+	extern(C) {
+
+	struct FCGX_Stream {
+		ubyte* rdNext;
+		ubyte* wrNext;
+		ubyte* stop;
+		ubyte* stopUnget;
+		int isReader;
+		int isClosed;
+		int wasFCloseCalled;
+		int FCGI_errno;
+		void* function(FCGX_Stream* stream) fillBuffProc;
+		void* function(FCGX_Stream* stream, int doClose) emptyBuffProc;
+		void* data;
+	}
+
+	alias char** FCGX_ParamArray;
+
+	int FCGX_Accept(FCGX_Stream** stdin, FCGX_Stream** stdout, FCGX_Stream** stderr, FCGX_ParamArray* envp);
+	int FCGX_GetChar(FCGX_Stream* stream);
+	int FCGX_PutStr(const ubyte* str, int n, FCGX_Stream* stream);
+	int FCGX_HasSeenEOF(FCGX_Stream* stream);
+
+	}
+}
+
+
+
+
+
+/*
+Copyright: Adam D. Ruppe, 2008 - 2011
+License:   <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
+Authors: Adam D. Ruppe
+
+	Copyright Adam D. Ruppe 2008 - 2011.
+Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+	http://www.boost.org/LICENSE_1_0.txt)
+*/
diff --git a/dom.d b/dom.d
deleted file mode 120000
index 505b2fa..0000000
--- a/dom.d
+++ /dev/null
@@ -1 +0,0 @@
-/home/me/program/djs/dom.d
\ No newline at end of file
diff --git a/dom.d b/dom.d
new file mode 100644
index 0000000..74536b6
--- /dev/null
+++ b/dom.d
@@ -0,0 +1,3455 @@
+module arsd.dom;
+
+import std.string;
+// import std.ascii;
+import std.exception;
+
+import std.uri;
+import std.array;
+
+import std.stdio;
+
+// Biggest (known) fixme left for "tag soup": <p> .... <p> in loose mode should close it on the second opening.
+// Biggest FIXME for real documents: character set encoding detection
+
+// Should I support Element.dataset? it does dash to camelcase for attribute "data-xxx-xxx"
+
+/*
+	To pwn haml, it might be interesting to add a
+
+	getElementBySelectorAndMakeIfNotThere
+
+	It first does querySelector. If null, find the path that was closest to matching using
+	the weight rules or the left to right reading, whatever gets close.
+
+	Then make the elements so it works and return the first matching element.
+
+
+	virtual Element setMainPart() {} // usually does innertext but can be overridden by certain elements
+
+
+	The haml converter produces a mixin string that does getElementBySelectorAndMakeIfNotThere and calls
+	setMainPart on it. boom.
+*/
+
+T[] insertAfter(T)(T[] arr, int position, T[] what) {
+	assert(position < arr.length);
+	T[] ret;
+	ret.length = arr.length + what.length;
+	int a = 0;
+	foreach(i; arr[0..position+1])
+		ret[a++] = i;
+	
+	foreach(i; what)
+		ret[a++] = i;
+
+	foreach(i; arr[position+1..$])
+		ret[a++] = i;
+
+	return ret;
+}
+
+bool isInArray(T)(T item, T[] arr) {
+	foreach(i; arr)
+		if(item == i)
+			return true;
+	return false;
+}
+
+class Stack(T) {
+	void push(T t) {
+		arr ~= t;
+	}
+
+	T pop() {
+		assert(arr.length);
+		T tmp = arr[$-1];
+		arr.length = arr.length - 1;
+		return tmp;
+	}
+
+	T peek() {
+		return arr[$-1];
+	}
+
+	bool empty() {
+		return arr.length ? false : true;
+	}
+
+	T[] arr;
+}
+
+class ElementStream {
+	Element front() {
+		return current.element;
+	}
+
+	this(Element start) {
+		current.element = start;
+		current.childPosition = -1;
+		isEmpty = false;
+		stack = new Stack!(Current);
+	}
+
+	/*
+		Handle it
+		handle its children
+
+	*/
+	void popFront() {
+	    more:
+	    	if(isEmpty) return;
+
+		current.childPosition++;
+		if(current.childPosition >= current.element.children.length) {
+			if(stack.empty())
+				isEmpty = true;
+			else {
+				current = stack.pop();
+				goto more;
+			}
+		} else {
+			stack.push(current);
+			current.element = current.element.children[current.childPosition];
+			current.childPosition = -1;
+		}
+	}
+
+	void currentKilled() {
+		if(stack.empty) // should never happen
+			isEmpty = true;
+		else {
+			current = stack.pop();
+			current.childPosition--; // when it is killed, the parent is brought back a lil so when we popFront, this is then right
+		}
+	}
+
+	bool empty() {
+		return isEmpty;
+	}
+
+	struct Current {
+		Element element;
+		int childPosition;
+	}
+
+	Current current;
+
+	Stack!(Current) stack;
+	bool isEmpty;
+}
+
+string[string] dup(in string[string] arr) {
+	string[string] ret;
+	foreach(k, v; arr)
+		ret[k] = v;
+	return ret;
+}
+
+/*
+	swapNode
+	cloneNode
+*/
+class Element {
+	Element[] children;
+	string tagName;
+	string[string] attributes;
+	bool selfClosed;
+
+	Document parentDocument;
+
+	this(Document _parentDocument, string _tagName, string[string] _attributes = null, bool _selfClosed = false) {
+		parentDocument = _parentDocument;
+		tagName = _tagName;
+		if(_attributes !is null)
+			attributes = _attributes;
+		selfClosed = _selfClosed;
+	}
+
+	@property Element previousSibling(string tagName = null) {
+		if(this.parentNode is null)
+			return null;
+		Element ps = null;
+		foreach(e; this.parentNode.childNodes) {
+			if(e is this)
+				break;
+			if(tagName is null || e.tagName == tagName)
+				ps = e;
+		}
+
+		return ps;
+	}
+
+	@property Element nextSibling(string tagName = null) {
+		if(this.parentNode is null)
+			return null;
+		Element ns = null;
+		bool mightBe = false;
+		foreach(e; this.parentNode.childNodes) {
+			if(e is this) {
+				mightBe = true;
+				continue;
+			}
+			if(mightBe)
+				if(tagName is null || e.tagName == tagName) {
+					ns = e;
+					break;
+				}
+		}
+
+		return ns;
+	}
+
+
+	// if you change something here, it won't apply... FIXME const? but changing it would be nice if it applies to the style attribute too though you should use style there.
+	@property CssStyle computedStyle() {
+		if(_computedStyle is null) {
+			auto style = this.getAttribute("style");
+		/* we'll treat shitty old html attributes as css here */
+			if(this.hasAttribute("width"))
+				style ~= "; width: " ~ this.width;
+			if(this.hasAttribute("height"))
+				style ~= "; width: " ~ this.height;
+			if(this.hasAttribute("bgcolor"))
+				style ~= "; background-color: " ~ this.bgcolor;
+			if(this.tagName == "body" && this.hasAttribute("text"))
+				style ~= "; color: " ~ this.text;
+			if(this.hasAttribute("color"))
+				style ~= "; color: " ~ this.color;
+		/* done */
+
+
+			_computedStyle = new CssStyle(null, style); // gives at least something to work with
+		}
+		return _computedStyle;
+	}
+
+	private CssStyle _computedStyle;
+
+	// These properties are useless in most cases, but if you write a layout engine on top of this lib, they may be good
+	version(browser) {
+		void* expansionHook;
+		int offsetWidth;
+		int offsetHeight;
+		int offsetLeft;
+		int offsetTop;
+		Element offsetParent;
+		bool hasLayout;
+		int zIndex;
+
+		int absoluteLeft() {
+			int a = offsetLeft;
+			auto p = offsetParent;
+			while(p) {
+				a += p.offsetLeft;
+				p = p.offsetParent;
+			}
+
+			return a;
+		}
+
+		int absoluteTop() {
+			int a = offsetTop;
+			auto p = offsetParent;
+			while(p) {
+				a += p.offsetTop;
+				p = p.offsetParent;
+			}
+
+			return a;
+		}
+	}
+
+	// Back to the regular dom functions
+
+	@property Element cloned() {
+		auto e = new Element(parentDocument, tagName, attributes.dup, selfClosed);
+		foreach(child; children) {
+			e.appendChild(child.cloned);
+		}
+
+		return e;
+	}
+
+	/// Returns the first child of this element. If it has no children, returns null.
+	@property Element firstChild() {
+		return children.length ? children[0] : null;
+	}
+
+	@property Element lastChild() {
+		return children.length ? children[$ - 1] : null;
+	}
+
+	/// Convenience constructor when you don't care about the parentDocument. Note this might break things on the document.
+	/// Note also that without a parent document, elements are always in strict, case-sensitive mode.
+	this(string _tagName, string[string] _attributes = null) {
+		tagName = _tagName;
+		if(_attributes !is null)
+			attributes = _attributes;
+		selfClosed = tagName.isInArray(selfClosedElements);
+	}
+
+	/*
+	private this() {
+
+	}
+	*/
+
+	private this(Document _parentDocument) {
+		parentDocument = _parentDocument;
+	}
+
+	private void parseAttributes(string[] whichOnes = null) {
+/+
+		if(whichOnes is null)
+			whichOnes = attributes.keys;
+		foreach(attr; whichOnes) {
+			switch(attr) {
+				case "id":
+
+				break;
+				case "class":
+
+				break;
+				case "style":
+
+				break;
+				default:
+					// we don't care about it
+			}
+		}
++/
+	}
+
+    public:
+    	/// Appends the given element to this one. The given element must not have a parent already.
+	Element appendChild(Element e)
+		in {
+			assert(e !is null);
+			assert(e.parentNode is null);
+		}
+		out (ret) {
+			assert(e.parentNode is this);
+			assert(e is ret);
+		}
+	body {
+		selfClosed = false;
+		e.parentNode = this;
+		e.parentDocument = this.parentDocument;
+		children ~= e;
+		return e;
+	}
+
+	/// Inserts the second element to this node, right before the first param
+	Element insertBefore(Element where, Element what)
+		in {
+			assert(where !is null);
+			assert(where.parentNode is this);
+			assert(what !is null);
+			assert(what.parentNode is null);
+		}
+		out (ret) {
+			assert(where.parentNode is this);
+			assert(what.parentNode is this);
+			assert(ret is what);
+		}
+	body {
+		foreach(i, e; children) {
+			if(e is where) {
+				children = children[0..i] ~ what ~ children[i..$];
+				what.parentNode = this;
+				return what;
+			}
+		}
+
+		return what;
+
+		assert(0);
+	}
+
+	Element insertAfter(Element where, Element what)
+		in {
+			assert(where !is null);
+			assert(where.parentNode is this);
+			assert(what !is null);
+			assert(what.parentNode is null);
+		}
+		out (ret) {
+			assert(where.parentNode is this);
+			assert(what.parentNode is this);
+			assert(ret is what);
+		}
+	body {
+		foreach(i, e; children) {
+			if(e is where) {
+				children = children[0 .. i + 1] ~ what ~ children[i + 1 .. $];
+				what.parentNode = this;
+				return what;
+			}
+		}
+
+		return what;
+
+		assert(0);
+	}
+
+
+	/// convenience function to quickly add a tag with some text or
+	/// other relevant info (for example, it's a src for an <img> element
+	/// instead of inner text)
+	Element addChild(string tagName, string childInfo = null, string childInfo2 = null) {
+		auto e = parentDocument.createElement(tagName);
+		if(childInfo !is null)
+			switch(tagName) {
+				case "img":
+					e.src = childInfo;
+					if(childInfo2 !is null)
+						e.alt = childInfo2;
+				break;
+				case "option":
+					e.innerText = childInfo;
+					if(childInfo2 !is null)
+						e.value = childInfo2;
+				break;
+				case "input":
+					e.type = "hidden";
+					e.name = childInfo;
+					if(childInfo2 !is null)
+						e.value = childInfo2;
+				break;
+				case "a":
+					e.innerText = childInfo;
+					if(childInfo2 !is null)
+						e.href = childInfo2;
+				break;
+				case "script":
+				case "style":
+					e.innerRawSource = childInfo;
+				break;
+				case "meta":
+					e.name = childInfo;
+					if(childInfo2 !is null)
+						e.content = childInfo2;
+				break;
+				default:
+					e.innerText = childInfo;
+			}
+		return appendChild(e);
+	}
+
+	Element addChild(string tagName, Element firstChild)
+	in {
+		assert(parentDocument !is null);
+		assert(firstChild !is null);
+	}
+	out(ret) {
+		assert(ret !is null);
+		assert(ret.parentNode is this);
+		assert(firstChild.parentNode is ret);
+	}
+	body {
+		auto e = parentDocument.createElement(tagName);
+		e.appendChild(firstChild);
+		this.appendChild(e);
+		return e;
+	}
+
+	T getParent(T)(string tagName = null) if(is(T : Element)) {
+		if(tagName is null) {
+			static if(is(T == Form))
+				tagName = "form";
+			else static if(is(T == Table))
+				tagName = "table";
+			else static if(is(T == Table))
+				tagName == "a";
+		}
+
+		auto par = this.parentNode;
+		while(par !is null) {
+			if(tagName is null || par.tagName == tagName)
+				break;
+			par = par.parentNode;
+		}
+
+		auto t = cast(T) par;
+		if(t is null)
+			throw new ElementNotFoundException("", tagName ~ " parent not found");
+
+		return t;
+	}
+
+	/// swaps one child for a new thing. Returns the old child which is now parentless.
+	Element swapNode(Element child, Element replacement) {
+		foreach(ref c; this.children)
+			if(c is child) {
+				c.parentNode = null;
+				c = replacement;
+				c.parentNode = this;
+				return child;
+			}
+		assert(0);
+	}
+
+
+	Element getElementById(string id) {
+		foreach(e; tree)
+			if(e.id == id)
+				return e;
+		return null;
+	}
+
+	final SomeElementType requireElementById(SomeElementType = Element)(string id)
+	if(
+		is(SomeElementType : Element)
+	)
+	out(ret) {
+		assert(ret !is null);
+	}
+	body {
+		auto e = cast(SomeElementType) getElementById(id);
+		if(e is null)
+			throw new ElementNotFoundException(SomeElementType.stringof, "id=" ~ id);
+		return e;
+	}
+
+	final SomeElementType requireSelector(SomeElementType = Element)(string selector)
+	if(
+		is(SomeElementType : Element)
+	)
+	out(ret) {
+		assert(ret !is null);
+	}
+	body {
+		auto e = cast(SomeElementType) querySelector(selector);
+		if(e is null)
+			throw new ElementNotFoundException(SomeElementType.stringof, selector);
+		return e;
+	}
+
+	Element querySelector(string selector) {
+		// FIXME: inefficient
+		auto list = getElementsBySelector(selector);
+		if(list.length == 0)
+			return null;
+		return list[0];
+	}
+
+	/// a more standards-compliant alias for getElementsBySelector
+	Element[] querySelectorAll(string selector) {
+		return getElementsBySelector(selector);
+	}
+
+	Element[] getElementsBySelector(string selector) {
+		if(parentDocument && parentDocument.loose)
+			selector = selector.toLower;
+
+		Element[] ret;
+		foreach(sel; parseSelectorString(selector))
+			ret ~= sel.getElements(this);
+		return ret;
+	}
+
+	Element[] getElementsByTagName(string tag) {
+		if(parentDocument && parentDocument.loose)
+			tag = tag.toLower();
+		Element[] ret;
+		foreach(e; tree)
+			if(e.tagName == tag)
+				ret ~= e;
+		return ret;
+	}
+
+	Element appendText(string text) {
+		Element e = new TextNode(parentDocument, text);
+		return appendChild(e);
+	}
+
+	@property Element[] childElements() {
+		Element[] ret;
+		foreach(c; children)
+			if(c.nodeType == 1)
+				ret ~= c;
+		return ret;
+	}
+
+	/*
+		Does a CSS selector
+
+		* -- all, default if nothing else is there
+
+		tag#id.class.class.class:pseudo[attrib=what][attrib=what] OP selector
+
+		It is all additive
+
+		OP
+
+		space = descendant
+		>     = direct descendant
+		+     = sibling (E+F Matches any F element immediately preceded by a sibling element E)
+
+		[foo]        Foo is present as an attribute
+		[foo="warning"]   Matches any E element whose "foo" attribute value is exactly equal to "warning".
+		E[foo~="warning"] Matches any E element whose "foo" attribute value is a list of space-separated values, one of which is exactly equal to "warning"
+		E[lang|="en"] Matches any E element whose "lang" attribute has a hyphen-separated list of values beginning (from the left) with "en".
+
+		[item$=sdas] ends with
+		[item^-sdsad] begins with
+
+		Quotes are optional here.
+
+		Pseudos:
+			:first-child
+			:last-child
+			:link (same as a[href] for our purposes here)
+
+
+		There can be commas separating the selector. A comma separated list result is OR'd onto the main.
+
+
+
+		This ONLY cares about elements. text, etc, are ignored
+
+
+		There should be two functions: given element, does it match the selector? and given a selector, give me all the elements
+	*/
+
+	/// Appends the given html to the element, returning the elements appended
+	Element[] appendHtml(string html) {
+		Document d = new Document("<root>" ~ html ~ "</root>");
+		return stealChildren(d.root);
+	}
+
+	Element addClass(string c) {
+		string cn = getAttribute("class");
+		if(cn is null) {
+			setAttribute("class", c);
+			return this;
+		} else {
+			setAttribute("class", cn ~ " " ~ c);
+		}
+
+		return this;
+	}
+
+	Element removeClass(string c) {
+		auto cn = className;
+
+		className = cn.replace(c, "").strip;
+
+		return this;
+	}
+
+	bool hasClass(string c) {
+		auto cn = className;
+
+		int idx = cn.indexOf(c);
+		if(idx == -1)
+			return false;
+
+		foreach(cla; cn.split(" "))
+			if(cla == c)
+				return true;
+		return false;
+
+		/*
+		int rightSide = idx + c.length;
+
+		bool checkRight() {
+			if(rightSide == cn.length)
+				return true; // it's the only class
+			else if(iswhite(cn[rightSide]))
+				return true;
+			return false; // this is a substring of something else..
+		}
+
+		if(idx == 0) {
+			return checkRight();
+		} else {
+			if(!iswhite(cn[idx - 1]))
+				return false; // substring
+			return checkRight();
+		}
+
+		assert(0);
+		*/
+	}
+
+	void reparent(Element newParent)
+		in {
+			assert(newParent !is null);
+			assert(parentNode !is null);
+		}
+		out {
+			assert(this.parentNode == newParent);
+			assert(isInArray(this, newParent.children));
+		}
+	body {
+		parentNode.removeChild(this);
+		newParent.appendChild(this);
+	}
+
+	void insertChildAfter(Element child, Element where)
+		in {
+			assert(child !is null);
+			assert(where !is null);
+			assert(where.parentNode is this);
+			assert(!selfClosed);
+			assert(isInArray(where, children));
+		}
+		out {
+			assert(child.parentNode is this);
+			assert(where.parentNode is this);
+			assert(isInArray(where, children));
+			assert(isInArray(child, children));
+		}
+	body {
+		foreach(i, c; children) {
+			if(c is where) {
+				i++;
+				children = children[0..i] ~ child ~ children[i..$];
+				child.parentNode = this;
+				break;
+			}
+		}
+	}
+
+	Element[] stealChildren(Element e, Element position = null)
+		in {
+			assert(!selfClosed);
+			assert(e !is null);
+			if(position !is null)
+				assert(isInArray(position, children));
+		}
+		out {
+			assert(e.children.length == 0);
+		}
+	body {
+		foreach(c; e.children)
+			c.parentNode = this;
+		if(position is null)
+			children ~= e.children;
+		else {
+			foreach(i, child; children) {
+				if(child is position) {
+					children = children[0..i] ~
+						e.children ~
+						children[i..$];
+					break;
+				}
+			}
+		}
+
+		auto ret = e.children.dup;
+		e.children.length = 0;
+
+		return ret;
+	}
+
+    	/// Puts the current element first in our children list. The given element must not have a parent already.
+	Element prependChild(Element e)
+		in {
+			assert(e.parentNode is null);
+			assert(!selfClosed);
+		}
+		out {
+			assert(e.parentNode is this);
+			assert(children[0] is e);
+		}
+	body {
+		e.parentNode = this;
+		children = e ~ children;
+		return e;
+	}
+
+
+	/**
+		Provides easy access to attributes, like in javascript
+	*/
+		// name != "popFront" is so duck typing doesn't think it's a range
+	string opDispatch(string name)(string v = null) if(name != "popFront") {
+		if(v !is null)
+			setAttribute(name, v);
+		return getAttribute(name);
+	}
+
+	/**
+		Returns the element's children.
+	*/
+	@property const(Element[]) childNodes() const {
+		return children;
+	}
+
+	/// Mutable version of the same
+	@property Element[] childNodes() { // FIXME: the above should be inout
+		return children;
+	}
+
+
+	// should return int
+	@property int nodeType() const {
+		return 1;
+	}
+
+	/**
+		Returns a string containing all child elements, formatted such that it could be pasted into
+		an XML file.
+	*/
+	@property string innerHTML() const {
+		string s = "";
+		if(children is null) {
+			assert(s !is null);
+			return s;
+		}
+		foreach(child; children) {
+			assert(child !is null);
+			auto ts = child.toString();
+			assert(ts !is null);
+			s ~= ts;
+		}
+
+		assert(s !is null);
+
+		return s;
+	}
+
+	/**
+		Takes some html and replaces the element's children with the tree made from the string.
+	*/
+	@property void innerHTML(string html) {
+		if(html.length)
+			selfClosed = false;
+
+		auto doc = new Document();
+		doc.parse("<innerhtml>" ~ html ~ "</innerhtml>"); // FIXME: this should preserve the strictness of the parent document
+
+		children = doc.root.children;
+		foreach(c; children) {
+			c.parentNode = this;
+		}
+
+		auto newpd = this.parentDocument;
+		foreach(c; this.tree) {
+			c.parentDocument = newpd;
+		}
+
+		doc.root.children = null;
+	}
+
+	/**
+		Replaces this node with the given html string, which is parsed
+
+		Note: this invalidates the this reference, since it is removed
+		from the tree.
+
+		Returns the new children that replace this.
+	*/
+	@property Element[] outerHTML(string html) {
+		auto doc = new Document();
+		doc.parse("<innerhtml>" ~ html ~ "</innerhtml>"); // FIXME: needs to preserve the strictness
+
+		children = doc.root.children;
+		foreach(c; children) {
+			c.parentNode = this;
+		}
+
+
+		stripOut();
+
+		return doc.root.children;
+	}
+
+	@property string outerHTML() {
+		return this.toString();
+	}
+
+	@property void innerRawSource(string rawSource) {
+		children.length = 0;
+		auto rs = new RawSource(parentDocument, rawSource);
+		rs.parentNode = this;
+
+		children ~= rs;
+	}
+
+	/**
+		Gets the given attribute value, or null if the
+		attribute is not set.
+
+		Note that the returned string is decoded, so it no longer contains any xml entities.
+	*/
+	string getAttribute(string name) const {
+		if(parentDocument && parentDocument.loose)
+			name = name.toLower();
+		auto e = name in attributes;
+		if(e)
+			return *e;
+		else
+			return null;
+	}
+
+	/**
+		Sets an attribute. Returns this for easy chaining
+	*/
+	Element setAttribute(string name, string value) {
+		if(parentDocument && parentDocument.loose)
+			name = name.toLower();
+
+		// I never use this shit legitimately and neither should you
+		if(name.toLower == "href" || name.toLower == "src") {
+			if(value.strip.toLower.startsWith("vbscript:"))
+				value = value[9..$];
+			if(value.strip.toLower.startsWith("javascript:"))
+				value = value[11..$];
+		}
+
+		attributes[name] = value;
+
+		return this;
+	}
+
+	/**
+		Extension
+	*/
+	bool hasAttribute(string name) {
+		if(parentDocument && parentDocument.loose)
+			name = name.toLower();
+
+		if(name in attributes)
+			return true;
+		else
+			return false;
+	}
+
+	/**
+		Extension
+	*/
+	void removeAttribute(string name) {
+		if(parentDocument && parentDocument.loose)
+			name = name.toLower();
+		if(name in attributes)
+			attributes.remove(name);
+	}
+
+	/**
+		Gets the class attribute's contents. Returns
+		an empty string if it has no class.
+	*/
+	string className() const {
+		auto c = getAttribute("class");
+		if(c is null)
+			return "";
+		return c;
+	}
+
+	Element className(string c) {
+		setAttribute("class", c);
+		return this;
+	}
+
+	string nodeValue() const {
+		return "";
+	}
+
+	Element replaceChild(Element find, Element replace) 
+		in {
+			assert(find !is null);
+			assert(replace !is null);
+			assert(replace.parentNode is null);
+		}
+		out {
+			assert(replace.parentNode is this);
+			assert(find.parentNode is null);
+		}
+	body {
+		for(int i = 0; i < children.length; i++) {
+			if(children[i] is find) {
+				replace.parentNode = this;
+				children[i].parentNode = null;
+				children[i] = replace;
+				return replace;
+			}
+		}
+
+		throw new Exception("no such child");
+	}
+
+	/**
+		Removes the given child from this list.
+
+		Returns the removed element.
+	*/
+	Element removeChild(Element c)
+		in {
+			assert(c !is null);
+			assert(c.parentNode is this);
+		}
+		out {
+			foreach(child; children)
+				assert(child !is c);
+			assert(c.parentNode is null);
+		}
+	body {
+		foreach(i, e; children) {
+			if(e is c) {
+				children = children[0..i] ~ children [i+1..$];
+				c.parentNode = null;
+				return c;
+			}
+		}
+
+		throw new Exception("no such child");
+	}
+
+	Element[] removeChildren()
+		out (ret) {
+			assert(children.length == 0);
+			foreach(r; ret)
+				assert(r.parentNode is null);
+		}
+	body {
+		Element[] oldChildren = children.dup;
+		foreach(c; oldChildren)
+			c.parentNode = null;
+
+		children.length = 0;
+
+		return oldChildren;
+	}
+
+	/**
+		EXTENSION
+
+		Replaces the given element with a whole group.
+	*/
+	void replaceChild(Element find, Element[] replace)
+		in {
+			assert(find !is null);
+			assert(replace !is null);
+			assert(find.parentNode is this);
+			foreach(r; replace)
+				assert(r.parentNode is null);
+		}
+		out {
+			assert(find.parentNode is null);
+			assert(children.length >= replace.length);
+			foreach(child; children)
+				assert(child !is find);
+			foreach(r; replace)
+				assert(r.parentNode is this);
+		}
+	body {
+		if(replace.length == 0) {
+			removeChild(find);
+			return;
+		}
+		assert(replace.length);
+		for(int i = 0; i < children.length; i++) {
+			if(children[i] is find) {
+				children[i].parentNode = null; // this element should now be dead
+				children[i] = replace[0];
+				children = .insertAfter(children, i, replace[1..$]);
+				foreach(e; replace)
+					e.parentNode = this;
+				return;
+			}
+		}
+
+		throw new Exception("no such child");
+	}
+
+	Element parentNode;
+
+	/**
+		Strips this tag out of the document, putting its inner html
+		as children of the parent.
+	*/
+	void stripOut()
+		in {
+			assert(parentNode !is null);
+		}
+		out {
+			assert(parentNode is null);
+			assert(children.length == 0);
+		}
+	body {
+		foreach(c; children)
+			c.parentNode = null; // remove the parent
+		if(children.length)
+			parentNode.replaceChild(this, this.children);
+		else
+			parentNode.removeChild(this);
+		this.children.length = 0; // we reparented them all above
+	}
+
+	Element replaceWith(Element e) {
+		if(e.parentNode !is null)
+			e.parentNode.removeChild(e);
+		this.parentNode.replaceChild(this, e);
+		return e;
+	}
+
+	/**
+		INCOMPATIBLE -- extension
+
+		Splits the className into an array of each class given
+	*/
+	string[] classNames() const {
+		return className().split(" ");
+	}
+
+	/**
+		Fetches the first consecutive text nodes, concatenated together
+	*/
+	string firstInnerText() const {
+		string s;
+		foreach(child; children) {
+			if(child.nodeType != NodeType.Text)
+				break;
+
+			s ~= child.nodeValue();
+		}
+		return s;
+	}
+
+	/**
+		Fetch the inside text, with all tags stripped out
+	*/
+	@property string innerText() const {
+		string s;
+		foreach(child; children) {
+			if(child.nodeType != NodeType.Text)
+				s ~= child.innerText;
+			else
+				s ~= child.nodeValue();
+		}
+		return s;
+	}
+
+	/**
+		Sets the inside text, replacing all children
+	*/
+	@property void innerText(string text) {
+		assert(!selfClosed);
+		Element e = new TextNode(parentDocument, text);
+		e.parentNode = this;
+		children = [e];
+	}
+
+	/**
+		Strips this node out of the document, replacing it with the given text
+	*/
+	@property void outerText(string text) {
+		parentNode.replaceChild(this, new TextNode(parentDocument, text));
+	}
+
+	/**
+		Same result as innerText; the tag with all tags stripped out
+	*/
+	@property string outerText() const {
+		return innerText();
+	}
+
+
+	invariant () {
+		if(children !is null)
+		foreach(child; children) {
+		//	assert(parentNode !is null);
+			assert(child !is null);
+			assert(child.parentNode is this, format("%s is not a parent of %s (it thought it was %s)", tagName, child.tagName, child.parentNode is null ? "null" : child.parentNode.tagName));
+			assert(child !is this);
+			assert(child !is parentNode);
+		}
+
+		//assert(parentDocument !is null); // no more; if it is present, we use it, but it is not required
+		// reason is so you can create these without needing a reference to the document
+	}
+
+	/**
+		Turns the whole element, including tag, attributes, and children, into a string which could be pasted into
+		an XML file.
+	*/
+	override string toString() const {
+		assert(tagName !is null);
+		string s = "<" ~ tagName;
+
+		foreach(n, v ; attributes) {
+			assert(n !is null);
+			//assert(v !is null);
+			s ~= " " ~ n ~ "=\"" ~ htmlEntitiesEncode(v) ~ "\"";
+		}
+
+		if(selfClosed){
+			s ~= " />";
+			return s;
+		}
+
+		s ~= ">";
+
+		s ~= innerHTML();
+
+		s ~= "</" ~ tagName ~ ">";
+
+		assert(s !is null);
+
+		return s;
+	}
+
+	/**
+		Returns a lazy range of all its children, recursively.
+	*/
+	ElementStream tree() {
+		return new ElementStream(this);
+	}
+}
+
+class DocumentFragment : Element {
+	this(Document _parentDocument) {
+		tagName = "#fragment";
+		super(_parentDocument);
+	}
+
+	override string toString() const {
+		return this.innerHTML;
+	}
+}
+
+string htmlEntitiesEncode(string data) {
+	char[] output = "".dup;
+	foreach(dchar d; data) {
+		if(d == '&')
+			output ~= "&amp;";
+		else if (d == '<')
+			output ~= "&lt;";
+		else if (d == '>')
+			output ~= "&gt;";
+		else if (d == '\"')
+			output ~= "&quot;";
+		else if (d < 128 && d > 0)
+			output ~= d;
+		else
+			output ~= "&#" ~ std.conv.to!string(cast(int) d) ~ ";";
+	}
+
+	//assert(output !is null); // this fails on empty attributes.....
+	return assumeUnique(output);
+
+//	data = data.replace("\u00a0", "&nbsp;");
+}
+
+string xmlEntitiesEncode(string data) {
+	return htmlEntitiesEncode(data);
+}
+
+dchar parseEntity(in dchar[] entity) {
+	switch(entity[1..$-1]) {
+		case "quot":
+			return '"';
+		case "apos":
+			return '\'';
+		case "lt":
+			return '<';
+		case "gt":
+			return '>';
+		// the next are html rather than xml
+		/*
+		case "cent":
+		case "pound":
+		case "sect":
+		case "deg":
+		case "micro"
+		*/
+		case "lsquo":
+			return '\u2018';
+		case "rsquo":
+			return '\u2019';
+		case "ldquo":
+			return '\u201c';
+		case "rdquo":
+			return '\u201d';
+		case "reg":
+			return '\u00ae';
+		case "trade":
+			return '\u2122';
+		case "nbsp":
+			return '\u00a0';
+		case "amp":
+			return '&';
+		case "copy":
+			return '\u00a9';
+		case "eacute":
+			return '\u00e9';
+		case "mdash":
+			return '\u2014';
+		// and handling numeric entities
+		default:
+			if(entity[1] == '#') {
+				if(entity[2] == 'x' /*|| (!strict && entity[2] == 'X')*/) {
+					auto hex = entity[3..$-1];
+
+					auto p = intFromHex(to!string(hex).toLower());
+					return cast(dchar) p;
+				} else {
+					auto decimal = entity[2..$-1];
+
+					auto p = std.conv.to!int(decimal);
+					return cast(dchar) p;
+				}
+			} else
+				return '?';
+	}
+
+	assert(0);
+}
+
+import std.utf;
+
+string htmlEntitiesDecode(string data, bool strict = false) {
+	dchar[] a;
+
+	bool tryingEntity = false;
+	dchar[] entityBeingTried;
+	int entityAttemptIndex = 0;
+
+	foreach(dchar ch; data) {
+		if(tryingEntity) {
+			entityAttemptIndex++;
+			entityBeingTried ~= ch;
+
+			if(ch == ';') {
+				tryingEntity = false;
+				a ~= parseEntity(entityBeingTried);
+			} else {
+				if(entityAttemptIndex >= 7) {
+					if(strict)
+						throw new Exception("unterminated entity at " ~ to!string(entityBeingTried));
+					else {
+						tryingEntity = false;
+						a ~= entityBeingTried;
+					}
+				}
+			}
+		} else {
+			if(ch == '&') {
+				tryingEntity = true;
+				entityBeingTried = null;
+				entityBeingTried ~= ch;
+				entityAttemptIndex = 0;
+			} else {
+				a ~= ch;
+			}
+		}
+	}
+
+	return std.conv.to!string(a);
+}
+
+class RawSource : Element {
+	this(Document _parentDocument, string s) {
+		super(_parentDocument);
+		source = s;
+		tagName = "#raw";
+	}
+
+	override string nodeValue() const {
+		return this.toString();
+	}
+
+	override int nodeType() const {
+		return 100;
+	}
+
+	override string toString() const {
+		return source;
+	}
+
+	override Element appendChild(Element e) {
+		assert(0, "Cannot append to a text node");
+	}
+
+
+	string source;
+}
+
+enum NodeType { Text = 3}
+
+class TextNode : Element {
+  public:
+	this(Document _parentDocument, string e) {
+		super(_parentDocument);
+		contents = e;
+		tagName = "#text";
+	}
+
+	static TextNode fromUndecodedString(Document _parentDocument, string html) {
+		auto e = new TextNode(_parentDocument, "");
+		e.contents = htmlEntitiesDecode(html, _parentDocument is null ? false : !_parentDocument.loose);
+		return e;
+	}
+
+	override @property Element cloned() {
+		return new TextNode(parentDocument, contents);
+	}
+
+	override string nodeValue() const {
+		return this.contents; //toString();
+	}
+
+	override int nodeType() const {
+		return NodeType.Text;
+	}
+
+	override string toString() const {
+		string s;
+		if(contents.length)
+			s = htmlEntitiesEncode(contents);
+		else
+			s = "";
+
+		assert(s !is null);
+		return s;
+	}
+
+	override Element appendChild(Element e) {
+		assert(0, "Cannot append to a text node");
+	}
+
+	string contents;
+}
+
+/**
+	There are subclasses of Element offering improved helper
+	functions for the element in HTML.
+*/
+
+class Link : Element {
+	this(Document _parentDocument) {
+		super(_parentDocument);
+	}
+
+	this(string href, string text) {
+		super("a");
+		setAttribute("href", href);
+		innerText = text;
+	}
+/+
+	/// Returns everything in the href EXCEPT the query string
+	@property string targetSansQuery() {
+
+	}
+
+	@property string domainName() {
+
+	}
+
+	@property string path
++/
+	/// This gets a variable from the URL's query string.
+	string getValue(string name) {
+		auto vars = variablesHash();
+		if(name in vars)
+			return vars[name];
+		return null;
+	}
+
+	private string[string] variablesHash() {
+		string href = getAttribute("href");
+		if(href is null)
+			return null;
+
+		int ques = href.indexOf("?");
+		string str = "";
+		if(ques != -1) {
+			str = href[ques+1..$];
+
+			int fragment = str.indexOf("#");
+			if(fragment != -1)
+				str = str[0..fragment];
+		}
+
+		string[] variables = str.split("&");
+
+		string[string] hash;
+
+		foreach(var; variables) {
+			int index = var.indexOf("=");
+			if(index == -1)
+				hash[var] = "";
+			else {
+				hash[decodeComponent(var[0..index])] = decodeComponent(var[index + 1 .. $]);
+			}
+		}
+
+		return hash;
+	}
+
+	/*private*/ void updateQueryString(string[string] vars) {
+		string href = getAttribute("href");
+
+		int question = href.indexOf("?");
+		if(question != -1)
+			href = href[0..question];
+
+		string frag = "";
+		int fragment = href.indexOf("#");
+		if(fragment != -1) {
+			frag = href[fragment..$];
+			href = href[0..fragment];
+		}
+
+		string query = "?";
+		bool first = true;
+		foreach(name, value; vars) {
+			if(!first)
+				query ~= "&";
+			else
+				first = false;
+
+			query ~= encodeComponent(name);
+			if(value.length)
+				query ~= "=" ~ encodeComponent(value);
+		}
+
+		if(query != "?")
+			href ~= query;
+
+		href ~= frag;
+
+		setAttribute("href", href);
+	}
+
+	/// Sets or adds the variable with the given name to the given value
+	/// It automatically URI encodes the values and takes care of the ? and &.
+	void setValue(string name, string variable) {
+		auto vars = variablesHash();
+		vars[name] = variable;
+
+		updateQueryString(vars);
+	}
+
+	/// Removes the given variable from the query string
+	void removeValue(string name) {
+		auto vars = variablesHash();
+		vars.remove(name);
+
+		updateQueryString(vars);
+	}
+
+	/*
+	override string toString() {
+
+	}
+
+	override string getAttribute(string name) {
+		if(name == "href") {
+
+		} else
+			return super.getAttribute(name);
+	}
+	*/
+}
+
+class Form : Element {
+	this(Document _parentDocument) {
+		super(_parentDocument);
+		tagName = "form";
+	}
+
+	// FIXME: doesn't handle arrays; multiple fields can have the same name
+
+	/// Set's the form field's value. For input boxes, this sets the value attribute. For
+	/// textareas, it sets the innerText. For radio boxes and select boxes, it removes
+	/// the checked/selected attribute from all, and adds it to the one matching the value.
+	/// For checkboxes, if the value is non-null and not empty, it checks the box.
+
+	/// If you set a value that doesn't exist, it throws an exception if makeNew is false.
+	/// Otherwise, it makes a new input with type=hidden to keep the value.
+	void setValue(string field, string value, bool makeNew = true) {
+		auto eles = getField(field);
+		if(eles.length == 0) {
+			if(makeNew) {
+				addField(field, value);
+				return;
+			} else
+				throw new Exception("form field does not exist");
+		}
+
+		if(eles.length == 1) {
+			auto e = eles[0];
+			switch(e.tagName) {
+				default: assert(0);
+				case "textarea":
+					e.innerText = value;
+				break;
+				case "input":
+					string type = e.getAttribute("type");
+					if(type is null) {
+						e.value = value;
+						return;
+					}
+					switch(type) {
+						case "checkbox":
+						case "radio":
+							if(value.length)
+								e.setAttribute("checked", "checked");
+							else
+								e.removeAttribute("checked");
+						break;
+						default:
+							e.value = value;
+							return;
+					}
+				break;
+				case "select":
+					bool found = false;
+					foreach(child; e.tree) {
+						if(child.tagName != "option")
+							continue;
+						string val = child.getAttribute("value");
+						if(val is null)
+							val = child.innerText;
+						if(val == value) {
+							child.setAttribute("selected", "selected");
+							found = true;
+						} else
+							child.removeAttribute("selected");
+					}
+
+					if(!found) {
+						addChild("option", value)
+						.setAttribute("selected", "selected");
+					}
+				break;
+			}
+		} else {
+			// assume radio boxes
+			foreach(e; eles) {
+				string val = e.getAttribute("value");
+				//if(val is null)
+				//	throw new Exception("don't know what to do with radio boxes with null value");
+				if(val == value)
+					e.setAttribute("checked", "checked");
+				else
+					e.removeAttribute("checked");
+			}
+		}
+	}
+
+	/// Gets the value of the field; what would be given if it submitted right now. (so
+	/// it handles select boxes and radio buttons too). For checkboxes, if a value isn't
+	/// given, but it is checked, it returns "checked", since null and "" are indistinguishable
+	string getValue(string field) {
+		auto eles = getField(field);
+		if(eles.length == 0)
+			return "";
+		if(eles.length == 1) {
+			auto e = eles[0];
+			switch(e.tagName) {
+				default: assert(0);
+				case "input":
+					if(e.type == "checkbox") {
+						if(e.checked)
+							return e.value.length ? e.value : "checked";
+						return "";
+					} else
+						return e.value;
+				case "textarea":
+					return e.innerText;
+				case "select":
+					foreach(child; e.tree) {
+						if(child.tagName != "option")
+							continue;
+						if(child.selected)
+							return child.value;
+					}
+				break;
+			}
+		} else {
+			// assuming radio
+			foreach(e; eles) {
+				if(e.checked)
+					return e.value;
+			}
+		}
+
+		return "";
+	}
+
+	// FIXME: doesn't handle multiple elements with the same name (except radio buttons)
+	string getPostableData() {
+		bool[string] namesDone;
+
+		string ret;
+		bool outputted = false;
+
+		foreach(e; getElementsBySelector("[name]")) {
+			if(e.name in namesDone)
+				continue;
+
+			if(outputted)
+				ret ~= "&";
+			else
+				outputted = true;
+
+			ret ~= std.uri.encodeComponent(e.name) ~ "=" ~ std.uri.encodeComponent(getValue(e.name));
+
+			namesDone[e.name] = true;
+		}
+
+		return ret;
+	}
+
+	/// Gets the actual elements with the given name
+	Element[] getField(string name) {
+		Element[] ret;
+		foreach(e; tree) {
+			if(e.name == name)
+				ret ~= e;
+		}
+		return ret;
+	}
+
+	// Grabs the <label> with the given for tag, if there is one.
+	Element getLabel(string forId) {
+		foreach(e; tree)
+			if(e.tagName == "label" && e.getAttribute("for") == forId)
+				return e;
+		return null;
+	}
+
+	/// Adds a new INPUT field to the end of the form with the given attributes.
+	Element addField(string name, string value, string type = "hidden") {
+		auto e = new Element(parentDocument, "input", null, true);
+		e.name = name;
+		e.value = value;
+		e.type = type;
+
+		appendChild(e);
+
+		return e;
+	}
+
+	/// Removes the given field from the form. It finds the element and knocks it right out.
+	void removeField(string name) {
+		foreach(e; getField(name))
+			e.parentNode.removeChild(e);
+	}
+
+	/+
+	/// Returns all form members.
+	@property Element[] elements() {
+
+	}
+
+	string opDispatch(string name)(string v = null)
+		// filter things that should actually be attributes on the form
+		if( name != "method" && name != "action" && name != "enctype"
+		 && name != "style"  && name != "name" && name != "id" && name != "class")
+	{
+
+	}
+	+/
+/+
+	void submit() {
+		// take its elements and submit them through http
+	}
++/
+}
+
+import std.conv;
+
+class Table : Element {
+	this(Document _parentDocument) {
+		super(_parentDocument);
+		tagName = "table";
+	}
+
+	Element th(T)(T t) {
+		assert(parentDocument !is null);
+		Element e = parentDocument.createElement("th");
+		static if(is(T == Html))
+			e.innerHTML = t;
+		else
+			e.innerText = to!string(t);
+		return e;
+	}
+
+	Element td(T)(T t) {
+		assert(parentDocument !is null);
+		Element e = parentDocument.createElement("td");
+		static if(is(T == Html))
+			e.innerHTML = t;
+		else
+			e.innerText = to!string(t);
+		return e;
+	}
+
+	Element appendRow(T...)(T t) {
+		assert(parentDocument !is null);
+
+		Element row = parentDocument.createElement("tr");
+
+		foreach(e; t) {
+			static if(is(typeof(e) : Element)) {
+				if(e.tagName == "td" || e.tagName == "th")
+					row.appendChild(e);
+				else {
+					Element a = parentDocument.createElement("td");
+
+					a.appendChild(e);
+
+					row.appendChild(a);
+				}
+			} else static if(is(typeof(e) == Html)) {
+				Element a = parentDocument.createElement("td");
+				a.innerHTML = e.source;
+				row.appendChild(a);
+			} else {
+				Element a = parentDocument.createElement("td");
+				a.innerText = to!string(e);
+				row.appendChild(a);
+			}
+		}
+
+		foreach(e; children) {
+			if(e.tagName == "tbody") {
+				e.appendChild(row);
+				goto done;
+			}
+		}
+
+		appendChild(row);
+
+	    done:
+		return row;
+	}
+
+	Element captionElement() {
+		Element cap;
+		foreach(c; children) {
+			if(c.tagName == "caption") {
+				cap = c;
+				break;
+			}
+		}
+
+		if(cap is null) {
+			cap = parentDocument.createElement("caption");
+			appendChild(cap);
+		}
+
+		return cap;
+	}
+
+	@property string caption() {
+		return captionElement().innerText;
+	}
+
+	@property void caption(string text) {
+		captionElement().innerText = text;
+	}
+}
+
+
+class MarkupError : Exception {
+	this(string message) {
+		super(message);
+	}
+}
+
+class ElementNotFoundException : Exception {
+	this(string type, string search) {
+		super("Element of type '"~type~"' matching {"~search~"} not found.");
+	}
+}
+
+/// The html struct is used to differentiate between regular text nodes and html in certain functions
+struct Html {
+	string source;
+}
+
+class Document {
+	this(string data, bool caseSensitive = false, bool strict = false) {
+		parse(data, caseSensitive, strict);
+	}
+
+	/**
+		Creates an empty document. It has *nothing* in it at all.
+	*/
+	this() {
+
+	}
+
+	/**
+		Take XMLish* data and try to make the DOM tree out of it.
+
+		The goal isn't to be perfect, but to just be good enough to
+		approximate Javascript's behavior.
+
+		If strict, it throws on something that doesn't make sense.
+		(Examples: mismatched tags. It doesn't validate!)
+		If not strict, it tries to recover anyway, and only throws
+		when something is REALLY unworkable.
+
+		If strict is false, it uses a magic list of tags that needn't
+		be closed. If you are writing a document specifically for this,
+		try to avoid such - use self closed tags at least. Easier to parse.
+
+		* The xml version at the top really shouldn't be there...
+	*/
+	void parse(/*in */string data, bool caseSensitive = false, bool strict = false) {
+		// go through character by character.
+		// if you see a <, consider it a tag.
+		// name goes until the first non tagname character
+		// then see if it self closes or has an attribute
+
+		// if not in a tag, anything not a tag is a big text
+		// node child. It ends as soon as it sees a <
+
+		// Whitespace in text or attributes is preserved, but not between attributes
+
+		// &amp; and friends are converted when I know them, left the same otherwise
+
+		try {
+			validate(data); // it *must* be UTF-8 for this to work correctly
+		} catch (Throwable t) {
+			if(strict)
+			throw new MarkupError("This document is not UTF-8.");
+			else {
+				string newData;
+				foreach(char c; data)
+					if(c < 128)
+						newData ~= cast(char) c;
+				data = newData;
+			}
+		}
+
+		int pos = 0;
+
+		clear();
+
+		loose = !caseSensitive;
+
+		bool sawImproperNesting = false;
+
+		int getLineNumber(int p) {
+			int line = 1;
+			foreach(c; data[0..p])
+				if(c == '\n')
+					line++;
+			return line;
+		}
+
+		void parseError(string message) {
+			throw new MarkupError(format("char %d (line %d): %s", pos, getLineNumber(pos), message));
+		}
+
+		void eatWhitespace() {
+			while(pos < data.length && (data[pos] == ' ' || data[pos] == '\n' || data[pos] == '\t'))
+				pos++;
+		}
+
+		string readTagName() {
+			// remember to include : for namespaces
+			// basically just keep going until >, /, or whitespace
+			int start = pos;
+			while(  data[pos] != '>' && data[pos] != '/' &&
+				data[pos] != ' ' && data[pos] != '\n' && data[pos] != '\t')
+				pos++;
+
+			if(!caseSensitive)
+				return toLower(data[start..pos]);
+			else
+				return data[start..pos];
+		}
+
+		string readAttributeName() {
+			// remember to include : for namespaces
+			// basically just keep going until >, /, or whitespace
+			int start = pos;
+			while(  data[pos] != '>' && data[pos] != '/'  && data[pos] != '=' &&
+				data[pos] != ' ' && data[pos] != '\n' && data[pos] != '\t')
+				pos++;
+
+			if(!caseSensitive)
+				return toLower(data[start..pos]);
+			else
+				return data[start..pos];
+		}
+
+		string readAttributeValue() {
+			switch(data[pos]) {
+				case '\'':
+				case '"':
+					char end = data[pos];
+					pos++;
+					int start = pos;
+					while(data[pos] != end)
+						pos++;
+					string v = htmlEntitiesDecode(data[start..pos], strict);
+					pos++; // skip over the end
+					return v;
+				break;
+				default:
+					if(strict)
+						parseError("Attributes must be quoted");
+					// read until whitespace or terminator (/ or >)
+					int start = pos;
+					while(data[pos] != '>' && data[pos] != '/' &&
+					      data[pos] != ' ' && data[pos] != '\n' && data[pos] != '\t')
+					      	pos++;
+
+					string v = htmlEntitiesDecode(data[start..pos], strict);
+					// don't skip the end - we'll need it later
+					return v;
+			}
+		}
+
+		TextNode readTextNode() {
+			int start = pos;
+			while(pos < data.length && data[pos] != '<') {
+				pos++;
+			}
+
+			return TextNode.fromUndecodedString(this, data[start..pos]);
+		}
+
+		RawSource readCDataNode() {
+			int start = pos;
+			while(pos < data.length && data[pos] != '<') {
+				pos++;
+			}
+
+			return new RawSource(this, data[start..pos]);
+		}
+
+		char readEntity() {
+			return ' ';
+		}
+
+		string readComment() {
+			return "";
+		}
+
+		string readScript() {
+			return "";
+		}
+
+
+		struct Ele {
+			int type; // element or closing tag or nothing
+			Element element; // for type == 0
+			string payload; // for type == 1
+		}
+		// recursively read a tag
+		Ele readElement(string[] parentChain = null) {
+			if(!strict && parentChain is null)
+				parentChain = [];
+
+			if(pos >= data.length)
+				if(strict) {
+					throw new MarkupError("Gone over the input (is there no root element?), chain: " ~ to!string(parentChain));
+				} else {
+					if(parentChain.length)
+						return Ele(1, null, parentChain[0]); // in loose mode, we just assume the document has ended
+					else
+						return Ele(4); // signal emptiness upstream
+				}
+
+			if(data[pos] != '<') {
+				return Ele(0, readTextNode(), null);
+			}
+
+			enforce(data[pos] == '<');
+			pos++;
+			switch(data[pos]) {
+				// I don't care about these, so I just want to skip them
+				case '!': // might be a comment, a doctype, or a special instruction
+					pos++;
+					if(data[pos] == '-' && data[pos+1] == '-') {
+						// comment
+						pos += 2;
+						while(data[pos..pos+3] != "-->")
+							pos++;
+						assert(data[pos] == '-');
+						pos++;
+						assert(data[pos] == '-');
+						pos++;
+						assert(data[pos] == '>');
+					} else
+						while(data[pos] != '>')
+							pos++;
+					pos++; // skip the >
+				break;
+				case '?':
+					char end = data[pos];
+
+				    more:
+					pos++; // skip the start
+					while(data[pos] != end)
+						pos++;
+					pos++; // skip the end
+					if(data[pos] == '>')
+						pos++;
+					else
+						goto more;
+				break;
+				case '/': // closing an element
+					pos++; // skip the start
+					int p = pos;
+					while(data[pos] != '>')
+						pos++;
+					//writefln("</%s>", data[p..pos]);
+					pos++; // skip the '>'
+
+					string tname = data[p..pos-1];
+					if(!caseSensitive)
+						tname = tname.toLower;
+
+					return Ele(1, null, tname); // closing tag reports itself here
+				break;
+				case ' ': // assume it isn't a real element...
+					if(strict)
+						parseError("bad markup - improperly placed <");
+					else
+						return Ele(0, TextNode.fromUndecodedString(this, "<"), null);
+				break;
+				default:
+					string tagName = readTagName();
+					string[string] attributes;
+
+					Ele addTag(bool selfClosed) {
+						if(selfClosed)
+							pos++;
+						else {
+							if(!strict)
+								if(tagName.isInArray(selfClosedElements))
+									// these are de-facto self closed
+									selfClosed = true;
+						}
+
+						if(strict)
+						enforce(data[pos] == '>');//, format("got %s when expecting >\nContext:\n%s", data[pos], data[pos - 100 .. pos + 100]));
+						else {
+							// if we got here, it's probably because a slash was in an
+							// unquoted attribute - don't trust the selfClosed value
+							if(!selfClosed)
+								selfClosed = tagName.isInArray(selfClosedElements);
+
+							while(data[pos] != '>')
+								pos++;
+						}
+
+						int whereThisTagStarted = pos; // for better error messages
+
+						pos++;
+
+						auto e = createElement(tagName);
+						e.attributes = attributes;
+						e.selfClosed = selfClosed;
+						e.parseAttributes();
+
+
+						// HACK to handle script as a CDATA section 
+						if(tagName == "script" || tagName == "style") {
+							string closer = "</" ~ tagName ~ ">";
+							int ending = indexOf(data[pos..$], closer);
+							if(loose && ending == -1)
+								ending = indexOf(data[pos..$], closer.toUpper);
+							if(ending == -1)
+								throw new Exception("tag " ~ tagName ~ " never closed");
+							ending += pos;
+							e.innerRawSource = data[pos..ending];
+							pos = ending + closer.length;
+							return Ele(0, e, null);
+						}
+
+						bool closed = selfClosed;
+
+						//writef("<%s>", tagName);
+						while(!closed) {
+							Ele n;
+							if(strict)
+								n = readElement();
+							else
+								n = readElement(parentChain ~ tagName);
+
+							if(n.type == 4) return n; // the document is empty
+
+
+							if(n.type == 0) {
+								e.appendChild(n.element);
+							} else if(n.type == 1) {
+								bool found = false;
+								if(n.payload != tagName) {
+									if(strict)
+										parseError(format("mismatched tag: </%s> != <%s> (opened on line %d)", n.payload, tagName, getLineNumber(whereThisTagStarted)));
+									else {
+										sawImproperNesting = true;
+										// this is so we don't drop several levels of awful markup
+										if(n.element) {
+											e.appendChild(n.element);
+											n.element = null;
+										}
+
+										// is the element open somewhere up the chain?
+										foreach(parent; parentChain)
+											if(parent == n.payload) {
+												n.element = e;
+												return n;
+											}
+
+										// if not, this is a text node; we can't fix it up...
+
+										// If it's already in the tree somewhere, assume it is closed by algorithm
+										// and we shouldn't output it - odds are the user just flipped a couple tags
+										foreach(ele; e.tree) {
+											if(ele.tagName == n.payload) {
+												found = true;
+												break;
+											}
+										}
+
+										if(!found) // if not found in the tree though, it's probably just text
+										e.appendChild(TextNode.fromUndecodedString(this, "</"~n.payload~">"));
+									}
+								} else {
+									if(n.element)
+										e.appendChild(n.element);
+								}
+
+								if(n.payload == tagName) // in strict mode, this is always true
+									closed = true;
+							} else { /*throw new Exception("wtf " ~ tagName);*/ }
+						}
+						//writef("</%s>\n", tagName);
+						return Ele(0, e, null);
+					}
+
+					switch(data[pos]) {
+						default: assert(0);
+						case '/': // self closing tag
+							return addTag(true);
+						break;
+						case '>':
+							return addTag(false);
+						break;
+						case ' ':
+						case '\t':
+						case '\n':
+							// there might be attributes...
+							moreAttributes:
+							eatWhitespace();
+
+							switch(data[pos]) {
+								case '/': // self closing tag
+									return addTag(true);
+								break;
+								case '>': // closed tag; open -- we now read the contents
+
+										return addTag(false);
+								break;
+								default: // it is an attribute
+									string attrName = readAttributeName();
+									string attrValue = attrName;
+									if(data[pos] == '=') {
+										pos++;
+										attrValue = readAttributeValue();
+									}
+
+									attributes[attrName] = attrValue;
+
+									goto moreAttributes;
+							}
+					}
+			}
+
+			return Ele(2, null, null); // this is a <! or <? thing prolly.
+			//assert(0);
+		}
+
+		eatWhitespace();
+		Ele r;
+		do {
+			r = readElement; // there SHOULD only be one element...
+			if(r.type == 4)
+				break; // the document is completely empty...
+		} while (r.type != 0 || r.element.nodeType != 1); // we look past the xml prologue and doctype
+
+		root = r.element;
+
+		if(root is null)
+			if(strict)
+				assert(0, "empty document should be impossible in strict mode");
+			else
+				parse(`<html><head></head><body></body></html>`); // fill in a dummy document in loose mode since that's what browsers do
+
+		if(0&&sawImproperNesting) {
+			// in loose mode, we can see some bad nesting. It's hard to fix above though
+			// because my code sucks. So, we'll fix it here.
+
+			fixing_p_again:
+			foreach(ele; root.getElementsBySelector("p > p")) {
+				auto holder = ele.parentNode.parentNode;
+				auto h2 = ele.parentNode;
+
+				if(holder is null || h2 is null)
+					continue;
+
+				ele = ele.parentNode.removeChild(ele);
+
+				holder.insertAfter(h2, ele);
+
+				goto fixing_p_again;
+			}
+
+		}
+	}
+
+	/* end massive parse function */
+
+	@property string title() {
+		bool doesItMatch(Element e) {
+			return (e.tagName == "title");
+		}
+
+		auto e = findFirst(&doesItMatch);
+		if(e)
+			return e.innerText();
+		return "";
+	}
+
+	@property void title(string t) {
+		bool doesItMatch(Element e) {
+			return (e.tagName == "title");
+		}
+
+		auto e = findFirst(&doesItMatch);
+
+		if(!e) {
+			e = createElement("title");
+			auto heads = getElementsByTagName("head");
+			if(heads.length)
+				heads[0].appendChild(e);
+		}
+
+		if(e)
+			e.innerText = t;
+	}
+
+	// FIXME: would it work to alias root this; ???? might be a good idea
+
+	Element getElementById(string id) {
+		return root.getElementById(id);
+	}
+
+	final SomeElementType requireElementById(SomeElementType = Element)(string id)
+		if( is(SomeElementType : Element))
+		out(ret) { assert(ret !is null); }
+	body {
+		return root.requireElementById!(SomeElementType)(id);
+	}
+
+	final SomeElementType requireSelector(SomeElementType = Element)(string selector)
+		if( is(SomeElementType : Element))
+		out(ret) { assert(ret !is null); }
+	body {
+		return root.requireSelector!(SomeElementType)(selector);
+	}
+
+
+	Element querySelector(string selector) {
+		return root.querySelector(selector);
+	}
+
+	Element[] querySelectorAll(string selector) {
+		return root.querySelectorAll(selector);
+	}
+
+	Element[] getElementsBySelector(string selector) {
+		return root.getElementsBySelector(selector);
+	}
+
+	Element[] getElementsByTagName(string tag) {
+		return root.getElementsByTagName(tag);
+	}
+
+	/** Extension: FIXME: btw, this could just be a lazy range...... */
+	Element getFirstElementByTagName(string tag) {
+		if(loose)
+			tag = tag.toLower();
+		bool doesItMatch(Element e) {
+			return e.tagName == tag;
+		}
+		return findFirst(&doesItMatch);
+	}
+
+	Element mainBody() {
+		return getFirstElementByTagName("body");
+	}
+
+	// this uses a weird thing... it's [name=] if no colon and
+	// [property=] if colon
+	string getMeta(string name) {
+		string thing = name.indexOf(":") == -1 ? "name" : "property";
+		auto e = querySelector("head meta["~thing~"="~name~"]");
+		if(e is null)
+			return null;
+		return e.content;
+	}
+	
+	void setMeta(string name, string value) {
+		string thing = name.indexOf(":") == -1 ? "name" : "property";
+		auto e = querySelector("head meta["~thing~"="~name~"]");
+		if(e is null) {
+			e = requireSelector("head").addChild("meta");
+			e.setAttribute(thing, name);
+		}
+
+		e.content = value;
+	}
+
+	Form[] forms() {
+		return cast(Form[]) getElementsByTagName("form");
+	}
+
+	Form createForm() 
+		out(ret) {
+			assert(ret !is null);
+		}
+	body {
+		return cast(Form) createElement("form");
+	}
+
+	Element createElement(string name) {
+		if(loose)
+			name = name.toLower();
+
+		bool selfClosed = name.isInArray(selfClosedElements);
+
+		Element e;
+		switch(name) {
+			case "table":
+				e = new Table(this);
+			break;
+			case "a":
+				e = new Link(this);
+			break;
+			case "form":
+				e = new Form(this);
+			break;
+			default:
+				return new Element(this, name, null, selfClosed);
+		}
+
+		// make sure all the stuff is constructed properly FIXME: should probably be in all the right constructors too
+		e.tagName = name;
+		e.selfClosed = selfClosed;
+		e.parentDocument = this;
+
+		return e;
+
+//		return new Element(this, name, null, selfClosed);
+	}
+
+	Element createFragment() {
+		return new DocumentFragment(this);
+	}
+
+	Element createTextNode(string content) {
+		return new TextNode(this, content);
+	}
+
+
+	// ******** Begin extensions ******** //
+	Element findFirst(bool delegate(Element) doesItMatch) {
+		Element result;
+
+		bool goThroughElement(Element e) {
+			if(doesItMatch(e)) {
+				result = e;
+				return true;
+			}
+
+			foreach(child; e.children) {
+				if(goThroughElement(child))
+					return true;
+			}
+
+			return false;
+		}
+
+		goThroughElement(root);
+
+		return result;
+	}
+
+	void clear() {
+		root = null;
+		loose = false;
+	}
+
+	void setProlog(string d) {
+		prolog = d;
+	}
+
+	string prolog = "<!DOCTYPE html>\n";
+
+	string toString() const {
+		return prolog ~ root.toString();
+	}
+
+	Element root;
+	bool loose;
+
+}
+
+	private static string[] selfClosedElements = [ "img", "hr", "input", "br", "col", "link", "meta" ];
+
+static import std.conv;
+
+int intFromHex(string hex) {
+	int place = 1;
+	int value = 0;
+	for(int a = hex.length - 1; a >= 0; a--) {
+		int v;
+		char q = hex[a];
+		if( q >= '0' && q <= '9')
+			v = q - '0';
+		else if (q >= 'a' && q <= 'f')
+			v = q - 'a' + 10;
+		else throw new Exception("Illegal hex character: " ~ q);
+
+		value += v * place;
+
+		place *= 16;
+	}
+
+	return value;
+}
+
+
+// CSS selector handling
+
+// EXTENSIONS
+// dd - dt means get the dt directly before that dd (opposite of +)                  NOT IMPLEMENTED
+// dd -- dt means rewind siblings until you hit a dt, go as far as you need to       NOT IMPLEMENTED
+// dt < dl means get the parent of that dt iff it is a dl (usable for "get a dt that are direct children of dl")
+// dt << dl  means go as far up as needed to find a dl (you have an element and want its containers)      NOT IMPLEMENTED
+// :first  means to stop at the first hit, don't do more (so p + p == p ~ p:first
+
+		static immutable string[] selectorTokens = [
+			// It is important that the 2 character possibilities go first here for accurate lexing
+		    "~=", "*=", "|=", "^=", "$=", "!=", // "::" should be there too for full standard
+		    "<<", // my any-parent extension (reciprocal of whitespace)
+		    " - ", // previous-sibling extension (whitespace required to disambiguate tag-names)
+		    ".", ">", "+", "*", ":", "[", "]", "=", "\"", "#", ",", " ", "~", "<"
+		]; // other is white space or a name.
+
+		int idToken(string str, int position) {
+			int tid = -1;
+			char c = str[position];
+			foreach(a, token; selectorTokens)
+				if(c == token[0]) {
+					if(token.length > 1) {
+						if(position + 1 >= str.length   ||   str[position+1] != token[1])
+							continue; // not this token
+					}
+					tid = a;
+					break;
+				}
+			return tid;
+		}
+	string[] lexSelector(string selector) {
+
+		// FIXME: it doesn't support quoted attributes
+		// FIXME: it doesn't support backslash escaped characters
+		// FIXME: it should ignore /* comments */
+		string[] tokens;
+		int start = -1;
+		bool skip = false;
+		// get rid of useless, non-syntax whitespace
+
+		selector = selector.strip;
+		selector = selector.replace("\n", " "); // FIXME hack
+
+		selector = selector.replace(" >", ">");
+		selector = selector.replace("> ", ">");
+		selector = selector.replace(" +", "+");
+		selector = selector.replace("+ ", "+");
+		selector = selector.replace(" ~", "~");
+		selector = selector.replace("~ ", "~");
+		selector = selector.replace(" <", "<");
+		selector = selector.replace("< ", "<");
+			// FIXME: this is ugly ^^^^^. It should just ignore that whitespace somewhere else.
+
+		foreach(i, c; selector) { // kill useless leading/trailing whitespace too
+			if(skip) {
+				skip = false;
+				continue;
+			}
+
+			int tid = idToken(selector, i);
+
+			if(tid == -1) {
+				if(start == -1)
+					start = i;
+			} else {
+				if(start != -1) {
+					tokens ~= selector[start..i];
+					start = -1;
+				}
+				tokens ~= selectorTokens[tid];
+			}
+
+			if (tid != -1 && selectorTokens[tid].length == 2)
+				skip = true;
+		}
+		if(start != -1)
+			tokens ~= selector[start..$];
+
+		return tokens;
+	}
+
+	struct SelectorPart {
+		string tagNameFilter;
+		string[] attributesPresent; // [attr]
+		string[2][] attributesEqual; // [attr=value]
+		string[2][] attributesStartsWith; // [attr^=value]
+		string[2][] attributesEndsWith; // [attr$=value]
+		// split it on space, then match to these
+		string[2][] attributesIncludesSeparatedBySpaces; // [attr~=value]
+		// split it on dash, then match to these
+		string[2][] attributesIncludesSeparatedByDashes; // [attr|=value]
+		string[2][] attributesInclude; // [attr*=value]
+		string[2][] attributesNotEqual; // [attr!=value] -- extension by me
+
+		bool firstChild;
+		bool lastChild;
+
+		bool emptyElement;
+		bool oddChild;
+		bool evenChild;
+
+		bool rootElement;
+
+		int separation = -1; // -1 == only itself; the null selector, 0 == tree, 1 == childNodes, 2 == childAfter, 3 == youngerSibling, 4 == parentOf
+
+		string toString() {
+			string ret;
+			switch(separation) {
+				default: assert(0);
+				case -1: break;
+				case 0: ret ~= " "; break;
+				case 1: ret ~= ">"; break;
+				case 2: ret ~= "+"; break;
+				case 3: ret ~= "~"; break;
+				case 4: ret ~= "<"; break;
+			}
+			ret ~= tagNameFilter;
+			foreach(a; attributesPresent) ret ~= "[" ~ a ~ "]";
+			foreach(a; attributesEqual) ret ~= "[" ~ a[0] ~ "=" ~ a[1] ~ "]";
+			foreach(a; attributesEndsWith) ret ~= "[" ~ a[0] ~ "$=" ~ a[1] ~ "]";
+			foreach(a; attributesStartsWith) ret ~= "[" ~ a[0] ~ "^=" ~ a[1] ~ "]";
+			foreach(a; attributesNotEqual) ret ~= "[" ~ a[0] ~ "!=" ~ a[1] ~ "]";
+			foreach(a; attributesInclude) ret ~= "[" ~ a[0] ~ "*=" ~ a[1] ~ "]";
+			foreach(a; attributesIncludesSeparatedByDashes) ret ~= "[" ~ a[0] ~ "|=" ~ a[1] ~ "]";
+			foreach(a; attributesIncludesSeparatedBySpaces) ret ~= "[" ~ a[0] ~ "~=" ~ a[1] ~ "]";
+
+			if(firstChild) ret ~= ":first-child";
+			if(lastChild) ret ~= ":last-child";
+			if(emptyElement) ret ~= ":empty";
+			if(oddChild) ret ~= ":odd-child";
+			if(evenChild) ret ~= ":even-child";
+			if(rootElement) ret ~= ":root";
+
+			return ret;
+		}
+
+		// USEFUL
+		bool matchElement(Element e) {
+			if(e is null) return false;
+			if(e.nodeType != 1) return false;
+
+			if(tagNameFilter != "" && tagNameFilter != "*")
+				if(e.tagName != tagNameFilter)
+					return false;
+			if(firstChild) {
+				if(e.parentNode is null)
+					return false;
+				if(e.parentNode.childElements[0] !is e)
+					return false;
+			}
+			if(lastChild) {
+				if(e.parentNode is null)
+					return false;
+				auto ce = e.parentNode.childElements;
+				if(ce[$-1] !is e)
+					return false;
+			}
+			if(emptyElement) {
+				if(e.children.length)
+					return false;
+			}
+			if(rootElement) {
+				if(e.parentNode !is null)
+					return false;
+			}
+			if(oddChild || evenChild) {
+				if(e.parentNode is null)
+					return false;
+				foreach(i, child; e.parentNode.childElements) {
+					if(child is e) {
+						if(oddChild && !(i&1))
+							return false;
+						if(evenChild && (i&1))
+							return false;
+						break;
+					}
+				}
+			}
+
+			bool matchWithSeparator(string attr, string value, string separator) {
+				foreach(s; attr.split(separator))
+					if(s == value)
+						return true;
+				return false;
+			}
+
+			foreach(a; attributesPresent)
+				if(a !in e.attributes)
+					return false;
+			foreach(a; attributesEqual)
+				if(a[0] !in e.attributes || e.attributes[a[0]] != a[1])
+					return false;
+			foreach(a; attributesNotEqual)
+				if(a[0] !in e.attributes || e.attributes[a[0]] == a[1])
+					return false;
+			foreach(a; attributesInclude)
+				if(a[0] !in e.attributes || (e.attributes[a[0]].indexOf(a[1]) == -1))
+					return false;
+			foreach(a; attributesStartsWith)
+				if(a[0] !in e.attributes || !e.attributes[a[0]].startsWith(a[1]))
+					return false;
+			foreach(a; attributesEndsWith)
+				if(a[0] !in e.attributes || !e.attributes[a[0]].endsWith(a[1]))
+					return false;
+			foreach(a; attributesIncludesSeparatedBySpaces)
+				if(a[0] !in e.attributes || !matchWithSeparator(e.attributes[a[0]], a[1], " "))
+					return false;
+			foreach(a; attributesIncludesSeparatedByDashes)
+				if(a[0] !in e.attributes || !matchWithSeparator(e.attributes[a[0]], a[1], "-"))
+					return false;
+
+			return true;
+		}
+	}
+
+	// USEFUL
+	Element[] getElementsBySelectorParts(Element start, SelectorPart[] parts) {
+		Element[] ret;
+		if(!parts.length) {
+			return [start]; // the null selector only matches the start point; it
+				// is what terminates the recursion
+		}
+
+		auto part = parts[0];
+		switch(part.separation) {
+			default: assert(0);
+			case -1:
+			case 0: // tree
+				foreach(e; start.tree) {
+					if(part.separation == 0 && start is e)
+						continue; // space doesn't match itself!
+					if(part.matchElement(e)) {
+						ret ~= getElementsBySelectorParts(e, parts[1..$]);
+					}
+				}
+			break;
+			case 1: // children
+				foreach(e; start.childNodes) {
+					if(part.matchElement(e)) {
+						ret ~= getElementsBySelectorParts(e, parts[1..$]);
+					}
+				}
+			break;
+			case 2: // next-sibling
+				auto tmp = start.parentNode;
+				if(tmp !is null) {
+					int pos = -1;
+					auto children = tmp.childElements;
+					foreach(i, child; children) {
+						if(child is start) {
+							pos = i;
+							break;
+						}
+					}
+					assert(pos != -1);
+					if(pos + 1 < children.length) {
+						auto e = children[pos+1];
+						if(part.matchElement(e))
+							ret ~= getElementsBySelectorParts(e, parts[1..$]);
+					}
+				}
+			break;
+			case 3: // younger sibling
+				auto tmp = start.parentNode;
+				if(tmp !is null) {
+					int pos = -1;
+					auto children = tmp.childElements;
+					foreach(i, child; children) {
+						if(child is start) {
+							pos = i;
+							break;
+						}
+					}
+					assert(pos != -1);
+					foreach(e; children[pos+1..$]) {
+						if(part.matchElement(e))
+							ret ~= getElementsBySelectorParts(e, parts[1..$]);
+					}
+				}
+			break;
+			case 4: // immediate parent node, an extension of mine to walk back up the tree
+				auto e = start.parentNode;
+				if(part.matchElement(e)) {
+					ret ~= getElementsBySelectorParts(e, parts[1..$]);
+				}
+				/*
+					Example of usefulness:
+
+					Consider you have an HTML table. If you want to get all rows that have a th, you can do:
+
+					table th < tr
+
+					Get all th descendants of the table, then walk back up the tree to fetch their parent tr nodes
+				*/
+			break;
+			case 5: // any parent note, another extension of mine to go up the tree (backward of the whitespace operator)
+				/*
+					Like with the < operator, this is best used to find some parent of a particular known element.
+
+					Say you have an anchor inside a 
+				*/
+		}
+
+		return ret;
+	}
+
+	struct Selector {
+		SelectorPart[] parts;
+
+		string toString() {
+			string ret;
+			foreach(part; parts)
+				ret ~= part.toString();
+			return ret;
+		}
+
+		// USEFUL
+		Element[] getElements(Element start) {
+			return removeDuplicates(getElementsBySelectorParts(start, parts));
+		}
+
+		// USEFUL (but not implemented)
+		/// If relativeTo == null, it assumes the root of the parent document.
+		bool matchElement(Element e, Element relativeTo = null) {
+			// FIXME
+			/+
+			Element where = e;
+			foreach(part; retro(parts)) {
+				if(where is relativeTo)
+					return false; // at end of line, if we aren't done by now, the match fails
+				if(!part.matchElement(where))
+					return false; // didn't match
+
+				if(part.selection == 1) // the > operator
+					where = where.parentNode;
+				else if(part.selection == 0) { // generic parent
+					// need to go up the whole chain
+				}
+			}
+			+/
+			return true; // if we got here, it is a success
+		}
+
+		// the string should NOT have commas. Use parseSelectorString for that instead
+		static Selector fromString(string selector) {
+			return parseSelector(lexSelector(selector));
+		}
+	}
+
+	Selector[] parseSelectorString(string selector) {
+		Selector[] ret;
+		foreach(s; selector.split(",")) {
+			ret ~= parseSelector(lexSelector(s));
+		}
+
+		return ret;
+	}
+
+	Selector parseSelector(string[] tokens) {
+		Selector s;
+
+		SelectorPart current;
+		void commit() {
+			// might as well skip null items
+			if(current != current.init) {
+				s.parts ~= current;
+
+				current = current.init; // start right over
+			}
+		}
+		enum State {
+			Starting,
+			ReadingClass,
+			ReadingId,
+			ReadingAttributeSelector,
+			ReadingAttributeComparison,
+			ExpectingAttributeCloser,
+			ReadingPseudoClass,
+			ReadingAttributeValue
+		}
+		State state = State.Starting;
+		string attributeName, attributeValue, attributeComparison;
+		foreach(token; tokens) {
+			int tid = -1;
+			foreach(i, item; selectorTokens)
+				if(token == item) {
+					tid = i;
+					break;
+				}
+			final switch(state) {
+				case State.Starting: // fresh, might be reading an operator or a tagname
+					if(tid == -1) {
+						current.tagNameFilter = token;
+					} else {
+						// Selector operators
+						switch(token) {
+							case "*":
+								current.tagNameFilter = "*";
+							break;
+							case " ":
+								commit();
+								current.separation = 0; // tree
+							break;
+							case ">":
+								commit();
+								current.separation = 1; // child
+							break;
+							case "+":
+								commit();
+								current.separation = 2; // sibling directly after
+							break;
+							case "~":
+								commit();
+								current.separation = 3; // any sibling after
+							break;
+							case "<":
+								commit();
+								current.separation = 4; // immediate parent of
+							break;
+							case "[":
+								state = State.ReadingAttributeSelector;
+							break;
+							case ".":
+								state = State.ReadingClass;
+							break;
+							case "#":
+								state = State.ReadingId;
+							break;
+							case ":":
+								state = State.ReadingPseudoClass;
+							break;
+
+							default:
+								assert(0, token);
+						}
+					}
+				break;
+				case State.ReadingClass:
+					current.attributesIncludesSeparatedBySpaces ~= ["class", token];
+					state = State.Starting;
+				break;
+				case State.ReadingId:
+					current.attributesEqual ~= ["id", token];
+					state = State.Starting;
+				break;
+				case State.ReadingPseudoClass:
+					switch(token) {
+						case "first-child":
+							current.firstChild = true;
+						break;
+						case "last-child":
+							current.lastChild = true;
+						break;
+						case "only-child":
+							current.firstChild = true;
+							current.lastChild = true;
+						break;
+						case "empty":
+							// one with no children
+							current.emptyElement = true;
+						break;
+						case "link":
+							current.attributesPresent ~= "href";
+						break;
+						case "root":
+							current.rootElement = true;
+						break;
+						// My extensions
+						case "odd-child":
+							current.oddChild = true;
+						break;
+						case "even-child":
+							current.evenChild = true;
+						break;
+
+						case "visited":
+						case "active":
+						case "hover":
+						case "target":
+						case "focus":
+						case "checked":
+						case "selected":
+							current.attributesPresent ~= "nothing";
+							// FIXME
+						/*
+						// defined in the standard, but I don't implement it
+						case "not":
+						*/
+						/+
+						// extensions not implemented
+						//case "text": // takes the text in the element and wraps it in an element, returning it
+						+/
+
+						case "before":
+						case "after":
+							current.attributesPresent ~= "FIXME";
+
+						break;
+						default:
+							//if(token.indexOf("lang") == -1)
+							//assert(0, token);
+					}
+					state = State.Starting;
+				break;
+				case State.ReadingAttributeSelector:
+					attributeName = token;
+					attributeComparison = null;
+					attributeValue = null;
+					state = State.ReadingAttributeComparison;
+				break;
+				case State.ReadingAttributeComparison:
+					if(token != "]") {
+						if(token.indexOf("=") == -1) {
+							// not a comparison; consider it
+							// part of the attribute
+							attributeValue ~= token;
+						} else {
+							attributeComparison = token;
+							state = State.ReadingAttributeValue;
+						}
+						break;
+					}
+				// fallthrough
+				case State.ExpectingAttributeCloser:
+					if(token != "]") {
+						// not the closer; consider it part of comparison
+						if(attributeComparison == "")
+							attributeName ~= token;
+						else
+							attributeValue ~= token;
+						break;
+					}
+
+					// Selector operators
+					switch(attributeComparison) {
+						default: assert(0);
+						case "":
+							current.attributesPresent ~= attributeName;
+						break;
+						case "=":
+							current.attributesEqual ~= [attributeName, attributeValue];
+						break;
+						case "|=":
+							current.attributesIncludesSeparatedByDashes ~= [attributeName, attributeValue];
+						break;
+						case "~=":
+							current.attributesIncludesSeparatedBySpaces ~= [attributeName, attributeValue];
+						break;
+						case "$=":
+							current.attributesEndsWith ~= [attributeName, attributeValue];
+						break;
+						case "^=":
+							current.attributesStartsWith ~= [attributeName, attributeValue];
+						break;
+						case "*=":
+							current.attributesInclude ~= [attributeName, attributeValue];
+						break;
+						case "!=":
+							current.attributesNotEqual ~= [attributeName, attributeValue];
+						break;
+					}
+
+					state = State.Starting;
+				break;
+				case State.ReadingAttributeValue:
+					attributeValue = token;
+					state = State.ExpectingAttributeCloser;
+				break;
+			}
+		}
+
+		commit;
+
+		return s;
+	}
+
+Element[] removeDuplicates(Element[] input) {
+	Element[] ret;
+
+	bool[Element] already;
+	foreach(e; input) {
+		if(e in already) continue;
+		already[e] = true;
+		ret ~= e;
+	}
+
+	return ret;
+}
+
+// done with CSS selector handling
+
+
+
+string unCamelCase(string a) {
+	string ret;
+	foreach(c; a)
+		if((c >= 'A' && c <= 'Z'))
+			ret ~= "-" ~ toLower("" ~ c)[0];
+		else
+			ret ~= c;
+	return ret;
+}
+
+string camelCase(string a) {
+	string ret;
+	bool justSawDash = false;
+	foreach(c; a)
+		if(c == '-') {
+			justSawDash = true;
+		} else {
+			if(justSawDash) {
+				justSawDash = false;
+				ret ~= toUpper("" ~ c);
+			} else
+				ret ~= c;
+		}
+	return ret;
+}
+
+class CssStyle {
+	this(string rule, string content) {
+		rule = rule.strip;
+		content = content.strip;
+
+		if(content.length == 0)
+			return;
+
+		originatingRule = rule;
+		originatingSpecificity = getSpecificityOfRule(rule); // FIXME: if there's commas, this won't actually work!
+
+		foreach(part; content.split(";")) {
+			part = part.strip;
+			if(part.length == 0)
+				continue;
+			auto idx = part.indexOf(":");
+			if(idx == -1)
+				continue;
+				//throw new Exception("Bad css rule (no colon): " ~ part);
+
+			Property p;
+
+			p.name = part[0 .. idx].strip;
+			p.value = part[idx + 1 .. $].replace("! important", "!important").replace("!important", "").strip; // FIXME don't drop important
+			p.givenExplicitly = true;
+			p.specificity = originatingSpecificity;
+
+			properties ~= p;
+		}
+
+		foreach(property; properties)
+			expandShortForm(property, originatingSpecificity);
+	}
+
+	Specificity getSpecificityOfRule(string rule) {
+		Specificity s;
+		if(rule.length == 0) { // inline
+		//	s.important = 2;
+		} else {
+			// FIXME
+		}
+
+		return s;
+	}
+
+	string originatingRule;
+	Specificity originatingSpecificity;
+
+	union Specificity {
+		uint score;
+		// version(little_endian)
+		struct {
+			ubyte tags;
+			ubyte classes;
+			ubyte ids;
+			ubyte important; // 0 = none, 1 = stylesheet author, 2 = inline style, 3 = user important
+		}
+	}
+
+	struct Property {
+		bool givenExplicitly; // this is false if for example the user said "padding" and this is "padding-left"
+		string name;
+		string value;
+		Specificity specificity;
+		// do we care about the original source rule?
+	}
+
+	Property[] properties;
+
+	string opDispatch(string nameGiven)(string value = null) if(nameGiven != "popFront") {
+		string name = unCamelCase(nameGiven);
+		if(value is null)
+			return getValue(name);
+		else
+			return setValue(name, value, 0x02000000 /* inline specificity */);
+	}
+
+	// takes dash style name
+	string getValue(string name) {
+		foreach(property; properties)
+			if(property.name == name)
+				return property.value;
+		return null;
+	}
+
+	// takes dash style name
+	string setValue(string name, string value, Specificity newSpecificity, bool explicit = true) {
+		value = value.replace("! important", "!important");
+		if(value.indexOf("!important") != -1) {
+			newSpecificity.important = 1; // FIXME
+			value = value.replace("!important", "").strip;
+		}
+
+		foreach(ref property; properties)
+			if(property.name == name) {
+				if(newSpecificity.score >= property.specificity.score) {
+					property.givenExplicitly = explicit;
+					expandShortForm(property, newSpecificity);
+					return (property.value = value);
+				} else {
+					if(name == "display")
+					writeln("Not setting ", name, " to ", value, " because ", newSpecificity.score, " < ", property.specificity.score);
+					return value; // do nothing - the specificity is too low
+				}
+			}
+
+		// it's not here...
+
+		Property p;
+		p.givenExplicitly = true;
+		p.name = name;
+		p.value = value;
+		p.specificity = originatingSpecificity;
+
+		properties ~= p;
+		expandShortForm(p, originatingSpecificity);
+
+		return value;
+	}
+
+	private void expandQuadShort(string name, string value, Specificity specificity) {
+		auto parts = value.split(" ");
+		switch(parts.length) {
+			case 1:
+				setValue(name ~"-left", parts[0], specificity, false);
+				setValue(name ~"-right", parts[0], specificity, false);
+				setValue(name ~"-top", parts[0], specificity, false);
+				setValue(name ~"-bottom", parts[0], specificity, false);
+			break;
+			case 2:
+				setValue(name ~"-left", parts[1], specificity, false);
+				setValue(name ~"-right", parts[1], specificity, false);
+				setValue(name ~"-top", parts[0], specificity, false);
+				setValue(name ~"-bottom", parts[0], specificity, false);
+			break;
+			case 3:
+				setValue(name ~"-top", parts[0], specificity, false);
+				setValue(name ~"-right", parts[1], specificity, false);
+				setValue(name ~"-bottom", parts[2], specificity, false);
+				setValue(name ~"-left", parts[2], specificity, false);
+
+			break;
+			case 4:
+				setValue(name ~"-top", parts[0], specificity, false);
+				setValue(name ~"-right", parts[1], specificity, false);
+				setValue(name ~"-bottom", parts[2], specificity, false);
+				setValue(name ~"-left", parts[3], specificity, false);
+			break;
+			default:
+				assert(0, value);
+		}
+	}
+
+	void expandShortForm(Property p, Specificity specificity) {
+		switch(p.name) {
+			case "margin":
+			case "padding":
+				expandQuadShort(p.name, p.value, specificity);
+			break;
+			case "border":
+			case "outline":
+				setValue(p.name ~ "-left", p.value, specificity, false);
+				setValue(p.name ~ "-right", p.value, specificity, false);
+				setValue(p.name ~ "-top", p.value, specificity, false);
+				setValue(p.name ~ "-bottom", p.value, specificity, false);
+			break;
+
+			case "border-top":
+			case "border-bottom":
+			case "border-left":
+			case "border-right":
+			case "outline-top":
+			case "outline-bottom":
+			case "outline-left":
+			case "outline-right":
+
+			default: ;
+		}
+	}
+
+	string toString() {
+		string ret;
+		if(originatingRule.length)
+			ret = originatingRule ~ " {";
+
+		foreach(property; properties) {
+			if(!property.givenExplicitly)
+				continue; // skip the inferred shit
+
+			if(originatingRule.length)
+				ret ~= "\n\t";
+			else
+				ret ~= " ";
+
+			ret ~= property.name ~ ": " ~ property.value ~ ";";
+		}
+
+		if(originatingRule.length)
+			ret ~= "\n}\n";
+
+		return ret;
+	}
+}
+
+class StyleSheet {
+	CssStyle[] rules;
+
+	this(string source) {
+		// FIXME: handle @ rules and probably could improve lexer
+		// add nesting?
+		int state;
+		string currentRule;
+		string currentValue;
+
+		string* currentThing = &currentRule;
+		foreach(c; source) {
+			handle: switch(state) {
+				default: assert(0);
+				case 0: // starting - we assume we're reading a rule
+					switch(c) {
+						case '@':
+							state = 4;
+						break;
+						case '/':
+							state = 1;
+						break;
+						case '{':
+							currentThing = &currentValue;
+						break;
+						case '}':
+							if(currentThing is &currentValue) {
+								rules ~= new CssStyle(currentRule, currentValue);
+
+								currentRule = "";
+								currentValue = "";
+
+								currentThing = &currentRule;
+							} else {
+								// idk what is going on here.
+								// check sveit.com to reproduce
+								currentRule = "";
+								currentValue = "";
+							}
+						break;
+						default:
+							(*currentThing) ~= c;
+					}
+				break;
+				case 1: // expecting *
+					if(c == '*')
+						state = 2;
+					else {
+						state = 0;
+						(*currentThing) ~= "/" ~ c;
+					}
+				break;
+				case 2: // inside comment
+					if(c == '*')
+						state = 3;
+				break;
+				case 3: // expecting / to end comment
+					if(c == '/')
+						state = 0;
+					else
+						state = 2; // it's just a comment so no need to append
+				break;
+				case 4:
+					if(c == '{')
+						state = 5;
+					if(c == ';')
+						state = 0; // just skipping import
+				break;
+				case 5:
+					if(c == '}')
+						state = 0; // skipping font face probably
+			}
+		}
+	}
+
+	void apply(Document document) {
+		foreach(rule; rules) {
+			if(rule.originatingRule.length == 0)
+				continue; // this shouldn't happen here in a stylesheet
+			foreach(element; document.querySelectorAll(rule.originatingRule)) {
+				// note: this should be a different object than the inline style
+				// since givenExplicitly is likely destroyed here
+				auto current = element.computedStyle;
+
+				foreach(item; rule.properties)
+					current.setValue(item.name, item.value, item.specificity);
+			}
+		}
+	}
+}
+
+
+/*
+Copyright: Adam D. Ruppe, 2010 - 2011
+License:   <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
+Authors: Adam D. Ruppe
+
+        Copyright Adam D. Ruppe 2010-2011.
+Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+        http://www.boost.org/LICENSE_1_0.txt)
+*/
diff --git a/simpledisplay.d b/simpledisplay.d
deleted file mode 120000
index e93495b..0000000
--- a/simpledisplay.d
+++ /dev/null
@@ -1 +0,0 @@
-../../dimage/simpledisplay.d
\ No newline at end of file
diff --git a/simpledisplay.d b/simpledisplay.d
new file mode 100644
index 0000000..8b62e54
--- /dev/null
+++ b/simpledisplay.d
@@ -0,0 +1,2227 @@
+module simpledisplay;
+/*
+	Stuff to add:
+
+	Pens and brushes?
+	Maybe a global event loop?
+
+	Mouse deltas
+	Key items
+*/
+
+version(linux)
+	version = X11;
+version(OSX)
+	version = X11;
+version(FreeBSD)
+	version = X11;
+version(Solaris)
+	version = X11;
+
+import std.exception;
+import core.thread;
+import std.string; // FIXME: move to drawText X11 on next dmd
+
+import std.stdio;
+
+
+struct Color {
+	ubyte r;
+	ubyte g;
+	ubyte b;
+	ubyte a;
+
+	this(int red, int green, int blue, int alpha = 255) {
+		this.r = cast(ubyte) red;
+		this.g = cast(ubyte) green;
+		this.b = cast(ubyte) blue;
+		this.a = cast(ubyte) alpha;
+	}
+
+	static Color transparent() {
+		return Color(0, 0, 0, 0);
+	}
+
+	static Color white() {
+		return Color(255, 255, 255);
+	}
+
+	static Color black() {
+		return Color(0, 0, 0);
+	}
+}
+
+struct Point {
+	int x;
+	int y;
+}
+
+struct Size {
+	int width;
+	int height;
+}
+
+
+struct KeyEvent {
+
+}
+
+struct MouseEvent {
+	int type; // movement, press, release, double click
+
+	int x;
+	int y;
+
+	int button;
+	int buttonFlags;
+}
+
+struct MouseClickEvent {
+
+}
+
+struct MouseMoveEvent {
+
+}
+
+
+struct Pen {
+	Color color;
+	int width;
+	Style style;
+/+
+// From X.h
+
+#define LineSolid		0
+#define LineOnOffDash		1
+#define LineDoubleDash		2
+       LineDou-        The full path of the line is drawn, but the
+       bleDash         even dashes are filled differently from the
+                       odd dashes (see fill-style) with CapButt
+                       style used where even and odd dashes meet.
+
+
+
+/* capStyle */
+
+#define CapNotLast		0
+#define CapButt			1
+#define CapRound		2
+#define CapProjecting		3
+
+/* joinStyle */
+
+#define JoinMiter		0
+#define JoinRound		1
+#define JoinBevel		2
+
+/* fillStyle */
+
+#define FillSolid		0
+#define FillTiled		1
+#define FillStippled		2
+#define FillOpaqueStippled	3
+
+
++/
+	enum Style {
+		Solid,
+		Dashed
+	}
+}
+
+
+class Image {
+	this(int width, int height) {
+		this.width = width;
+		this.height = height;
+
+		impl.createImage(width, height);
+	}
+
+	this(Size size) {
+		this(size.width, size.height);
+	}
+
+	~this() {
+		impl.dispose();
+	}
+
+	void putPixel(int x, int y, Color c) {
+		if(x < 0 || x >= width)
+			return;
+		if(y < 0 || y >= height)
+			return;
+
+		impl.setPixel(x, y, c);
+	}
+
+	void opIndexAssign(Color c, int x, int y) {
+		putPixel(x, y, c);
+	}
+
+	immutable int width;
+	immutable int height;
+    private:
+	mixin NativeImageImplementation!() impl;
+}
+
+void displayImage(Image image, SimpleWindow win = null) {
+	if(win is null) {
+		win = new SimpleWindow(image);
+		{
+			auto p = win.draw;
+			p.drawImage(Point(0, 0), image);
+		}
+		return win.eventLoop(0,
+			(int) {
+				win.close();
+			} );
+	} else {
+		win.image = image;
+	}
+}
+
+/// Most functions use the outlineColor instead of taking a color themselves.
+struct ScreenPainter {
+	SimpleWindow window;
+	this(SimpleWindow window, NativeWindowHandle handle) {
+		this.window = window;
+		if(window.activeScreenPainter !is null) {
+			impl = window.activeScreenPainter;
+			impl.referenceCount++;
+		//	writeln("refcount ++ ", impl.referenceCount);
+		} else {
+			impl = new ScreenPainterImplementation;
+			impl.window = window;
+			impl.create(handle);
+			impl.referenceCount = 1;
+			window.activeScreenPainter = impl;
+		//	writeln("constructed");
+		}
+	}
+
+	~this() {
+		impl.referenceCount--;
+		//writeln("refcount -- ", impl.referenceCount);
+		if(impl.referenceCount == 0) {
+			//writeln("destructed");
+			impl.dispose();
+			window.activeScreenPainter = null;
+		}
+	}
+
+	// @disable this(this) { } // compiler bug? the linker is bitching about it beind defined twice
+
+	this(this) {
+		impl.referenceCount++;
+		//writeln("refcount ++ ", impl.referenceCount);
+	}
+
+	@property void outlineColor(Color c) {
+		impl.outlineColor(c);
+	}
+
+	@property void fillColor(Color c) {
+		impl.fillColor(c);
+	}
+
+	void updateDisplay() {
+		// FIXME
+	}
+
+	void clear() {
+		fillColor = Color(255, 255, 255);
+		drawRectangle(Point(0, 0), window.width, window.height);
+	}
+
+	void drawImage(Point upperLeft, Image i) {
+		impl.drawImage(upperLeft.x, upperLeft.y, i);
+	}
+
+	void drawText(Point upperLeft, string text) {
+		// bounding rect other sizes are ignored for now
+		impl.drawText(upperLeft.x, upperLeft.y, 0, 0, text);
+	}
+
+	void drawPixel(Point where) {
+		impl.drawPixel(where.x, where.y);
+	}
+
+
+	void drawLine(Point starting, Point ending) {
+		impl.drawLine(starting.x, starting.y, ending.x, ending.y);
+	}
+
+	void drawRectangle(Point upperLeft, int width, int height) {
+		impl.drawRectangle(upperLeft.x, upperLeft.y, width, height);
+	}
+
+	/// Arguments are the points of the bounding rectangle
+	void drawEllipse(Point upperLeft, Point lowerRight) {
+		impl.drawEllipse(upperLeft.x, upperLeft.y, lowerRight.x, lowerRight.y);
+	}
+
+	void drawArc(Point upperLeft, int width, int height, int start, int finish) {
+		impl.drawArc(upperLeft.x, upperLeft.y, width, height, start, finish);
+	}
+
+	void drawPolygon(Point[] vertexes) {
+		impl.drawPolygon(vertexes);
+	}
+
+
+	// and do a draw/fill in a single call maybe. Windows can do it... but X can't, though it could do two calls.
+
+	//mixin NativeScreenPainterImplementation!() impl;
+
+
+	// HACK: if I mixin the impl directly, it won't let me override the copy
+	// constructor! The linker complains about there being multiple definitions.
+	// I'll make the best of it and reference count it though.
+	ScreenPainterImplementation* impl;
+}
+
+	// HACK: I need a pointer to the implementation so it's separate
+	struct ScreenPainterImplementation {
+		SimpleWindow window;
+		int referenceCount;
+		mixin NativeScreenPainterImplementation!();
+	}
+
+class SimpleWindow {
+	int width;
+	int height;
+
+	// HACK: making the best of some copy constructor woes with refcounting
+	private ScreenPainterImplementation* activeScreenPainter;
+
+	/// Creates a window based on the given image. It's client area
+	/// width and height is equal to the image. (A window's client area
+	/// is the drawable space inside; it excludes the title bar, etc.)
+	this(Image image, string title = null) {
+		this.backingImage = image;
+		this(image.width, image.height, title);
+	}
+
+	this(Size size, string title = null) {
+		this(size.width, size.height, title);
+	}
+
+	this(int width, int height, string title = null) {
+		this.width = width;
+		this.height = height;
+		impl.createWindow(width, height, title is null ? "D Application" : title);
+	}
+
+	Image backingImage;
+
+	~this() {
+		impl.dispose();
+	}
+
+	/// Closes the window and terminates it's event loop.
+	void close() {
+		impl.closeWindow();
+	}
+
+	/// The event loop automatically returns when the window is closed
+	/// pulseTimeout is given in milliseconds.
+	final int eventLoop(T...)(
+		long pulseTimeout,    /// set to zero if you don't want a pulse. Note: don't set it too big, or user input may not be processed in a timely manner. I suggest something < 150.
+		T eventHandlers) /// delegate list like std.concurrency.receive
+	{
+
+		// FIXME: add more events
+		foreach(handler; eventHandlers) {
+			static if(__traits(compiles, handleKeyEvent = handler)) {
+				handleKeyEvent = handler;
+			} else static if(__traits(compiles, handleCharEvent = handler)) {
+				handleCharEvent = handler;
+			} else static if(__traits(compiles, handlePulse = handler)) {
+				handlePulse = handler;
+			} else static if(__traits(compiles, handleMouseEvent = handler)) {
+				handleMouseEvent = handler;
+			} else static assert(0, "I can't use this event handler " ~ typeof(handler).stringof);
+		}
+
+
+		return impl.eventLoop(pulseTimeout);
+	}
+
+	ScreenPainter draw() {
+		return impl.getPainter();
+	}
+
+	@property void image(Image i) {
+		backingImage = i;
+		version(Windows) {
+			RECT r;
+			r.right = i.width;
+			r.bottom = i.height;
+
+			InvalidateRect(hwnd, &r, false);
+		}
+		version(X11) {
+			if(!destroyed)
+			XPutImage(display, cast(Drawable) window, gc, backingImage.handle, 0, 0, 0, 0, backingImage.width, backingImage.height);
+		}
+	}
+
+	/// What follows are the event handlers. These are set automatically
+	/// by the eventLoop function, but are still public so you can change
+	/// them later.
+
+	/// Handles a low-level keyboard event
+	void delegate(int key) handleKeyEvent;
+
+	/// Handles a higher level keyboard event - c is the character just pressed.
+	void delegate(dchar c) handleCharEvent;
+
+	void delegate() handlePulse;
+
+	void delegate(MouseEvent) handleMouseEvent;
+
+	/** Platform specific - handle any native messages this window gets.
+	  *
+	  * Note: this is called *in addition to* other event handlers.
+
+	  * On Windows, it takes the form of void delegate(UINT, WPARAM, LPARAM).
+
+	  * On X11, it takes the form of void delegate(XEvent).
+	**/
+	NativeEventHandler handleNativeEvent;
+
+  private:
+	mixin NativeSimpleWindowImplementation!() impl;
+}
+
+/* Additional utilities */
+
+
+import std.conv;
+import std.math;
+
+Color fromHsl(real h, real s, real l) {
+	h = h % 360;
+
+	real C = (1 - abs(2 * l - 1)) * s;
+
+	real hPrime = h / 60;
+
+	real X = C * (1 - abs(hPrime % 2 - 1));
+
+	real r, g, b;
+
+	if(std.math.isNaN(h))
+		r = g = b = 0;
+	else if (hPrime >= 0 && hPrime < 1) {
+		r = C;
+		g = X;
+		b = 0;
+	} else if (hPrime >= 1 && hPrime < 2) {
+		r = X;
+		g = C;
+		b = 0;
+	} else if (hPrime >= 2 && hPrime < 3) {
+		r = 0;
+		g = C;
+		b = X;
+	} else if (hPrime >= 3 && hPrime < 4) {
+		r = 0;
+		g = X;
+		b = C;
+	} else if (hPrime >= 4 && hPrime < 5) {
+		r = X;
+		g = 0;
+		b = C;
+	} else if (hPrime >= 5 && hPrime < 6) {
+		r = C;
+		g = 0;
+		b = X;
+	}
+
+	real m = l - C / 2;
+
+	r += m;
+	g += m;
+	b += m;
+
+	return Color(
+		cast(ubyte)(r * 255),
+		cast(ubyte)(g * 255),
+		cast(ubyte)(b * 255),
+		255);
+}
+
+
+
+/* ********** What follows is the system-specific implementations *********/
+version(Windows) {
+	import std.string;
+
+	SimpleWindow[HWND] windowObjects;
+
+	alias void delegate(UINT, WPARAM, LPARAM) NativeEventHandler;
+	alias HWND NativeWindowHandle;
+
+	extern(Windows)
+	int WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+		if(hWnd in windowObjects) {
+			auto window = windowObjects[hWnd];
+			return window.windowProcedure(hWnd, iMessage, wParam, lParam);
+		} else {
+			return DefWindowProc(hWnd, iMessage, wParam, lParam);
+		}
+	}
+
+	mixin template NativeScreenPainterImplementation() {
+		HDC hdc;
+		HWND hwnd;
+		HDC windowHdc;
+		HBITMAP oldBmp;
+
+		void create(NativeWindowHandle window) {
+			auto buffer = this.window.impl.buffer;
+			hwnd = window;
+			windowHdc = GetDC(hwnd);
+
+			hdc = CreateCompatibleDC(windowHdc);
+			oldBmp = SelectObject(hdc, buffer);
+
+			// X doesn't draw a text background, so neither should we
+			SetBkMode(hdc, TRANSPARENT);
+		}
+
+		// just because we can on Windows...
+		//void create(Image image);
+
+		void dispose() {
+			// FIXME: this.window.width/height is probably wrong
+			BitBlt(windowHdc, 0, 0, this.window.width, this.window.height, hdc, 0, 0, SRCCOPY);
+
+			ReleaseDC(hwnd, windowHdc);
+
+			if(originalPen !is null)
+				SelectObject(hdc, originalPen);
+			if(currentPen !is null)
+				DeleteObject(currentPen);
+			if(originalBrush !is null)
+				SelectObject(hdc, originalBrush);
+			if(currentBrush !is null)
+				DeleteObject(currentBrush);
+
+			SelectObject(hdc, oldBmp);
+
+			DeleteDC(hdc);
+		}
+
+		HPEN originalPen;
+		HPEN currentPen;
+
+		Color _foreground;
+		@property void outlineColor(Color c) {
+			_foreground = c;
+			HPEN pen;
+			if(c.a == 0) {
+				pen = GetStockObject(NULL_PEN);
+			} else {
+				pen = CreatePen(PS_SOLID, 1, RGB(c.r, c.g, c.b));
+			}
+			auto orig = SelectObject(hdc, pen);
+			if(originalPen is null)
+				originalPen = orig;
+
+			if(currentPen !is null)
+				DeleteObject(currentPen);
+
+			currentPen = pen;
+
+			// the outline is like a foreground since it's done that way on X
+			SetTextColor(hdc, RGB(c.r, c.g, c.b));
+		}
+
+		HBRUSH originalBrush;
+		HBRUSH currentBrush;
+		@property void fillColor(Color c) {
+			HBRUSH brush;
+			if(c.a == 0) {
+				brush = GetStockObject(HOLLOW_BRUSH);
+			} else {
+				brush = CreateSolidBrush(RGB(c.r, c.g, c.b));
+			}
+			auto orig = SelectObject(hdc, brush);
+			if(originalBrush is null)
+				originalBrush = orig;
+
+			if(currentBrush !is null)
+				DeleteObject(currentBrush);
+
+			currentBrush = brush;
+
+			// background color is NOT set because X doesn't draw text backgrounds
+			//   SetBkColor(hdc, RGB(255, 255, 255));
+		}
+
+		void drawImage(int x, int y, Image i) {
+			BITMAP bm;
+
+			HDC hdcMem = CreateCompatibleDC(hdc);
+			HBITMAP hbmOld = SelectObject(hdcMem, i.handle);
+
+			GetObject(i.handle, bm.sizeof, &bm);
+
+			BitBlt(hdc, x, y, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
+
+			SelectObject(hdcMem, hbmOld);
+			DeleteDC(hdcMem);
+		}
+
+		void drawText(int x, int y, int x2, int y2, string text) {
+			/*
+			RECT rect;
+			rect.left = x;
+			rect.top = y;
+			rect.right = x2;
+			rect.bottom = y2;
+
+			DrawText(hdc, text.ptr, text.length, &rect, DT_LEFT);
+			*/
+
+			TextOut(hdc, x, y, text.ptr, text.length);
+		}
+
+		void drawPixel(int x, int y) {
+			SetPixel(hdc, x, y, RGB(_foreground.r, _foreground.g, _foreground.b));
+		}
+
+		// The basic shapes, outlined
+
+		void drawLine(int x1, int y1, int x2, int y2) {
+			MoveToEx(hdc, x1, y1, null);
+			LineTo(hdc, x2, y2);
+		}
+
+		void drawRectangle(int x, int y, int width, int height) {
+			Rectangle(hdc, x, y, x + width, y + height);
+		}
+
+		/// Arguments are the points of the bounding rectangle
+		void drawEllipse(int x1, int y1, int x2, int y2) {
+			Ellipse(hdc, x1, y1, x2, y2);
+		}
+
+		void drawArc(int x1, int y1, int width, int height, int start, int finish) {
+			// FIXME: start X, start Y, end X, end Y
+			Arc(hdc, x1, y1, x1 + width, y1 + height, 0, 0, 0, 0);
+		}
+
+		void drawPolygon(Point[] vertexes) {
+			POINT[] points;
+			points.length = vertexes.length;
+
+			foreach(i, p; vertexes) {
+				points[i].x = p.x;
+				points[i].y = p.y;
+			}
+
+			Polygon(hdc, points.ptr, points.length);
+		}
+	}
+
+
+	// Mix this into the SimpleWindow class
+	mixin template NativeSimpleWindowImplementation() {
+		ScreenPainter getPainter() {
+			return ScreenPainter(this, hwnd);
+		}
+
+		HBITMAP buffer;
+
+		void createWindow(int width, int height, string title) {
+			const char* cn = "DSimpleWindow";
+
+			HINSTANCE hInstance = cast(HINSTANCE) GetModuleHandle(null);
+
+			WNDCLASS wc;
+
+			wc.cbClsExtra = 0;
+			wc.cbWndExtra = 0;
+			wc.hbrBackground = cast(HBRUSH) GetStockObject(WHITE_BRUSH);
+			wc.hCursor = LoadCursor(null, IDC_ARROW);
+			wc.hIcon = LoadIcon(hInstance, null);
+			wc.hInstance = hInstance;
+			wc.lpfnWndProc = &WndProc;
+			wc.lpszClassName = cn;
+			wc.style = CS_HREDRAW | CS_VREDRAW;
+			if(!RegisterClass(&wc))
+				throw new Exception("RegisterClass");
+
+			hwnd = CreateWindow(cn, toStringz(title), WS_OVERLAPPEDWINDOW,
+				CW_USEDEFAULT, CW_USEDEFAULT, width, height,
+				null, null, hInstance, null);
+
+			windowObjects[hwnd] = this;
+
+			HDC hdc = GetDC(hwnd);
+			buffer = CreateCompatibleBitmap(hdc, width, height);
+
+			auto hdcBmp = CreateCompatibleDC(hdc);
+			// make sure it's filled with a blank slate
+			auto oldBmp = SelectObject(hdcBmp, buffer);
+			auto oldBrush = SelectObject(hdcBmp, GetStockObject(WHITE_BRUSH));
+			Rectangle(hdcBmp, 0, 0, width, height);
+			SelectObject(hdcBmp, oldBmp);
+			SelectObject(hdcBmp, oldBrush);
+			DeleteDC(hdcBmp);
+
+			ReleaseDC(hwnd, hdc);
+
+			// We want the window's client area to match the image size
+			RECT rcClient, rcWindow;
+			POINT ptDiff;
+			GetClientRect(hwnd, &rcClient);
+			GetWindowRect(hwnd, &rcWindow);
+			ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
+			ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
+			MoveWindow(hwnd,rcWindow.left, rcWindow.top, width + ptDiff.x, height + ptDiff.y, true);
+
+			ShowWindow(hwnd, SW_SHOWNORMAL);
+		}
+
+
+		void dispose() {
+			DeleteObject(buffer);
+		}
+
+		void closeWindow() {
+			DestroyWindow(hwnd);
+		}
+
+		HWND hwnd;
+
+		// the extern(Windows) wndproc should just forward to this
+		int windowProcedure(HWND hwnd, uint msg, WPARAM wParam, LPARAM lParam) {
+			assert(hwnd is this.hwnd);
+
+			MouseEvent mouse;
+			switch(msg) {
+				case WM_CHAR:
+					wchar c = cast(wchar) wParam;
+					if(handleCharEvent)
+						handleCharEvent(cast(dchar) c);
+				break;
+				case WM_MOUSEMOVE:
+
+				case WM_LBUTTONDOWN:
+				case WM_LBUTTONUP:
+				case WM_LBUTTONDBLCLK:
+
+				case WM_RBUTTONDOWN:
+				case WM_RBUTTONUP:
+				case WM_RBUTTONDBLCLK:
+
+				case WM_MBUTTONDOWN:
+				case WM_MBUTTONUP:
+				case WM_MBUTTONDBLCLK:
+					mouse.type = 0;
+					mouse.x = GET_X_LPARAM(lParam);
+					mouse.y = GET_Y_LPARAM(lParam);
+					mouse.buttonFlags = wParam;
+
+					if(handleMouseEvent)
+						handleMouseEvent(mouse);
+				break;
+				case WM_KEYDOWN:
+					if(handleKeyEvent)
+						handleKeyEvent(wParam);
+				break;
+				case WM_CLOSE:
+				case WM_DESTROY:
+					PostQuitMessage(0);
+				break;
+				case WM_PAINT: {
+					BITMAP bm;
+					PAINTSTRUCT ps;
+
+					HDC hdc = BeginPaint(hwnd, &ps);
+
+/*
+					if(backingImage !is null) {
+						HDC hdcMem = CreateCompatibleDC(hdc);
+						HBITMAP hbmOld = SelectObject(hdcMem, backingImage.handle);
+
+						GetObject(backingImage.handle, bm.sizeof, &bm);
+
+						BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
+
+						SelectObject(hdcMem, hbmOld);
+						DeleteDC(hdcMem);
+					}
+*/
+					HDC hdcMem = CreateCompatibleDC(hdc);
+					HBITMAP hbmOld = SelectObject(hdcMem, buffer);
+
+					GetObject(buffer, bm.sizeof, &bm);
+
+					BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
+
+					SelectObject(hdcMem, hbmOld);
+					DeleteDC(hdcMem);
+
+
+					EndPaint(hwnd, &ps);
+				} break;
+				  default:
+					return DefWindowProc(hwnd, msg, wParam, lParam);
+			}
+			 return 0;
+
+		}
+
+		int eventLoop(long pulseTimeout) {
+			MSG message;
+			int ret;
+
+			if(pulseTimeout) {
+				bool done = false;
+				while(!done) {
+					while(!done && PeekMessage(&message, hwnd, 0, 0, PM_NOREMOVE)) {
+						ret = GetMessage(&message, hwnd, 0, 0);
+						if(ret == 0)
+							done = true;
+
+						TranslateMessage(&message);
+						DispatchMessage(&message);
+					}
+
+					if(!done && handlePulse !is null)
+						handlePulse();
+					Thread.sleep(pulseTimeout * 10000);
+				}
+			} else {
+				while((ret = GetMessage(&message, hwnd, 0, 0)) != 0) {
+					if(ret == -1)
+						throw new Exception("GetMessage failed");
+					TranslateMessage(&message);
+					DispatchMessage(&message);
+				}
+			}
+
+			return message.wParam;
+		}
+	}
+
+	mixin template NativeImageImplementation() {
+		HBITMAP handle;
+		byte* rawData;
+
+		void setPixel(int x, int y, Color c) {
+			auto itemsPerLine = ((cast(int) width * 3 + 3) / 4) * 4;
+			// remember, bmps are upside down
+			auto offset = itemsPerLine * (height - y - 1) + x * 3;
+
+			rawData[offset + 0] = c.b;
+			rawData[offset + 1] = c.g;
+			rawData[offset + 2] = c.r;
+		}
+
+		void createImage(int width, int height) {
+			BITMAPINFO infoheader;
+			infoheader.bmiHeader.biSize = infoheader.bmiHeader.sizeof;
+			infoheader.bmiHeader.biWidth = width;
+			infoheader.bmiHeader.biHeight = height;
+			infoheader.bmiHeader.biPlanes = 1;
+			infoheader.bmiHeader.biBitCount = 24;
+			infoheader.bmiHeader.biCompression = BI_RGB;
+
+			handle = enforce(CreateDIBSection(
+				null,
+				&infoheader,
+				DIB_RGB_COLORS,
+				cast(void**) &rawData,
+				null,
+				0));
+
+		}
+
+		void dispose() {
+			DeleteObject(handle);
+		}
+	}
+
+	enum KEY_ESCAPE = 27;
+}
+version(X11) {
+
+	alias void delegate(XEvent) NativeEventHandler;
+	alias Window NativeWindowHandle;
+
+	enum KEY_ESCAPE = 9;
+	import core.stdc.stdlib;
+
+	mixin template NativeScreenPainterImplementation() {
+		Display* display;
+		Drawable d;
+		Drawable destiny;
+		GC gc;
+
+		void create(NativeWindowHandle window) {
+			this.display = XDisplayConnection.get();
+
+    			auto buffer = this.window.impl.buffer;
+
+			this.d = cast(Drawable) buffer;
+			this.destiny = cast(Drawable) window;
+
+			auto dgc = DefaultGC(display, DefaultScreen(display));
+
+			this.gc = XCreateGC(display, d, 0, null);
+
+			XCopyGC(display, dgc, 0xffffffff, this.gc);
+
+		}
+
+		void dispose() {
+    			auto buffer = this.window.impl.buffer;
+
+			// FIXME: this.window.width/height is probably wrong
+
+			// src x,y     then dest x, y
+			XCopyArea(display, d, destiny, gc, 0, 0, this.window.width, this.window.height, 0, 0);
+
+			XFreeGC(display, gc);
+		}
+
+		bool backgroundIsNotTransparent = true;
+		bool foregroundIsNotTransparent = true;
+
+		Color _outlineColor;
+		Color _fillColor;
+
+		@property void outlineColor(Color c) {
+			_outlineColor = c;
+			if(c.a == 0) {
+				foregroundIsNotTransparent = false;
+				return;
+			}
+
+			foregroundIsNotTransparent = true;
+
+			XSetForeground(display, gc, 
+				cast(uint) c.r << 16 |
+				cast(uint) c.g << 8 |
+				cast(uint) c.b);
+		}
+
+		@property void fillColor(Color c) {
+			_fillColor = c;
+			if(c.a == 0) {
+				backgroundIsNotTransparent = false;
+				return;
+			}
+
+			backgroundIsNotTransparent = true;
+
+			XSetBackground(display, gc, 
+				cast(uint) c.r << 16 |
+				cast(uint) c.g << 8 |
+				cast(uint) c.b);
+		
+		}
+
+		void swapColors() {
+			auto tmp = _fillColor;
+			fillColor = _outlineColor;
+			outlineColor = tmp;
+		}
+
+		void drawImage(int x, int y, Image i) {
+			// source x, source y
+			XPutImage(display, d, gc, i.handle, 0, 0, x, y, i.width, i.height);
+		}
+
+		void drawText(int x, int y, int x2, int y2, string text) {
+			foreach(line; text.split("\n")) {
+				XDrawString(display, d, gc, x, y + 12, line.ptr, line.length);
+				y += 16;
+			}
+		}
+
+		void drawPixel(int x, int y) {
+			XDrawPoint(display, d, gc, x, y);
+		}
+
+		// The basic shapes, outlined
+
+		void drawLine(int x1, int y1, int x2, int y2) {
+			if(foregroundIsNotTransparent)
+				XDrawLine(display, d, gc, x1, y1, x2, y2);
+		}
+
+		void drawRectangle(int x, int y, int width, int height) {
+			if(backgroundIsNotTransparent) {
+				swapColors();
+				XFillRectangle(display, d, gc, x, y, width, height);
+				swapColors();
+			}
+			if(foregroundIsNotTransparent)
+				XDrawRectangle(display, d, gc, x, y, width, height);
+		}
+
+		/// Arguments are the points of the bounding rectangle
+		void drawEllipse(int x1, int y1, int x2, int y2) {
+			drawArc(x1, y1, x2 - x1, y2 - y1, 0, 360 * 64);
+		}
+
+		// NOTE: start and finish are in units of degrees * 64
+		void drawArc(int x1, int y1, int width, int height, int start, int finish) {
+			if(backgroundIsNotTransparent) {
+				swapColors();
+				XFillArc(display, d, gc, x1, y1, width, height, start, finish);
+				swapColors();
+			}
+			if(foregroundIsNotTransparent)
+				XDrawArc(display, d, gc, x1, y1, width, height, start, finish);
+		}
+
+		void drawPolygon(Point[] vertexes) {
+			XPoint[] points;
+			points.length = vertexes.length;
+
+			foreach(i, p; vertexes) {
+				points[i].x = cast(short) p.x;
+				points[i].y = cast(short) p.y;
+			}
+			
+			if(backgroundIsNotTransparent) {
+				swapColors();
+				XFillPolygon(display, d, gc, points.ptr, points.length, PolygonShape.Complex, CoordMode.CoordModeOrigin);
+				swapColors();
+			}
+			if(foregroundIsNotTransparent) {
+				XDrawLines(display, d, gc, points.ptr, points.length, CoordMode.CoordModeOrigin);
+			}
+		}
+	}
+
+
+	class XDisplayConnection {
+		private static Display* display;
+
+		static Display* get() {
+			if(display is null)
+				display = enforce(XOpenDisplay(null));
+
+			return display;
+		}
+
+		static void close() {
+			XCloseDisplay(display);
+			display = null;
+		}
+	}
+
+	mixin template NativeImageImplementation() {
+		XImage* handle;
+		byte* rawData;
+
+		void createImage(int width, int height) {
+			auto display = XDisplayConnection.get();
+			auto screen = DefaultScreen(display);
+
+			// This actually needs to be malloc to avoid a double free error when XDestroyImage is called
+			rawData = cast(byte*) malloc(width * height * 4);
+
+			handle = XCreateImage(
+				display,
+				DefaultVisual(display, screen),
+				24, // bpp
+				ImageFormat.ZPixmap,
+				0, // offset
+				rawData,
+				width, height,
+				8 /* FIXME */, 4 * width); // padding, bytes per line
+		}
+
+		void dispose() {
+			XDestroyImage(handle);
+		}
+
+		/*
+		Color getPixel(int x, int y) {
+
+		}
+		*/
+
+		void setPixel(int x, int y, Color c) {
+			auto offset = (y * width + x) * 4;
+			rawData[offset + 0] = c.b;
+			rawData[offset + 1] = c.g;
+			rawData[offset + 2] = c.r;
+		}
+	}
+
+	mixin template NativeSimpleWindowImplementation() {
+		GC gc;
+		Window window;
+		Display* display;
+
+		Pixmap buffer;
+
+		ScreenPainter getPainter() {
+			return ScreenPainter(this, window);
+		}
+
+		void createWindow(int width, int height, string title) {
+			display = XDisplayConnection.get();
+			auto screen = DefaultScreen(display);
+		 
+			window = XCreateSimpleWindow(
+				display,
+				RootWindow(display, screen),
+				0, 0, // x, y
+				width, height,
+				1, // border width
+				BlackPixel(display, screen), // border
+				WhitePixel(display, screen)); // background
+
+			XTextProperty windowName;
+			windowName.value = title.ptr;
+			windowName.encoding = XA_STRING;
+			windowName.format = 8;
+			windowName.nitems = title.length;
+
+			XSetWMName(display, window, &windowName);
+
+			buffer = XCreatePixmap(display, cast(Drawable) window, width, height, 24);
+
+			gc = DefaultGC(display, screen);
+
+			// clear out the buffer to get us started...
+			XSetForeground(display, gc, WhitePixel(display, screen));
+			XFillRectangle(display, cast(Drawable) buffer, gc, 0, 0, width, height);
+			XSetForeground(display, gc, BlackPixel(display, screen));
+
+			// This gives our window a close button
+			Atom atom = XInternAtom(display, "WM_DELETE_WINDOW".ptr, true); // FIXME: does this need to be freed?
+			XSetWMProtocols(display, window, &atom, 1);
+
+			XMapWindow(display, window);
+
+			XSelectInput(display, window,
+				EventMask.ExposureMask |
+				EventMask.KeyPressMask |
+				EventMask.StructureNotifyMask
+				| EventMask.PointerMotionMask // FIXME: not efficient
+				| EventMask.ButtonPressMask
+				| EventMask.ButtonReleaseMask
+			);
+		}
+
+		void closeWindow() {
+			XFreePixmap(display, buffer);
+			XDestroyWindow(display, window);
+		}
+
+		void dispose() {
+		}
+
+		bool destroyed = false;
+
+		int eventLoop(long pulseTimeout) {
+			XEvent e;
+			bool done = false;
+
+			while (!done) {
+			while(!done &&
+				(pulseTimeout == 0 || (XPending(display) > 0)))
+			{
+				XNextEvent(display, &e);
+
+				switch(e.type) {
+				  case EventType.Expose:
+				  	//if(backingImage !is null)
+					//	XPutImage(display, cast(Drawable) window, gc, backingImage.handle, 0, 0, 0, 0, backingImage.width, backingImage.height);
+					XCopyArea(display, cast(Drawable) buffer, cast(Drawable) window, gc, 0, 0, width, height, 0, 0);
+				  break;
+				  case EventType.ClientMessage: // User clicked the close button
+				  case EventType.DestroyNotify:
+					done = true;
+					destroyed = true;
+				  break;
+
+				  case EventType.MotionNotify:
+				  	MouseEvent mouse;
+					auto event = e.xmotion;
+
+					mouse.type = 0;
+					mouse.x = event.x;
+					mouse.y = event.y;
+					mouse.buttonFlags = event.state;
+
+					if(handleMouseEvent)
+						handleMouseEvent(mouse);
+				  break;
+				  case EventType.ButtonPress:
+				  case EventType.ButtonRelease:
+				  	MouseEvent mouse;
+					auto event = e.xbutton;
+
+					mouse.type = e.type == EventType.ButtonPress ? 1 : 2;
+					mouse.x = event.x;
+					mouse.y = event.y;
+					mouse.button = event.button;
+					//mouse.buttonFlags = event.detail;
+
+					if(handleMouseEvent)
+						handleMouseEvent(mouse);
+				  break;
+
+				  case EventType.KeyPress:
+					if(handleCharEvent)
+						handleCharEvent(
+							XKeycodeToKeysym(
+								XDisplayConnection.get(),
+								e.xkey.keycode,
+								0)); // FIXME: we should check shift, etc. too, so it matches Windows' behavior better
+				  	if(handleKeyEvent)
+						handleKeyEvent(e.xkey.keycode);
+				  break;
+				  default:
+				}
+			}
+				if(!done && pulseTimeout !=0) {
+					if(handlePulse !is null)
+						handlePulse();
+					Thread.sleep(pulseTimeout * 10000);
+				}
+			}
+
+			return 0;
+		}
+	}
+}
+
+/* *************************************** */
+/*      Done with simpledisplay stuff      */
+/* *************************************** */
+
+// Necessary C library bindings follow
+
+version(Windows) {
+	import core.sys.windows.windows;
+
+	pragma(lib, "gdi32");
+
+	extern(Windows) {
+		// The included D headers are incomplete, finish them here
+		// enough that this module works.
+		alias GetObjectA GetObject;
+		alias GetMessageA GetMessage;
+		alias PeekMessageA PeekMessage;
+		alias TextOutA TextOut;
+		alias DispatchMessageA DispatchMessage;
+		alias GetModuleHandleA GetModuleHandle;
+		alias LoadCursorA LoadCursor;
+		alias LoadIconA LoadIcon;
+		alias RegisterClassA RegisterClass;
+		alias CreateWindowA CreateWindow;
+		alias DefWindowProcA DefWindowProc;
+		alias DrawTextA DrawText;
+
+		bool MoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
+		HBITMAP CreateDIBSection(HDC, const BITMAPINFO*, uint, void**, HANDLE hSection, DWORD);
+		bool BitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, DWORD dwRop);
+		bool DestroyWindow(HWND);
+		int DrawTextA(HDC hDC, LPCTSTR lpchText, int nCount, LPRECT lpRect, UINT uFormat);
+		bool Rectangle(HDC, int, int, int, int);
+		bool Ellipse(HDC, int, int, int, int);
+		bool Arc(HDC, int, int, int, int, int, int, int, int);
+		bool Polygon(HDC, POINT*, int);
+		HBRUSH CreateSolidBrush(COLORREF);
+
+		HBITMAP CreateCompatibleBitmap(HDC, int, int);
+
+		uint SetTimer(HWND, uint, uint, void*);
+		bool KillTimer(HWND, uint);
+
+
+		enum BI_RGB = 0;
+		enum DIB_RGB_COLORS = 0;
+		enum DT_LEFT = 0;
+		enum TRANSPARENT = 1;
+
+	}
+
+}
+
+else version(X11) {
+
+// X11 bindings needed here
+/*
+	A little of this is from the bindings project on
+	D Source and some of it is copy/paste from the C
+	header.
+
+	The DSource listing consistently used D's long
+	where C used long. That's wrong - C long is 32 bit, so
+	it should be int in D. I changed that here.
+
+	Note:
+	This isn't complete, just took what I needed for myself.
+*/
+
+pragma(lib, "X11");
+
+extern(C):
+
+
+KeySym XKeycodeToKeysym(
+    Display*		/* display */,
+    KeyCode		/* keycode */,
+    int			/* index */
+);
+
+Display* XOpenDisplay(const char*);
+int XCloseDisplay(Display*);
+
+
+enum MappingType:int {
+	MappingModifier		=0,
+	MappingKeyboard		=1,
+	MappingPointer		=2
+}
+
+/* ImageFormat -- PutImage, GetImage */
+enum ImageFormat:int {
+	XYBitmap	=0,	/* depth 1, XYFormat */
+	XYPixmap	=1,	/* depth == drawable depth */
+	ZPixmap	=2	/* depth == drawable depth */
+}
+
+enum ModifierName:int {
+	ShiftMapIndex	=0,
+	LockMapIndex	=1,
+	ControlMapIndex	=2,
+	Mod1MapIndex	=3,
+	Mod2MapIndex	=4,
+	Mod3MapIndex	=5,
+	Mod4MapIndex	=6,
+	Mod5MapIndex	=7
+}
+
+enum ButtonMask:int {
+	Button1Mask	=1<<8,
+	Button2Mask	=1<<9,
+	Button3Mask	=1<<10,
+	Button4Mask	=1<<11,
+	Button5Mask	=1<<12,
+	AnyModifier	=1<<15/* used in GrabButton, GrabKey */
+}
+
+enum KeyOrButtonMask:uint {
+	ShiftMask	=1<<0,
+	LockMask	=1<<1,
+	ControlMask	=1<<2,
+	Mod1Mask	=1<<3,
+	Mod2Mask	=1<<4,
+	Mod3Mask	=1<<5,
+	Mod4Mask	=1<<6,
+	Mod5Mask	=1<<7,
+	Button1Mask	=1<<8,
+	Button2Mask	=1<<9,
+	Button3Mask	=1<<10,
+	Button4Mask	=1<<11,
+	Button5Mask	=1<<12,
+	AnyModifier	=1<<15/* used in GrabButton, GrabKey */
+}
+
+enum ButtonName:int {
+	Button1	=1,
+	Button2	=2,
+	Button3	=3,
+	Button4	=4,
+	Button5	=5
+}
+
+/* Notify modes */
+enum NotifyModes:int
+{
+	NotifyNormal		=0,
+	NotifyGrab			=1,
+	NotifyUngrab		=2,
+	NotifyWhileGrabbed	=3
+}
+const int NotifyHint	=1;	/* for MotionNotify events */
+		       
+/* Notify detail */
+enum NotifyDetail:int
+{
+	NotifyAncestor			=0,
+	NotifyVirtual			=1,
+	NotifyInferior			=2,
+	NotifyNonlinear			=3,
+	NotifyNonlinearVirtual	=4,
+	NotifyPointer			=5,
+	NotifyPointerRoot		=6,
+	NotifyDetailNone		=7
+}
+
+/* Visibility notify */
+
+enum VisibilityNotify:int
+{
+VisibilityUnobscured		=0,
+VisibilityPartiallyObscured	=1,
+VisibilityFullyObscured		=2
+}
+
+
+enum WindowStackingMethod:int
+{
+	Above		=0,
+	Below		=1,
+	TopIf		=2,
+	BottomIf	=3,
+	Opposite	=4
+}
+
+/* Circulation request */
+enum CirculationRequest:int
+{
+	PlaceOnTop		=0,
+	PlaceOnBottom	=1
+}
+
+enum PropertyNotification:int
+{
+	PropertyNewValue	=0,
+	PropertyDelete		=1
+}
+
+enum ColorMapNotification:int
+{
+	ColormapUninstalled	=0,
+	ColormapInstalled		=1
+}
+
+
+	struct _XPrivate {}
+	struct _XrmHashBucketRec {}
+	typedef void* XPointer;
+	typedef void* XExtData;
+	alias uint XID;
+	typedef XID Window;
+	typedef XID Drawable;
+	typedef XID Pixmap;
+	alias uint Atom;
+	alias bool Bool;
+	alias Display XDisplay;
+	typedef int ByteOrder;
+	typedef uint Time;
+	typedef void ScreenFormat;
+
+	struct XImage {
+	    int width, height;			/* size of image */
+	    int xoffset;				/* number of pixels offset in X direction */
+	    ImageFormat format;		/* XYBitmap, XYPixmap, ZPixmap */
+	    void *data;					/* pointer to image data */
+	    ByteOrder byte_order;		/* data byte order, LSBFirst, MSBFirst */
+	    int bitmap_unit;			/* quant. of scanline 8, 16, 32 */
+	    int bitmap_bit_order;		/* LSBFirst, MSBFirst */
+	    int bitmap_pad;			/* 8, 16, 32 either XY or ZPixmap */
+	    int depth;					/* depth of image */
+	    int bytes_per_line;			/* accelarator to next line */
+	    int bits_per_pixel;			/* bits per pixel (ZPixmap) */
+	    uint red_mask;	/* bits in z arrangment */
+	    uint green_mask;
+	    uint blue_mask;
+	    XPointer obdata;			/* hook for the object routines to hang on */
+	    struct f {				/* image manipulation routines */
+			XImage* function(
+				XDisplay* 			/* display */,
+				Visual*				/* visual */,
+				uint				/* depth */,
+				int					/* format */,
+				int					/* offset */,
+				byte*				/* data */,
+				uint				/* width */,
+				uint				/* height */,
+				int					/* bitmap_pad */,
+				int					/* bytes_per_line */) create_image;
+			int  function(XImage *)destroy_image;
+			uint function(XImage *, int, int)get_pixel;
+			int  function(XImage *, int, int, uint)put_pixel;
+			XImage function(XImage *, int, int, uint, uint)sub_image;
+			int function(XImage *, int)add_pixel;
+		}
+	}
+
+
+
+/*
+ * Definitions of specific events.
+ */
+struct XKeyEvent
+{
+	int type;			/* of event */
+	uint serial;		/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window it is reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	KeyOrButtonMask state;	/* key or button mask */
+	uint keycode;	/* detail */
+	Bool same_screen;	/* same screen flag */
+}
+typedef XKeyEvent XKeyPressedEvent;
+typedef XKeyEvent XKeyReleasedEvent;
+
+struct XButtonEvent
+{
+	int type;		/* of event */
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window it is reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	KeyOrButtonMask state;	/* key or button mask */
+	uint button;	/* detail */
+	Bool same_screen;	/* same screen flag */
+}
+typedef XButtonEvent XButtonPressedEvent;
+typedef XButtonEvent XButtonReleasedEvent;
+
+struct XMotionEvent{
+	int type;		/* of event */
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	KeyOrButtonMask state;	/* key or button mask */
+	byte is_hint;		/* detail */
+	Bool same_screen;	/* same screen flag */
+}
+typedef XMotionEvent XPointerMovedEvent;
+
+struct XCrossingEvent{
+	int type;		/* of event */
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;	        /* "event" window reported relative to */
+	Window root;	        /* root window that the event occurred on */
+	Window subwindow;	/* child window */
+	Time time;		/* milliseconds */
+	int x, y;		/* pointer x, y coordinates in event window */
+	int x_root, y_root;	/* coordinates relative to root */
+	NotifyModes mode;		/* NotifyNormal, NotifyGrab, NotifyUngrab */
+	NotifyDetail detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior, 
+	 * NotifyNonlinear,NotifyNonlinearVirtual
+	 */
+	Bool same_screen;	/* same screen flag */
+	Bool focus;		/* Boolean focus */
+	KeyOrButtonMask state;	/* key or button mask */
+}
+typedef XCrossingEvent XEnterWindowEvent;
+typedef XCrossingEvent XLeaveWindowEvent;
+
+struct XFocusChangeEvent{
+	int type;		/* FocusIn or FocusOut */
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;		/* window of event */
+	NotifyModes mode;		/* NotifyNormal, NotifyWhileGrabbed,
+				   NotifyGrab, NotifyUngrab */
+	NotifyDetail detail;
+	/*
+	 * NotifyAncestor, NotifyVirtual, NotifyInferior, 
+	 * NotifyNonlinear,NotifyNonlinearVirtual, NotifyPointer,
+	 * NotifyPointerRoot, NotifyDetailNone 
+	 */
+}
+typedef XFocusChangeEvent XFocusInEvent;
+typedef XFocusChangeEvent XFocusOutEvent;
+Window XCreateSimpleWindow(
+    Display*	/* display */,
+    Window		/* parent */,
+    int			/* x */,
+    int			/* y */,
+    uint		/* width */,
+    uint		/* height */,
+    uint		/* border_width */,
+    uint		/* border */,
+    uint		/* background */
+);
+
+XImage *XCreateImage(
+    Display*		/* display */,
+    Visual*		/* visual */,
+    uint	/* depth */,
+    int			/* format */,
+    int			/* offset */,
+    byte*		/* data */,
+    uint	/* width */,
+    uint	/* height */,
+    int			/* bitmap_pad */,
+    int			/* bytes_per_line */
+);
+
+Atom XInternAtom(
+    Display*		/* display */,
+    const char*	/* atom_name */,
+    Bool		/* only_if_exists */		 
+);
+
+typedef int Status;
+
+ 
+enum EventMask:int
+{ 
+	NoEventMask				=0,
+	KeyPressMask			=1<<0,
+	KeyReleaseMask			=1<<1, 
+	ButtonPressMask			=1<<2,
+	ButtonReleaseMask		=1<<3,
+	EnterWindowMask			=1<<4,
+	LeaveWindowMask			=1<<5,
+	PointerMotionMask		=1<<6,
+	PointerMotionHintMask	=1<<7,
+	Button1MotionMask		=1<<8,
+	Button2MotionMask		=1<<9,
+	Button3MotionMask		=1<<10,
+	Button4MotionMask		=1<<11,
+	Button5MotionMask		=1<<12,
+	ButtonMotionMask		=1<<13,
+	KeymapStateMask		=1<<14,
+	ExposureMask			=1<<15,
+	VisibilityChangeMask	=1<<16,
+	StructureNotifyMask		=1<<17,
+	ResizeRedirectMask		=1<<18,
+	SubstructureNotifyMask	=1<<19,
+	SubstructureRedirectMask=1<<20,
+	FocusChangeMask			=1<<21,
+	PropertyChangeMask		=1<<22,
+	ColormapChangeMask		=1<<23,
+	OwnerGrabButtonMask		=1<<24
+}
+
+int XPutImage(
+    Display*	/* display */,
+    Drawable	/* d */,
+    GC			/* gc */,
+    XImage*	/* image */,
+    int			/* src_x */,
+    int			/* src_y */,
+    int			/* dest_x */,
+    int			/* dest_y */,
+    uint		/* width */,
+    uint		/* height */	  
+);
+
+int XDestroyWindow(
+    Display*	/* display */,
+    Window		/* w */
+);
+
+int XDestroyImage(
+	XImage*);
+
+int XSelectInput(
+    Display*	/* display */,
+    Window		/* w */,
+    EventMask	/* event_mask */
+);
+
+int XMapWindow(
+    Display*	/* display */,
+    Window		/* w */
+);
+
+int XNextEvent(
+    Display*	/* display */,
+    XEvent*		/* event_return */
+);
+
+Status XSetWMProtocols(
+    Display*	/* display */,
+    Window		/* w */,
+    Atom*		/* protocols */,
+    int			/* count */
+);
+
+enum EventType:int
+{
+	KeyPress			=2,
+	KeyRelease			=3,
+	ButtonPress			=4,
+	ButtonRelease		=5,
+	MotionNotify		=6,
+	EnterNotify			=7,
+	LeaveNotify			=8,
+	FocusIn				=9,
+	FocusOut			=10,
+	KeymapNotify		=11,
+	Expose				=12,
+	GraphicsExpose		=13,
+	NoExpose			=14,
+	VisibilityNotify	=15,
+	CreateNotify		=16,
+	DestroyNotify		=17,
+	UnmapNotify		=18,
+	MapNotify			=19,
+	MapRequest			=20,
+	ReparentNotify		=21,
+	ConfigureNotify		=22,
+	ConfigureRequest	=23,
+	GravityNotify		=24,
+	ResizeRequest		=25,
+	CirculateNotify		=26,
+	CirculateRequest	=27,
+	PropertyNotify		=28,
+	SelectionClear		=29,
+	SelectionRequest	=30,
+	SelectionNotify		=31,
+	ColormapNotify		=32,
+	ClientMessage		=33,
+	MappingNotify		=34,
+	LASTEvent			=35	/* must be bigger than any event # */
+}
+/* generated on EnterWindow and FocusIn  when KeyMapState selected */
+struct XKeymapEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	byte key_vector[32];
+}	
+
+struct XExposeEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	int x, y;
+	int width, height;
+	int count;		/* if non-zero, at least this many more */
+}
+
+struct XGraphicsExposeEvent{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Drawable drawable;
+	int x, y;
+	int width, height;
+	int count;		/* if non-zero, at least this many more */
+	int major_code;		/* core is CopyArea or CopyPlane */
+	int minor_code;		/* not defined in the core */
+}
+
+struct XNoExposeEvent{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Drawable drawable;
+	int major_code;		/* core is CopyArea or CopyPlane */
+	int minor_code;		/* not defined in the core */
+}
+
+struct XVisibilityEvent{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	VisibilityNotify state;		/* Visibility state */
+}
+
+struct XCreateWindowEvent{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;		/* parent of the window */
+	Window window;		/* window id of window created */
+	int x, y;		/* window location */
+	int width, height;	/* size of window */
+	int border_width;	/* border width */
+	Bool override_redirect;	/* creation should be overridden */
+}
+
+struct XDestroyWindowEvent 
+{
+	int type;
+	uint serial;		/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+}
+
+struct XUnmapEvent
+{
+	int type;
+	uint serial;		/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Bool from_configure;
+}
+
+struct XMapEvent
+{
+	int type;
+	uint serial;		/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Bool override_redirect;	/* Boolean, is override set... */
+}
+
+struct XMapRequestEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+}
+
+struct XReparentEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	Window parent;
+	int x, y;
+	Bool override_redirect;
+}
+
+struct XConfigureEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	Bool override_redirect;
+}
+
+struct XGravityEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	int x, y;
+}
+
+struct XResizeRequestEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	int width, height;
+}
+
+struct  XConfigureRequestEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+	int x, y;
+	int width, height;
+	int border_width;
+	Window above;
+	WindowStackingMethod detail;		/* Above, Below, TopIf, BottomIf, Opposite */
+	uint value_mask;
+}
+
+struct XCirculateEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window event;
+	Window window;
+	CirculationRequest place;		/* PlaceOnTop, PlaceOnBottom */
+}
+
+struct XCirculateRequestEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window parent;
+	Window window;
+	CirculationRequest place;		/* PlaceOnTop, PlaceOnBottom */
+}
+
+struct XPropertyEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom atom;
+	Time time;
+	PropertyNotification state;		/* NewValue, Deleted */
+}
+
+struct XSelectionClearEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom selection;
+	Time time;
+}
+
+struct XSelectionRequestEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window owner;
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property;
+	Time time;
+}
+
+struct XSelectionEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window requestor;
+	Atom selection;
+	Atom target;
+	Atom property;		/* ATOM or None */
+	Time time;
+}
+
+struct XColormapEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Colormap colormap;	/* COLORMAP or None */
+	Bool new_;		/* C++ */
+	ColorMapNotification state;		/* ColormapInstalled, ColormapUninstalled */
+}
+
+struct XClientMessageEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;
+	Atom message_type;
+	int format;
+	union data{
+		byte b[20];
+		short s[10];
+		int l[5];
+		}
+}
+
+struct XMappingEvent
+{
+	int type;
+	uint serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;	/* Display the event was read from */
+	Window window;		/* unused */
+	MappingType request;		/* one of MappingModifier, MappingKeyboard,
+				   MappingPointer */
+	int first_keycode;	/* first keycode */
+	int count;		/* defines range of change w. first_keycode*/
+}
+
+struct XErrorEvent
+{
+	int type;
+	Display *display;	/* Display the event was read from */
+	XID resourceid;		/* resource id */
+	uint serial;	/* serial number of failed request */
+	uint error_code;	/* error code of failed request */
+	ubyte request_code;	/* Major op-code of failed request */
+	ubyte minor_code;	/* Minor op-code of failed request */
+}
+
+struct XAnyEvent 
+{
+	int type;
+	ubyte serial;	/* # of last request processed by server */
+	Bool send_event;	/* true if this came from a SendEvent request */
+	Display *display;/* Display the event was read from */
+	Window window;	/* window on which event was requested in event mask */
+}
+
+union XEvent{
+    int type;		/* must not be changed; first element */
+	XAnyEvent xany;
+	XKeyEvent xkey;
+	XButtonEvent xbutton;
+	XMotionEvent xmotion;
+	XCrossingEvent xcrossing;
+	XFocusChangeEvent xfocus;
+	XExposeEvent xexpose;
+	XGraphicsExposeEvent xgraphicsexpose;
+	XNoExposeEvent xnoexpose;
+	XVisibilityEvent xvisibility;
+	XCreateWindowEvent xcreatewindow;
+	XDestroyWindowEvent xdestroywindow;
+	XUnmapEvent xunmap;
+	XMapEvent xmap;
+	XMapRequestEvent xmaprequest;
+	XReparentEvent xreparent;
+	XConfigureEvent xconfigure;
+	XGravityEvent xgravity;
+	XResizeRequestEvent xresizerequest;
+	XConfigureRequestEvent xconfigurerequest;
+	XCirculateEvent xcirculate;
+	XCirculateRequestEvent xcirculaterequest;
+	XPropertyEvent xproperty;
+	XSelectionClearEvent xselectionclear;
+	XSelectionRequestEvent xselectionrequest;
+	XSelectionEvent xselection;
+	XColormapEvent xcolormap;
+	XClientMessageEvent xclient;
+	XMappingEvent xmapping;
+	XErrorEvent xerror;
+	XKeymapEvent xkeymap;
+	int pad[24];
+}
+
+
+	struct Display {
+		XExtData *ext_data;	/* hook for extension to hang data */
+		_XPrivate *private1;
+		int fd;			/* Network socket. */
+		int private2;
+		int proto_major_version;/* major version of server's X protocol */
+		int proto_minor_version;/* minor version of servers X protocol */
+		char *vendor;		/* vendor of the server hardware */
+	    	XID private3;
+		XID private4;
+		XID private5;
+		int private6;
+		XID function(Display*)resource_alloc;/* allocator function */
+		ByteOrder byte_order;		/* screen byte order, LSBFirst, MSBFirst */
+		int bitmap_unit;	/* padding and data requirements */
+		int bitmap_pad;		/* padding requirements on bitmaps */
+		ByteOrder bitmap_bit_order;	/* LeastSignificant or MostSignificant */
+		int nformats;		/* number of pixmap formats in list */
+		ScreenFormat *pixmap_format;	/* pixmap format list */
+		int private8;
+		int release;		/* release of the server */
+		_XPrivate *private9;
+		_XPrivate *private10;
+		int qlen;		/* Length of input event queue */
+		uint last_request_read; /* seq number of last event read */
+		uint request;	/* sequence number of last request. */
+		XPointer private11;
+		XPointer private12;
+		XPointer private13;
+		XPointer private14;
+		uint max_request_size; /* maximum number 32 bit words in request*/
+		_XrmHashBucketRec *db;
+		int function  (Display*)private15;
+		char *display_name;	/* "host:display" string used on this connect*/
+		int default_screen;	/* default screen for operations */
+		int nscreens;		/* number of screens on this server*/
+		Screen *screens;	/* pointer to list of screens */
+		uint motion_buffer;	/* size of motion buffer */
+		uint private16;
+		int min_keycode;	/* minimum defined keycode */
+		int max_keycode;	/* maximum defined keycode */
+		XPointer private17;
+		XPointer private18;
+		int private19;
+		byte *xdefaults;	/* contents of defaults from server */
+		/* there is more to this structure, but it is private to Xlib */
+	}
+
+struct Depth
+{
+	int depth;		/* this depth (Z) of the depth */
+	int nvisuals;		/* number of Visual types at this depth */
+	Visual *visuals;	/* list of visuals possible at this depth */
+}
+
+typedef void* GC;
+alias int VisualID;
+typedef XID Colormap;
+typedef XID KeySym;
+alias uint KeyCode;
+
+struct Screen{
+	XExtData *ext_data;		/* hook for extension to hang data */
+	Display *display;		/* back pointer to display structure */
+	Window root;			/* Root window id. */
+	int width, height;		/* width and height of screen */
+	int mwidth, mheight;	/* width and height of  in millimeters */
+	int ndepths;			/* number of depths possible */
+	Depth *depths;			/* list of allowable depths on the screen */
+	int root_depth;			/* bits per pixel */
+	Visual *root_visual;	/* root visual */
+	GC default_gc;			/* GC for the root root visual */
+	Colormap cmap;			/* default color map */
+	uint white_pixel;
+	uint black_pixel;		/* White and Black pixel values */
+	int max_maps, min_maps;	/* max and min color maps */
+	int backing_store;		/* Never, WhenMapped, Always */
+	bool save_unders;	
+	int root_input_mask;	/* initial root input mask */
+}
+
+struct Visual
+{
+	XExtData *ext_data;	/* hook for extension to hang data */
+	VisualID visualid;	/* visual id of this visual */
+	int class_;			/* class of screen (monochrome, etc.) */
+	uint red_mask, green_mask, blue_mask;	/* mask values */
+	int bits_per_rgb;	/* log base 2 of distinct color values */
+	int map_entries;	/* color map entries */
+}
+
+	alias Display* _XPrivDisplay;
+
+	Screen* ScreenOfDisplay(Display* dpy, int scr) {
+		return (&(cast(_XPrivDisplay)dpy).screens[scr]);
+	}
+
+	Window	RootWindow(Display *dpy,int scr) {
+		return ScreenOfDisplay(dpy,scr).root;
+	}
+
+	int DefaultScreen(Display *dpy) {
+		return dpy.default_screen;
+	}
+
+	Visual* DefaultVisual(Display *dpy,int scr) {
+		return ScreenOfDisplay(dpy,scr).root_visual;
+	}
+
+	GC DefaultGC(Display *dpy,int scr) {
+		return ScreenOfDisplay(dpy,scr).default_gc;
+	}
+
+	uint BlackPixel(Display *dpy,int scr) {
+		return ScreenOfDisplay(dpy,scr).black_pixel;
+	}
+
+	uint WhitePixel(Display *dpy,int scr) {
+		return ScreenOfDisplay(dpy,scr).white_pixel;
+	}
+
+	int XDrawString(Display*, Drawable, GC, int, int, in char*, int);
+	int XDrawLine(Display*, Drawable, GC, int, int, int, int);
+	int XDrawRectangle(Display*, Drawable, GC, int, int, uint, uint);
+	int XDrawArc(Display*, Drawable, GC, int, int, uint, uint, int, int);
+	int XFillRectangle(Display*, Drawable, GC, int, int, uint, uint);
+	int XFillArc(Display*, Drawable, GC, int, int, uint, uint, int, int);
+	int XDrawPoint(Display*, Drawable, GC, int, int);
+	int XSetForeground(Display*, GC, uint);
+	int XSetBackground(Display*, GC, uint);
+
+	GC XCreateGC(Display*, Drawable, uint, void*);
+	int XCopyGC(Display*, GC, uint, GC);
+	int XFreeGC(Display*, GC);
+
+	bool XCheckWindowEvent(Display*, Window, int, XEvent*);
+	bool XCheckMaskEvent(Display*, int, XEvent*);
+
+	int XPending(Display*);
+
+	Pixmap XCreatePixmap(Display*, Drawable, uint, uint, uint);
+	int XFreePixmap(Display*, Pixmap);
+	int XCopyArea(Display*, Drawable, Drawable, GC, int, int, uint, uint, int, int);
+	int XFlush(Display*);
+
+	struct XPoint {
+		short x;
+		short y;
+	}
+
+	int XDrawLines(Display*, Drawable, GC, XPoint*, int, CoordMode);
+	int XFillPolygon(Display*, Drawable, GC, XPoint*, int, PolygonShape, CoordMode);
+
+	enum CoordMode:int {
+		CoordModeOrigin = 0,
+		CoordModePrevious = 1
+	}
+
+	enum PolygonShape:int {
+		Complex = 0,
+		Nonconvex = 1,
+		Convex = 2
+	}
+
+	struct XTextProperty {
+		const(char)* value;		/* same as Property routines */
+		Atom encoding;			/* prop type */
+		int format;				/* prop data format: 8, 16, or 32 */
+		uint nitems;		/* number of data items in value */
+	}
+
+	void XSetWMName(Display*, Window, XTextProperty*);
+
+	enum Atom XA_STRING = 31;
+
+} else static assert(0, "Unsupported operating system");