From 83ebf1db399387170d6c224f18a0cbe404d2ea90 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Fri, 25 Mar 2016 07:35:09 +0000
Subject: [PATCH 01/31] Removing tree inconsistencies

Leftover bad links to detached/moved nodes. A few times I think a link back was needed, to remove it from the list. Some last/first child nodes not getting updated.
---
 src/html/dom.d | 40 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 37 insertions(+), 3 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 068c00a..425c6cc 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -325,7 +325,9 @@ struct Node {
 			assert(!lastChild_);
 			firstChild_ = node;
 			lastChild_ = node;
+			lastChild_.next_ = null;
 		}
+		firstChild_.prev_ = null;
 	}
 
 	void appendChild(Node* node) {
@@ -343,8 +345,10 @@ struct Node {
 		} else {
 			assert(!firstChild_);
 			firstChild_ = node;
+			firstChild_.prev_ = null;
 			lastChild_ = node;
 		}
+		lastChild_.next_ = null;
 	}
 
 	void removeChild(Node* node) {
@@ -391,19 +395,25 @@ struct Node {
 			firstChild_ = node;
 			lastChild_ = node;
 		}
+		lastChild_.next_ = null;
 		node.parent_ = &this;
 	}
 
 	void insertBefore(Node* node) {
 		assert(document_ == node.document_);
-
+		assert(node);
+		
 		parent_ = node.parent_;
 		prev_ = node.prev_;
 		next_ = node;
 		node.prev_ = &this;
 
-		if (parent_ && (parent_.firstChild_ == node))
-			parent_.firstChild_ = &this;
+		if (parent_ && (parent_.firstChild_ == node)) {
+		  assert(!prev_);
+		  parent_.firstChild_ = &this;
+		} else if(prev_) {
+		  prev_.next_ = &this;
+		}
 	}
 
 	void insertAfter(Node* node) {
@@ -413,6 +423,12 @@ struct Node {
 		prev_ = node;
 		next_ = node.next_;
 		node.next_ = &this;
+		if(parent_ && (parent_.lastChild_ == node)) {
+		  assert(!next_);
+		  parent_.lastChild_ = &this;
+		} else if(next_) {
+		  next_.prev_ = &this;
+		}
 	}
 
 	void detach() {
@@ -444,7 +460,16 @@ struct Node {
 				prev_ = null;
 			}
 			parent_ = null;
+		} else {
+		  if(prev_) {
+			prev_.next_ = next_;
+		  }
+		  if(next_) {
+			next_.prev_ = prev_;
+		  }
 		}
+		prev_ = null;
+		next_ = null;
 	}
 
 	package void detachFast() {
@@ -471,7 +496,16 @@ struct Node {
 					next_.prev_ = prev_;
 				}
 			}
+		} else {
+		  if(prev_) {
+			prev_.next_ = next_;
+		  }
+		  if(next_) {
+			next_.prev_ = prev_;
+		  }
 		}
+		prev_ = null;
+		next_ = null;
 	}
 
 	void destroy() {

From d909c7a1a685913773575e4e9c53432e378d631e Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Sun, 27 Mar 2016 06:10:19 +0000
Subject: [PATCH 02/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/dom.d) 50 902

---
 src/html/dom.d | 55 ++++++++++++++++++++++++++++++++++----------------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 425c6cc..71712ca 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -100,6 +100,8 @@ private struct AncestorsForward(NodeType, alias Condition = null) {
 private struct DescendantsDFForward(NodeType, alias Condition = null) {
 	this(NodeType* first) {
 		curr_ = first;
+			import std.stdio : writeln;
+			writeln("mocukent ",curr_.document_);
 		top_ = (first && first.parent_) ? first.parent_ : null;
 		static if (!is(typeof(Condition) == typeof(null))) {
 			if (!Condition(first))
@@ -331,6 +333,10 @@ struct Node {
 	}
 
 	void appendChild(Node* node) {
+		if(document_ != node.document_) {
+			import std.stdio;
+			writeln("oyyy ",document_," ",node.document_);
+		}	
 		assert(document_ == node.document_);
 		assert(isElementNode, "cannot append to non-element nodes");
 
@@ -402,7 +408,7 @@ struct Node {
 	void insertBefore(Node* node) {
 		assert(document_ == node.document_);
 		assert(node);
-		
+
 		parent_ = node.parent_;
 		prev_ = node.prev_;
 		next_ = node;
@@ -830,7 +836,7 @@ struct Node {
 		return document_.clone(&this);
 	}
 
-package:
+public:/*package:*/
 	enum TypeMask	= 0x7;
 	enum TypeShift	= 0;
 	enum FlagsBit	= TypeMask + 1;
@@ -853,7 +859,7 @@ package:
 	Document* document_;
 }
 
-auto createDocument(size_t options = DOMCreateOptions.Default)(HTMLString source) {
+auto ref createDocument(size_t options = DOMCreateOptions.Default)(HTMLString source) {
 	enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
 
 	auto document = createDocument();
@@ -913,15 +919,16 @@ unittest {
 
 
 
-static auto createDocument() {
-	auto document = Document();
-	document.init();
+static auto ref createDocument() {
+	auto document = new Document;
+	document.initialize();
 	document.root(document.createElement("root"));
 	return document;
 }
 
 
 struct Document {
+	@disable this(this);
 	auto createElement(HTMLString tagName, Node* parent = null) {
 		auto node = alloc_.alloc();
 		*node = Node(&this, tagName);
@@ -984,9 +991,9 @@ struct Document {
 		return source.clone(&this);
 	}
 
-	Document clone() const {
-		Document other = Document();
-		other.init();
+	Document* clone() const {
+		Document* other = new Document;
+		other.initialize();
 		other.root(other.clone(this.root_));
 		return other;
 	}
@@ -1039,8 +1046,9 @@ struct Document {
 
 	NodeWrapper!(const(Node)) querySelector(Selector selector, const(Node)* context = null) const {
 		auto top = context ? context : root_;
-
 		foreach(node; DescendantsDFForward!(const(Node), mixin(OnlyElements))(top)) {
+			assert(node.document_ == top.document_);
+			assert(&this == node.document_);
 			if (selector.matches(node))
 				return node;
 		}
@@ -1051,6 +1059,8 @@ struct Document {
 		auto top = context ? context : root_;
 
 		foreach(node; DescendantsDFForward!(Node, mixin(OnlyElements))(top)) {
+			assert(node.document_ == top.document_);
+			assert(&this == node.document_);
 			if (selector.matches(node))
 				return node;
 		}
@@ -1077,6 +1087,8 @@ struct Document {
 
 	QuerySelectorAllResult querySelectorAll(Selector selector, Node* context = null) {
 		auto top = context ? context : root_;
+			import std.stdio : writeln;
+			writeln("dockent ",top.document_,context);
 		return QuerySelectorMatcher!(Node, DescendantsDFForward!Node)(selector, DescendantsDFForward!Node(top));
 	}
 
@@ -1094,8 +1106,8 @@ struct Document {
 		return alloc_;
 	}
 
-private:
-	void init() {
+public:/*private:*/
+	void initialize() {
 		alloc_.init;
 	}
 
@@ -1135,10 +1147,19 @@ unittest {
 	assert(docc.root.html == doc.root.html, docc.root.html);
 }
 
+unittest {
+  auto foo() {
+	return createDocument();
+  }
+
+  auto bar = foo();
+  bar.root.appendChild(bar.createElement("yay"));
+}
+
 
 struct DOMBuilder(Document) {
-	this(ref Document document, Node* parent = null) {
-		document_ = &document;
+	this(Document* document, Node* parent = null) {
+		document_ = document;
 		element_ = parent ? parent : document.root;
 	}
 
@@ -1260,7 +1281,7 @@ struct DOMBuilder(Document) {
 		}
 	}
 
-private:
+public:/*private:*/
 	Document* document_;
 	Node* element_;
 	States state_;
@@ -1543,7 +1564,7 @@ private struct Rule {
 		return relation_;
 	}
 
-package:
+public:/*package:*/
 	ushort flags_;
 	MatchType match_;
 	Relation relation_;
@@ -1922,7 +1943,7 @@ struct Selector {
 		return true;
 	}
 
-private:
+public:/*private:*/
 	HTMLString source_;
 	Rule[] rules_;
 }

From 786a80048749d2852e9cc9481183a9ce690843de Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Mon, 28 Mar 2016 23:17:19 +0000
Subject: [PATCH 03/31] leave entities to character parsers

---
 src/html/dom.d    | 42 ++++++++++++++++++++++++++----------------
 src/html/parser.d |  6 +++++-
 2 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 71712ca..d943c84 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -100,8 +100,6 @@ private struct AncestorsForward(NodeType, alias Condition = null) {
 private struct DescendantsDFForward(NodeType, alias Condition = null) {
 	this(NodeType* first) {
 		curr_ = first;
-			import std.stdio : writeln;
-			writeln("mocukent ",curr_.document_);
 		top_ = (first && first.parent_) ? first.parent_ : null;
 		static if (!is(typeof(Condition) == typeof(null))) {
 			if (!Condition(first))
@@ -294,8 +292,7 @@ struct Node {
 		enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
 
 		destroyChildren();
-
-		auto builder = DOMBuilder!(Document)(*document_, &this);
+		auto builder = DOMBuilder!(Document)(document_, &this);
 		parseHTML!(typeof(builder), parserOptions)(html, builder);
 	}
 
@@ -440,6 +437,7 @@ struct Node {
 	void detach() {
 		if (parent_) {
 			if (parent_.firstChild_ == &this) {
+			  assert(!prev_);
 				parent_.firstChild_ = next_;
 				if (next_) {
 					next_.prev_ = null;
@@ -564,7 +562,7 @@ struct Node {
 			}
 			break;
 		case Text:
-			writeHTMLEscaped(app, tag_);
+		  app.put(tag_);
 			break;
 		case Comment:
 			app.put("<!--");
@@ -601,7 +599,7 @@ struct Node {
 
 				if (value.length) {
 					app.put("=\"");
-					writeHTMLEscaped(app, value);
+					app.put(value);
 					app.put("\"");
 				}
 			}
@@ -864,14 +862,18 @@ auto ref createDocument(size_t options = DOMCreateOptions.Default)(HTMLString so
 
 	auto document = createDocument();
 	auto builder = DOMBuilder!(Document)(document);
-
-	parseHTML!(typeof(builder), parserOptions)(source, builder);
+	import std.stdio;
+	parseHTML!(typeof(builder), parserOptions | ParserOptions.ParseEntities)(source, builder);
 	return document;
 }
 
 unittest {
-	auto doc = createDocument(`<html><body>&nbsp;</body></html>`);
-	assert(doc.root.outerHTML == `<root><html><body>&#160;</body></html></root>`);
+  import std.stdio;
+  auto doc = createDocument!(DOMCreateOptions.None)("");
+  doc.root.html("It's");
+  writeln(doc.root.html);
+	doc = createDocument(`<html><body>&nbsp;</body></html>`);
+	assert(doc.root.outerHTML == `<root><html><body>&#160;</body></html></root>`,doc.root.outerHTML);
 	doc = createDocument!(DOMCreateOptions.None)(`<html><body>&nbsp;</body></html>`);
 	assert(doc.root.outerHTML == `<root><html><body>&amp;nbsp;</body></html></root>`);
 	doc = createDocument(`<script>&nbsp;</script>`);
@@ -1087,8 +1089,6 @@ struct Document {
 
 	QuerySelectorAllResult querySelectorAll(Selector selector, Node* context = null) {
 		auto top = context ? context : root_;
-			import std.stdio : writeln;
-			writeln("dockent ",top.document_,context);
 		return QuerySelectorMatcher!(Node, DescendantsDFForward!Node)(selector, DescendantsDFForward!Node(top));
 	}
 
@@ -1156,8 +1156,12 @@ unittest {
   bar.root.appendChild(bar.createElement("yay"));
 }
 
-
 struct DOMBuilder(Document) {
+  invariant {
+	assert(document_ !is null);
+	assert(element_ !is null);
+	assert(element_.document_ !is null);
+  }
 	this(Document* document, Node* parent = null) {
 		document_ = document;
 		element_ = parent ? parent : document.root;
@@ -1181,7 +1185,6 @@ struct DOMBuilder(Document) {
 			element_.appendText(text_);
 			text_.length = 0;
 		}
-
 		auto element = document_.createElement(data, element_);
 		element_ = element;
 	}
@@ -1238,7 +1241,7 @@ struct DOMBuilder(Document) {
 	}
 
 	void onComment(HTMLString data) {
-		document_.createCommentNode(data, element_);
+	  document_.createCommentNode(data, element_);
 	}
 
 	void onDeclaration(HTMLString data) {
@@ -1259,7 +1262,8 @@ struct DOMBuilder(Document) {
 				element_.appendText(text_);
 				text_.length = 0;
 			} else {
-				document_.root.appendText(text_);
+
+			  document_.root.appendText(text_);
 			}
 		}
 	}
@@ -1274,6 +1278,12 @@ struct DOMBuilder(Document) {
 	}
 
 	void onEntity(HTMLString data, HTMLString decoded) {
+	  
+	  import std.stdio; writeln("derp",data,decoded);
+	  auto app = appender!string ;
+	  writeHTMLEscaped(app,decoded);
+	  writeln(app.data);
+
 		if (state_ == States.Global) {
 			text_ ~= decoded;
 		} else {
diff --git a/src/html/parser.d b/src/html/parser.d
index f6c7467..dbb93e0 100644
--- a/src/html/parser.d
+++ b/src/html/parser.d
@@ -7,6 +7,7 @@ import std.ascii;
 import std.conv;
 import std.traits;
 
+import html.entities : bytes_;
 import html.entities;
 import html.utils;
 
@@ -114,7 +115,10 @@ private auto parseNamedEntity(Handler, size_t options)(ref const(char)* start, r
 			handler.onNamedEntity(name);
 			static if ((options & ParserOptions.DecodeEntities) != 0) {
 				auto offset = codeOffset(*pindex);
-				handler.onEntity(name, cast(const(char)[])bytes_[offset..offset + codeLength(*pindex)]);
+				auto decoded = appender!string;
+				writeHTMLEscaped(decoded,
+								 cast(const(char)[])bytes_[offset..offset + codeLength(*pindex)]);
+				handler.onEntity(name, decoded.data);
 			}
 
 			start += 1 + name.length;

From 91e48562fc65b69c33be7ac8f206261b6961ed71 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Mon, 28 Mar 2016 23:43:11 +0000
Subject: [PATCH 04/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/parser.d) 269 6475

---
 src/html/dom.d    |  25 +---
 src/html/parser.d | 338 ++++------------------------------------------
 2 files changed, 29 insertions(+), 334 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index d943c84..1d7c026 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -19,7 +19,7 @@ enum DOMCreateOptions {
 	None = 0,
 	DecodeEntities  = 1 << 0,
 
-	Default = DecodeEntities,
+	Default = None,
 }
 
 
@@ -862,18 +862,13 @@ auto ref createDocument(size_t options = DOMCreateOptions.Default)(HTMLString so
 
 	auto document = createDocument();
 	auto builder = DOMBuilder!(Document)(document);
-	import std.stdio;
 	parseHTML!(typeof(builder), parserOptions | ParserOptions.ParseEntities)(source, builder);
 	return document;
 }
 
 unittest {
-  import std.stdio;
-  auto doc = createDocument!(DOMCreateOptions.None)("");
-  doc.root.html("It's");
-  writeln(doc.root.html);
-	doc = createDocument(`<html><body>&nbsp;</body></html>`);
-	assert(doc.root.outerHTML == `<root><html><body>&#160;</body></html></root>`,doc.root.outerHTML);
+  auto doc = createDocument(`<html><body>&nbsp;</body></html>`);
+	assert(doc.root.outerHTML == `<root><html><body>&nbsp;</body></html></root>`,doc.root.outerHTML);
 	doc = createDocument!(DOMCreateOptions.None)(`<html><body>&nbsp;</body></html>`);
 	assert(doc.root.outerHTML == `<root><html><body>&amp;nbsp;</body></html></root>`);
 	doc = createDocument(`<script>&nbsp;</script>`);
@@ -1277,20 +1272,6 @@ struct DOMBuilder(Document) {
 	void onHexEntity(HTMLString data) {
 	}
 
-	void onEntity(HTMLString data, HTMLString decoded) {
-	  
-	  import std.stdio; writeln("derp",data,decoded);
-	  auto app = appender!string ;
-	  writeHTMLEscaped(app,decoded);
-	  writeln(app.data);
-
-		if (state_ == States.Global) {
-			text_ ~= decoded;
-		} else {
-			value_ ~= decoded;
-		}
-	}
-
 public:/*private:*/
 	Document* document_;
 	Node* element_;
diff --git a/src/html/parser.d b/src/html/parser.d
index dbb93e0..508aca2 100644
--- a/src/html/parser.d
+++ b/src/html/parser.d
@@ -7,8 +7,6 @@ import std.ascii;
 import std.conv;
 import std.traits;
 
-import html.entities : bytes_;
-import html.entities;
 import html.utils;
 
 
@@ -41,13 +39,6 @@ private enum ParserStates {
 	PostComment1,
 	PostComment2,
 
-	// entities
-	PreEntity,
-	PreNumericEntity,
-	NamedEntity,
-	NumericEntity,
-	HexEntity,
-
 	// cdata
 	PreCDATA,
 	PreCDATA_C,
@@ -91,88 +82,10 @@ private enum ParserTextStates {
 
 
 enum ParserOptions {
-	ParseEntities   = 1 << 0,
-	DecodeEntities  = 1 << 1,
-
 	None = 0,
-	Default = ParseEntities | DecodeEntities,
-}
-
-
-private auto parseNamedEntity(Handler, size_t options)(ref const(char)* start, ref const(char)* ptr, ref Handler handler) {
-	auto length = ptr - start - 1;
-	if (start[1+length-1] == ';')
-		--length;
-
-	if (!length)
-		return false;
-
-	auto limit = min(1+MaxLegacyEntityNameLength, length);
-	auto name = start[1..1+length];
-
-	while (true) {
-		if (auto pindex = name in index_) {
-			handler.onNamedEntity(name);
-			static if ((options & ParserOptions.DecodeEntities) != 0) {
-				auto offset = codeOffset(*pindex);
-				auto decoded = appender!string;
-				writeHTMLEscaped(decoded,
-								 cast(const(char)[])bytes_[offset..offset + codeLength(*pindex)]);
-				handler.onEntity(name, decoded.data);
-			}
-
-			start += 1 + name.length;
-			return true;
-		} else {
-			if (limit <= MinEntityNameLength)
-				return false;
-			--limit;
-			name = start[1..1+limit];
-			continue;
-		}
-	}
-}
-
-private auto parseNumericEntity(Handler, size_t options)(ref const(char)* start, ref const(char)* ptr, ref Handler handler) {
-	auto length = (ptr - start) - 2;
-	if (start[1+length-1] == ';')
-		--length;
-
-	if (!length)
-		return false;
-	auto name = start[2..2+length];
-	handler.onNumericEntity(name);
-
-	static if ((options & ParserOptions.DecodeEntities) != 0) {
-		auto cname = name[0..min(8, name.length)];
-		auto code = parse!uint(cname, 10);
-		handler.onEntity(start[2..2+length], decodeCodePoint(code));
-	}
-
-	start = ptr;
-	return true;
+	Default = None
 }
 
-private auto parseHexEntity(Handler, size_t options)(ref const(char)* start, ref const(char)* ptr, ref Handler handler) {
-	auto length = (ptr - start) - 3;
-	if (start[1+length-1] == ';')
-		--length;
-
-	if (!length)
-		return false;
-
-	auto name = start[3..3+length];
-	handler.onHexEntity(name);
-
-	static if ((options & ParserOptions.DecodeEntities) != 0) {
-		auto cname = name[0..min(6, name.length)];
-		auto code = parse!uint(cname, 16);
-		handler.onEntity(name, decodeCodePoint(code));
-	}
-
-	start = ptr;
-	return true;
-}
 
 void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] source, ref Handler handler) {
 	auto ptr = source.ptr;
@@ -183,22 +96,14 @@ void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] so
 	ParserStates saved = ParserStates.Text;
 	ParserTextStates textState = ParserTextStates.Normal;
 
-	enum ParseEntities = (options & (ParserOptions.ParseEntities | ParserOptions.DecodeEntities)) != 0;
-	enum DecodeEntities = (options & ParserOptions.DecodeEntities) != 0;
-
 	while (ptr != end) {
 		final switch(state) with (ParserStates) {
 		case Text:
 			final switch (textState) with (ParserTextStates) {
 			case Normal:
-				static if (ParseEntities) {
-					while ((ptr != end) && (*ptr != '<') && (*ptr != '&'))
-						++ptr;
-				} else {
-					while ((ptr != end) && (*ptr != '<'))
-						++ptr;
-				}
-				break;
+			  while ((ptr != end) && (*ptr != '<'))
+				++ptr;
+			  break;
 			case Script:
 			case Style:
 				while ((ptr != end) && ((*ptr != '<') || (ptr + 1 == end) || (*(ptr + 1) != '/')))
@@ -207,26 +112,11 @@ void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] so
 			if (ptr == end)
 				continue;
 
-			static if (ParseEntities) {
-				auto noEntity = *ptr != '&';
-			} else {
-				enum noEntity = true;
-			}
 
-			if (noEntity) {
-				if (start != ptr)
-					handler.onText(start[0..ptr-start]);
-				state = PreTagName;
-				start = ptr;
-			} else {
-				static if (ParseEntities) {
-					if (start != ptr)
-						handler.onText(start[0..ptr-start]);
-					saved = state;
-					state = PreEntity;
-					start = ptr;
-				}
-			}
+			if (start != ptr)
+			  handler.onText(start[0..ptr-start]);
+			state = PreTagName;
+			start = ptr;
 			break;
 
 		case PreTagName:
@@ -424,100 +314,39 @@ void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] so
 			break;
 
 		case AttrValueDQ:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != '\"') && (*ptr != '&'))
-					++ptr;
-			} else {
-				while ((ptr != end) && (*ptr != '\"'))
-					++ptr;
-			}
+		  while ((ptr != end) && (*ptr != '\"'))
+			++ptr;
+		  
 			if (ptr == end)
 				continue;
 
-			static if (ParseEntities) {
-				auto noEntity = *ptr != '&';
-			} else {
-				enum noEntity = true;
-			}
-
-			if (noEntity) {
-				handler.onAttrValue(start[0..ptr-start]);
-				handler.onAttrEnd();
-				state = PreAttrName;
-			} else {
-				static if (ParseEntities) {
-					if (start != ptr)
-						handler.onAttrValue(start[0..ptr-start]);
-					saved = state;
-					state = PreEntity;
-					start = ptr;
-				}
-			}
+			handler.onAttrValue(start[0..ptr-start]);
+			handler.onAttrEnd();
+			state = PreAttrName;
 			break;
 
 		case AttrValueSQ:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != '\'') && (*ptr != '&'))
-					++ptr;
-			} else {
-				while ((ptr != end) && (*ptr != '\''))
-					++ptr;
-			}
+		  while ((ptr != end) && (*ptr != '\''))
+			++ptr;
+
 			if (ptr == end)
 				continue;
 
-			static if (ParseEntities) {
-				auto noEntity = *ptr != '&';
-			} else {
-				enum noEntity = true;
-			}
-
-			if (noEntity) {
-				handler.onAttrValue(start[0..ptr-start]);
-				handler.onAttrEnd();
-				state = PreAttrName;
-			} else {
-				static if (ParseEntities) {
-					if (start != ptr)
-						handler.onAttrValue(start[0..ptr-start]);
-					saved = state;
-					state = PreEntity;
-					start = ptr;
-				}
-			}
+			handler.onAttrValue(start[0..ptr-start]);
+			handler.onAttrEnd();
+			state = PreAttrName;
 			break;
 
 		case AttrValueNQ:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != '>') && (*ptr != '&') && !isSpace(*ptr))
-					++ptr;
-			} else {
-				while ((ptr != end) && (*ptr != '>') && !isSpace(*ptr))
-					++ptr;
-			}
+		  while ((ptr != end) && (*ptr != '>') && !isSpace(*ptr))
+			++ptr;
+
 			if (ptr == end)
 				continue;
 
-			static if (ParseEntities) {
-				auto noEntity = *ptr != '&';
-			} else {
-				enum noEntity = true;
-			}
-
-			if (noEntity) {
-				handler.onAttrValue(start[0..ptr-start]);
-				handler.onAttrEnd();
-				state = PreAttrName;
-			} else {
-				static if (ParseEntities) {
-					if (start != ptr)
-						handler.onAttrValue(start[0..ptr-start]);
-					saved = state;
-					state = PreEntity;
-					start = ptr;
-					break;
-				}
-			}
+			handler.onAttrValue(start[0..ptr-start]);
+			handler.onAttrEnd();
+			state = PreAttrName;
 			continue;
 
 		case PreComment:
@@ -666,91 +495,6 @@ void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] so
 			start = ptr + 1;
 			break;
 
-		case PreEntity:
-			static if (ParseEntities) {
-				if (*ptr == '#') {
-					state = PreNumericEntity;
-					break;
-				} else {
-					state = NamedEntity;
-					continue;
-				}
-			} else {
-				assert(0, "should never get here!");
-			}
-
-		case NamedEntity:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != ';') && isAlphaNum(*ptr) && (ptr - start < MaxEntityNameLength))
-					++ptr;
-				if (ptr == end)
-					continue;
-
-				if ((saved == Text) || (*ptr != '=')) {
-					if (parseNamedEntity!(Handler, options)(start, ptr, handler)) {
-						if (*start == ';')
-							++start;
-					}
-				}
-				state = saved;
-
-				if (*ptr == ';') break;
-				else continue;
-			} else {
-				break;
-			}
-
-		case PreNumericEntity:
-			static if (ParseEntities) {
-				if ((*ptr == 'X') || (*ptr == 'x')) {
-					state = HexEntity;
-					break;
-				} else {
-					state = NumericEntity;
-					continue;
-				}
-			} else {
-				assert(0, "should never get here!");
-			}
-
-		case NumericEntity:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != ';') && isDigit(*ptr))
-					++ptr;
-				if (ptr == end)
-					continue;
-
-				state = saved;
-				if (parseNumericEntity!(Handler, options)(start, ptr, handler)) {
-					if (*start == ';')
-						++start;
-				}
-
-				if (*ptr == ';') break;
-				else continue;
-			} else {
-				break;
-			}
-
-		case HexEntity:
-			static if (ParseEntities) {
-				while ((ptr != end) && (*ptr != ';') && isHexDigit(*ptr))
-					++ptr;
-				if (ptr == end)
-					continue;
-
-				state = saved;
-				if (parseHexEntity!(Handler, options)(start, ptr, handler)) {
-					if (*start == ';')
-						++start;
-				}
-
-				if (*ptr == ';') break;
-				else continue;
-			} else {
-				break;
-			}
-
 		case PreScript_SC:
 			if ((*ptr == 'r') || (*ptr == 'R')) {
 				state = PreScript_SCR;
@@ -929,36 +673,6 @@ void parseHTML(Handler, size_t options = ParserOptions.Default)(const(char)[] so
 		case PostComment2:
 			handler.onComment(remaining[0..$-2]);
 			break;
-		case NamedEntity:
-			static if (ParseEntities) {
-				if (saved == Text) {
-					if (ptr-start > 1)
-						parseNamedEntity!(Handler, options)(start, ptr, handler);
-					if (start < ptr)
-						handler.onText(start[0..ptr-start]);
-				}
-			}
-			break;
-		case NumericEntity:
-			static if (ParseEntities) {
-				if (saved == Text) {
-					if (ptr-start > 2)
-						parseNumericEntity!(Handler, options)(start, ptr, handler);
-					if (start < ptr)
-						handler.onText(start[0..ptr-start]);
-				}
-			}
-			break;
-		case HexEntity:
-			static if (ParseEntities) {
-				if (saved == Text) {
-					if (ptr-start > 3)
-						parseHexEntity!(Handler, options)(start, ptr, handler);
-					if (start < ptr)
-						handler.onText(start[0..ptr-start]);
-				}
-			}
-			break;
 		default:
 			if ((state != TagName) &&
 				(state != PreAttrName) &&

From 7c357e4c56ff93ce96b1343d4c116f88facf46f9 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 01:18:09 +0000
Subject: [PATCH 05/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 52 1629

---
 src/html/dom.d    | 29 ++++++-----------------------
 src/html/escape.d | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 23 deletions(-)
 create mode 100644 src/html/escape.d

diff --git a/src/html/dom.d b/src/html/dom.d
index 1d7c026..78b6e91 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -17,8 +17,6 @@ alias HTMLString = const(char)[];
 
 enum DOMCreateOptions {
 	None = 0,
-	DecodeEntities  = 1 << 0,
-
 	Default = None,
 }
 
@@ -289,8 +287,6 @@ struct Node {
 	@property void html(size_t options = DOMCreateOptions.Default)(HTMLString html) {
 		assert(isElementNode, "cannot add html to non-element nodes");
 
-		enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
-
 		destroyChildren();
 		auto builder = DOMBuilder!(Document)(document_, &this);
 		parseHTML!(typeof(builder), parserOptions)(html, builder);
@@ -858,19 +854,15 @@ public:/*package:*/
 }
 
 auto ref createDocument(size_t options = DOMCreateOptions.Default)(HTMLString source) {
-	enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
-
 	auto document = createDocument();
 	auto builder = DOMBuilder!(Document)(document);
-	parseHTML!(typeof(builder), parserOptions | ParserOptions.ParseEntities)(source, builder);
+	parseHTML!(typeof(builder))(source, builder);
 	return document;
 }
 
 unittest {
   auto doc = createDocument(`<html><body>&nbsp;</body></html>`);
 	assert(doc.root.outerHTML == `<root><html><body>&nbsp;</body></html></root>`,doc.root.outerHTML);
-	doc = createDocument!(DOMCreateOptions.None)(`<html><body>&nbsp;</body></html>`);
-	assert(doc.root.outerHTML == `<root><html><body>&amp;nbsp;</body></html></root>`);
 	doc = createDocument(`<script>&nbsp;</script>`);
 	assert(doc.root.outerHTML == `<root><script>&nbsp;</script></root>`, doc.root.outerHTML);
 	doc = createDocument(`<style>&nbsp;</style>`);
@@ -907,11 +899,11 @@ unittest {
 
 unittest {
 	const doc = createDocument(`<html><body><div>&nbsp;</div></body></html>`);
-	assert(doc.root.find("html").front.outerHTML == `<html><body><div>&#160;</div></body></html>`);
-	assert(doc.root.find("html").front.find("div").front.outerHTML == `<div>&#160;</div>`);
-	assert(doc.root.find("body").front.outerHTML == `<body><div>&#160;</div></body>`);
-	assert(doc.root.find("body").front.closest("body").outerHTML == `<body><div>&#160;</div></body>`); // closest() tests self
-	assert(doc.root.find("body").front.closest("html").outerHTML == `<html><body><div>&#160;</div></body></html>`);
+	assert(doc.root.find("html").front.outerHTML == `<html><body><div>&nbsp;</div></body></html>`);
+	assert(doc.root.find("html").front.find("div").front.outerHTML == `<div>&nbsp;</div>`);
+	assert(doc.root.find("body").front.outerHTML == `<body><div>&nbsp;</div></body>`);
+	assert(doc.root.find("body").front.closest("body").outerHTML == `<body><div>&nbsp;</div></body>`); // closest() tests self
+	assert(doc.root.find("body").front.closest("html").outerHTML == `<html><body><div>&nbsp;</div></body></html>`);
 }
 
 
@@ -1263,15 +1255,6 @@ struct DOMBuilder(Document) {
 		}
 	}
 
-	void onNamedEntity(HTMLString data) {
-	}
-
-	void onNumericEntity(HTMLString data) {
-	}
-
-	void onHexEntity(HTMLString data) {
-	}
-
 public:/*private:*/
 	Document* document_;
 	Node* element_;
diff --git a/src/html/escape.d b/src/html/escape.d
new file mode 100644
index 0000000..1efccd7
--- /dev/null
+++ b/src/html/escape.d
@@ -0,0 +1,37 @@
+enum HTMLEscapes {
+  lt = '<',
+  gt = '>',
+};
+
+enum AttributeEscapes {
+  quot = '"',
+  
+
+string checkEscapes() {
+  return q{
+	if(chunk.startsWith("%1$s;")) {
+	  result.put("%2$s");
+	  result.put(chunk["%1$s;".length:$]);
+	} else
+  }.format(match,replacement);
+}
+	  
+
+auto unescape(bool unicode = true,
+			  bool html = false,
+			  bool attribute = false)
+  (HTMLstring s) {
+  appender!HTMLstring result;
+  auto chunks = s.splitter("&");
+  if(chunks.empty) return s;
+  chunks.popFront();
+  if(chunks.empty) return s;
+  
+  foreach(chunk; chunks) {
+	mixin checkEscape("lt")
+	  mixin checkEscape("gt")
+	  mixin checkEscape("
+	static if(html) {
+	  if(chunk.startsWith("lt;"
+	  
+	

From 1ad5200fb52fb6776a1eaf80591470202a005ebb Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 02:08:29 +0000
Subject: [PATCH 06/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 77 1486

---
 src/html/escape.d | 91 ++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 75 insertions(+), 16 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 1efccd7..1c7708f 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -5,17 +5,31 @@ enum HTMLEscapes {
 
 enum AttributeEscapes {
   quot = '"',
-  
+  apos = '\'',
+}
 
-string checkEscapes() {
-  return q{
-	if(chunk.startsWith("%1$s;")) {
-	  result.put("%2$s");
-	  result.put(chunk["%1$s;".length:$]);
-	} else
-  }.format(match,replacement);
+string checkEnum(alias Escapes, bool escape = true)(string s) {
+  for(e;EnumMembers!Escapes) {
+	static if(escape) {
+	  app.put(q{
+		  if(chunk.startsWith("%1$s")) {
+			result.put("&%2$s;");
+			result.put(chunk["%1$s".length:$]);
+			continue;
+		  }
+		}.format(to!wchar(e),to!string(e)));
+	} else {
+	  app.put(q{
+		  if(chunk.startsWith("%1$s;")) {
+			result.put("%2$s");
+			result.put(chunk["%1$s;".length:$]);
+			continue;
+		  }
+		}.format(to!string(e),to!wchar(e)));
+	}
+  }
+  return app.data;
 }
-	  
 
 auto unescape(bool unicode = true,
 			  bool html = false,
@@ -26,12 +40,57 @@ auto unescape(bool unicode = true,
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
-  
+
   foreach(chunk; chunks) {
-	mixin checkEscape("lt")
-	  mixin checkEscape("gt")
-	  mixin checkEscape("
+	if(chunk.length == 0) {
+	  app.put("&");
+	  continue;
+	}
 	static if(html) {
-	  if(chunk.startsWith("lt;"
-	  
-	
+	  mixin checkEscapes!(HTMLEscapes,false);
+	}
+	static if(attribute) {
+	  mixin checkEscapes!(AttributeEscapes,false);
+	}
+	static if(unicode) {
+	  mixin checkEscapes!(NamedEscapes, false);
+	  switch(chunk[0]) {
+	  case '#':
+		auto pos = chunk.countUntil(';');
+		if(pos < 0) {
+		  app.put("&" ~ chunk);
+		  continue;
+		}
+		auto num = chunk[1..pos];
+		if(!isNumeric(num)) {
+		  app.put("&" ~ chunk);
+		  continue;
+		}
+		app.put(num.to!int.to!dchar.to!string);
+		app.put(chunk[pos..$]);
+		continue;
+	  }
+	case 'x':
+	  auto pos = chunk.countUntil(';');
+	  if(pos < 0) {
+		app.put("&" ~ chunk);
+		continue;
+	  }
+	  auto num = chunk[1..pos];
+	  if(num.count("abcdefABCDEF0123456789") < num.length) {
+		app.put("&" ~ chunk);
+		continue;
+	  }
+	  app.put(to!int(num,0x10).to!dchar.to!string);
+	default:
+	  app.put("&" ~ chunk);
+	  continue;
+	}
+  }
+  return app.data;
+}
+
+unittest {
+  import std.stdio;
+  writeln("hmmm ",unescape("&lt;html&gt;&amp;amp; &#160; &x37;"));
+}

From 930b76217dd287b863da14c5398c878907c0d6a7 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 02:14:45 +0000
Subject: [PATCH 07/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 52 1309

---
 src/html/escape.d | 64 +++++++++++++++++++++++++++++++----------------
 1 file changed, 42 insertions(+), 22 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 1c7708f..8bcf86f 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -1,3 +1,7 @@
+module html.escape;
+
+import html: HTMLString;
+
 enum HTMLEscapes {
   lt = '<',
   gt = '>',
@@ -8,21 +12,30 @@ enum AttributeEscapes {
   apos = '\'',
 }
 
+enum NamedEscapes {
+  nbsp = ' '
+}
+
 string checkEnum(alias Escapes, bool escape = true)(string s) {
-  for(e;EnumMembers!Escapes) {
+  import std.array: appender;
+  import std.traits: EnumMembers;
+  import std.format: format;
+  import std.conv: to;
+  auto app = appender!string;
+  foreach(e;EnumMembers!Escapes) {
 	static if(escape) {
 	  app.put(q{
 		  if(chunk.startsWith("%1$s")) {
-			result.put("&%2$s;");
-			result.put(chunk["%1$s".length:$]);
+			app.put("&%2$s;");
+			app.put(chunk["%1$s".length:$]);
 			continue;
 		  }
 		}.format(to!wchar(e),to!string(e)));
 	} else {
 	  app.put(q{
 		  if(chunk.startsWith("%1$s;")) {
-			result.put("%2$s");
-			result.put(chunk["%1$s;".length:$]);
+			app.put("%2$s");
+			app.put(chunk["%1$s;".length:$]);
 			continue;
 		  }
 		}.format(to!string(e),to!wchar(e)));
@@ -34,8 +47,13 @@ string checkEnum(alias Escapes, bool escape = true)(string s) {
 auto unescape(bool unicode = true,
 			  bool html = false,
 			  bool attribute = false)
-  (HTMLstring s) {
-  appender!HTMLstring result;
+  (HTMLString s) {
+  import std.array: appender;
+  import std.algorithm.iteration: splitter;
+  import std.conv: to;
+  import std.string: isNumeric;
+  import std.algorithm.searching: countUntil, count;
+  auto app = appender!HTMLString;
   auto chunks = s.splitter("&");
   if(chunks.empty) return s;
   chunks.popFront();
@@ -47,13 +65,13 @@ auto unescape(bool unicode = true,
 	  continue;
 	}
 	static if(html) {
-	  mixin checkEscapes!(HTMLEscapes,false);
+	  mixin checkEnum!(HTMLEscapes,false);
 	}
 	static if(attribute) {
-	  mixin checkEscapes!(AttributeEscapes,false);
+	  mixin checkEnum!(AttributeEscapes,false);
 	}
 	static if(unicode) {
-	  mixin checkEscapes!(NamedEscapes, false);
+	  mixin checkEnum!(NamedEscapes, false);
 	  switch(chunk[0]) {
 	  case '#':
 		auto pos = chunk.countUntil(';');
@@ -69,22 +87,24 @@ auto unescape(bool unicode = true,
 		app.put(num.to!int.to!dchar.to!string);
 		app.put(chunk[pos..$]);
 		continue;
-	  }
-	case 'x':
-	  auto pos = chunk.countUntil(';');
-	  if(pos < 0) {
-		app.put("&" ~ chunk);
+
+	  case 'x':
+		auto pos = chunk.countUntil(';');
+		if(pos < 0) {
+		  app.put("&" ~ chunk);
+		  continue;
+		}
+		auto num = chunk[1..pos];
+		if(num.count("abcdefABCDEF0123456789") < num.length) {
+		  app.put("&" ~ chunk);
+		  continue;
+		}
+		app.put(to!int(num,0x10).to!dchar.to!string);
 		continue;
-	  }
-	  auto num = chunk[1..pos];
-	  if(num.count("abcdefABCDEF0123456789") < num.length) {
+	  default:
 		app.put("&" ~ chunk);
 		continue;
 	  }
-	  app.put(to!int(num,0x10).to!dchar.to!string);
-	default:
-	  app.put("&" ~ chunk);
-	  continue;
 	}
   }
   return app.data;

From bc6a14b98abd0083e12d0f0695dd3d161e78be33 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 02:34:53 +0000
Subject: [PATCH 08/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 50 1230

---
 src/html/escape.d | 52 ++++++++++++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 8bcf86f..b96eef6 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -16,32 +16,31 @@ enum NamedEscapes {
   nbsp = ' '
 }
 
-string checkEnum(alias Escapes, bool escape = true)(string s) {
-  import std.array: appender;
+bool checkEnum(alias Escapes, bool escape = true)
+  (string ref chunk,
+   Appender!string ref app) {
   import std.traits: EnumMembers;
-  import std.format: format;
   import std.conv: to;
-  auto app = appender!string;
   foreach(e;EnumMembers!Escapes) {
-	static if(escape) {
-	  app.put(q{
-		  if(chunk.startsWith("%1$s")) {
-			app.put("&%2$s;");
-			app.put(chunk["%1$s".length:$]);
-			continue;
-		  }
-		}.format(to!wchar(e),to!string(e)));
+	auto repr = e.to!dchar.to!string;
+	auto name = e.to!string;
+	if(repr == "\"")
+	  repr = "\\\"";
+	static if(escape == true) {
+	  if(chunk.startsWith(repr)) {
+		app.put("&"~name~";");
+		app.put(chunk[repr.length..$]);
+		return true;
+	  }
 	} else {
-	  app.put(q{
-		  if(chunk.startsWith("%1$s;")) {
-			app.put("%2$s");
-			app.put(chunk["%1$s;".length:$]);
-			continue;
-		  }
-		}.format(to!string(e),to!wchar(e)));
+	  if(chunk.startsWith(name ~ ";")) {
+		app.put(repr);
+		app.put(chunk[name.length+1..$]);
+		return true;
+	  }
 	}
   }
-  return app.data;
+  return false;
 }
 
 auto unescape(bool unicode = true,
@@ -52,26 +51,29 @@ auto unescape(bool unicode = true,
   import std.algorithm.iteration: splitter;
   import std.conv: to;
   import std.string: isNumeric;
-  import std.algorithm.searching: countUntil, count;
+  import std.algorithm.searching: countUntil, count,startsWith;
   auto app = appender!HTMLString;
   auto chunks = s.splitter("&");
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
+  import std.stdio;
+  writeln(checkEnum!(HTMLEscapes,false)(s,app));
 
   foreach(chunk; chunks) {
+	writeln(chunk);
 	if(chunk.length == 0) {
 	  app.put("&");
 	  continue;
 	}
 	static if(html) {
-	  mixin checkEnum!(HTMLEscapes,false);
+	  if(checkEnum!(HTMLEscapes,false)(s,app)) continue;
 	}
 	static if(attribute) {
-	  mixin checkEnum!(AttributeEscapes,false);
+	  if(checkEnum!(AttributeEscapes,false)(s,app)) continue;
 	}
 	static if(unicode) {
-	  mixin checkEnum!(NamedEscapes, false);
+	  if(checkEnum!(NamedEscapes, false)(s,app)) continue;
 	  switch(chunk[0]) {
 	  case '#':
 		auto pos = chunk.countUntil(';');
@@ -112,5 +114,5 @@ auto unescape(bool unicode = true,
 
 unittest {
   import std.stdio;
-  writeln("hmmm ",unescape("&lt;html&gt;&amp;amp; &#160; &x37;"));
+  writeln("hmmm ",unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#160; &x37;"));
 }

From 7c094d475124847b5504e04b2d005dd46b3dfa03 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 03:06:07 +0000
Subject: [PATCH 09/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 129 2782

---
 src/html/escape.d | 144 +++++++++++++++++++++++++++++++---------------
 1 file changed, 97 insertions(+), 47 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index b96eef6..e903e6c 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -1,4 +1,5 @@
 module html.escape;
+  import std.stdio;
 
 import html: HTMLString;
 
@@ -13,17 +14,22 @@ enum AttributeEscapes {
 }
 
 enum NamedEscapes {
-  nbsp = ' '
+  nbsp = ' ',
+  amp = '&'
 }
 
+import std.array: Appender;
+
 bool checkEnum(alias Escapes, bool escape = true)
-  (string ref chunk,
-   Appender!string ref app) {
+  (ref HTMLString chunk,
+   Appender!HTMLString app) {
   import std.traits: EnumMembers;
   import std.conv: to;
+  import std.string: startsWith;
   foreach(e;EnumMembers!Escapes) {
 	auto repr = e.to!dchar.to!string;
 	auto name = e.to!string;
+	writeln("okay... ",chunk," ",repr," ",name);
 	if(repr == "\"")
 	  repr = "\\\"";
 	static if(escape == true) {
@@ -57,56 +63,46 @@ auto unescape(bool unicode = true,
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
-  import std.stdio;
   writeln(checkEnum!(HTMLEscapes,false)(s,app));
 
   foreach(chunk; chunks) {
 	writeln(chunk);
-	if(chunk.length == 0) {
-	  app.put("&");
-	  continue;
-	}
-	static if(html) {
-	  if(checkEnum!(HTMLEscapes,false)(s,app)) continue;
-	}
-	static if(attribute) {
-	  if(checkEnum!(AttributeEscapes,false)(s,app)) continue;
-	}
-	static if(unicode) {
-	  if(checkEnum!(NamedEscapes, false)(s,app)) continue;
-	  switch(chunk[0]) {
-	  case '#':
-		auto pos = chunk.countUntil(';');
-		if(pos < 0) {
-		  app.put("&" ~ chunk);
-		  continue;
-		}
-		auto num = chunk[1..pos];
-		if(!isNumeric(num)) {
-		  app.put("&" ~ chunk);
-		  continue;
-		}
-		app.put(num.to!int.to!dchar.to!string);
-		app.put(chunk[pos..$]);
-		continue;
-
-	  case 'x':
-		auto pos = chunk.countUntil(';');
-		if(pos < 0) {
-		  app.put("&" ~ chunk);
-		  continue;
-		}
-		auto num = chunk[1..pos];
-		if(num.count("abcdefABCDEF0123456789") < num.length) {
-		  app.put("&" ~ chunk);
-		  continue;
+	bool handle() {
+	  if(chunk.length == 0) return false;
+	  static if(unicode) {
+		switch(chunk[1]) {
+		case '#':
+		  auto pos = chunk[2..$-1].countUntil(';');
+		  if(pos < 0) return false;
+		  auto num = chunk[2..pos];
+		  if(!isNumeric(num)) return false;
+		  
+		  app.put(num.to!int.to!dchar.to!string);
+		  app.put(chunk[pos..$-1]);
+		  return true;
+		case 'x':
+		  auto pos = chunk[2..$-1].countUntil(';');
+		  if(pos < 0) return false;
+		  auto num = chunk[2..pos];
+		  if(num.count!((c) => 0 == "abcdefABCDEF0123456789".count(c)) > 0)
+			return false;
+		
+		  app.put(to!int(num,0x10).to!dchar.to!string);
+		  return true;
+		default:
+		  if(checkEnum!(NamedEscapes, false)(chunk,app)) return true;
 		}
-		app.put(to!int(num,0x10).to!dchar.to!string);
-		continue;
-	  default:
-		app.put("&" ~ chunk);
-		continue;
 	  }
+	  static if(html) {
+		if(checkEnum!(HTMLEscapes,false)(chunk,app)) return true;
+	  }
+	  static if(attribute) {
+		if(checkEnum!(AttributeEscapes,false)(chunk,app)) return true;
+	  }
+	  return false;
+	}
+	if(!handle()) {
+	  app.put(chunk);
 	}
   }
   return app.data;
@@ -116,3 +112,57 @@ unittest {
   import std.stdio;
   writeln("hmmm ",unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#160; &x37;"));
 }
+
+auto escape(bool unicode = true,
+			  bool html = false,
+			  bool attribute = false)
+  (HTMLString s) {
+  import std.array: appender;
+  import std.algorithm.iteration: splitter;
+  auto app = appender!HTMLString;
+  bool criteria(char c) {
+	static if(unicode) {
+	  // no utf-8 multibyte characters, or control characters.
+	  if(c < ' ' || c > '~') return true;
+	  foreach(e;EnumMembers!NamedEscapes) {
+		if(e.to!char == c) return true;
+	  }
+	}
+	static if(html) {
+	  foreach(e;EnumMembers!HTMLEscapes) {
+		if(e.to!char == c) return true;
+	  }
+	}
+	static if(attribute) {
+	  foreach(e;EnumMembers!AttributeEscapes) {
+		if(e.to!char == c) return true;
+	  }
+	}
+  }
+	
+  auto chunks = s.splitter(criteria);
+  if(chunks.empty) return s;
+  chunks.popFront();
+  if(chunks.empty) return s;
+  for(chunk; chunks) {
+	static if(unicode) {
+	  import std.utf: decode;
+	  if(checkEnum!(NamedEscapes, true)(chunk,app)) continue;
+	  if(chunk[0] > 0x7f) {
+		auto num = 0
+		auto point = decode(chunk,num);
+		app.put("&x");
+		app.put(to!int(point,0x10));
+		app.put(";");
+		app.put(chunk[num..$]);
+		continue;
+	  }
+	}
+	static if(html) {
+	  if(checkEnum!(HTMLEscapes, true)(chunk,app)) continue;
+	}
+	static if(attribute) {
+	  if(checkEnum!(AttributeEscapes, true)(chunk,app)) continue;
+	}
+  }
+	

From 5a9b31a22cd73fed02c79d69552a534bcc861c57 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 03:27:06 +0000
Subject: [PATCH 10/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 51 1041

---
 src/html/escape.d | 66 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 42 insertions(+), 24 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index e903e6c..191c67d 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -1,5 +1,7 @@
 module html.escape;
   import std.stdio;
+  import std.traits: EnumMembers;
+  import std.conv: to;
 
 import html: HTMLString;
 
@@ -23,8 +25,6 @@ import std.array: Appender;
 bool checkEnum(alias Escapes, bool escape = true)
   (ref HTMLString chunk,
    Appender!HTMLString app) {
-  import std.traits: EnumMembers;
-  import std.conv: to;
   import std.string: startsWith;
   foreach(e;EnumMembers!Escapes) {
 	auto repr = e.to!dchar.to!string;
@@ -120,10 +120,10 @@ auto escape(bool unicode = true,
   import std.array: appender;
   import std.algorithm.iteration: splitter;
   auto app = appender!HTMLString;
-  bool criteria(char c) {
+  bool criteria(const(char) c) {
 	static if(unicode) {
-	  // no utf-8 multibyte characters, or control characters.
-	  if(c < ' ' || c > '~') return true;
+	  // break on utf-8 multibyte characters, or control characters.
+	  if(!isPrintable(c)) return true;
 	  foreach(e;EnumMembers!NamedEscapes) {
 		if(e.to!char == c) return true;
 	  }
@@ -138,31 +138,49 @@ auto escape(bool unicode = true,
 		if(e.to!char == c) return true;
 	  }
 	}
+	return false;
   }
-	
-  auto chunks = s.splitter(criteria);
+
+  import std.range: isForwardRange;
+  import std.functional: unaryFun;
+  static assert(isForwardRange!(typeof(s)));
+  pragma(msg,typeid(typeof(criteria)));
+  pragma(msg,is(typeof(unaryFun!criteria(s[0]))));
+  auto chunks = splitter!(a => a == ' ')(s);
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
-  for(chunk; chunks) {
-	static if(unicode) {
-	  import std.utf: decode;
-	  if(checkEnum!(NamedEscapes, true)(chunk,app)) continue;
-	  if(chunk[0] > 0x7f) {
-		auto num = 0
-		auto point = decode(chunk,num);
-		app.put("&x");
-		app.put(to!int(point,0x10));
-		app.put(";");
-		app.put(chunk[num..$]);
-		continue;
+  foreach(chunk; chunks) {
+	bool handle() {
+	  static if(unicode) {
+		import std.utf: decode;
+		if(checkEnum!(NamedEscapes, true)(chunk,app)) return true;
+		if(chunk[0] > 0x7f) {
+		  size_t num = 0;
+		  auto point = decode(chunk,num);
+		  app.put("&x");
+		  app.put(to!uint(point,0x10));
+		  app.put(";");
+		  app.put(chunk[num..$]);
+		  return true;
+		}
 	  }
+	  static if(html) {
+		if(checkEnum!(HTMLEscapes, true)(chunk,app)) return true;
+	  }
+	  static if(attribute) {
+		if(checkEnum!(AttributeEscapes, true)(chunk,app)) return true;		
+	  }
+	  return false;
 	}
-	static if(html) {
-	  if(checkEnum!(HTMLEscapes, true)(chunk,app)) continue;
-	}
-	static if(attribute) {
-	  if(checkEnum!(AttributeEscapes, true)(chunk,app)) continue;
+	if(!handle()) {
+	  app.put(chunk);
 	}
   }
+}
 	
+unittest {
+  writeln(escape!(true,true,true)(`<hi>
+
+--—--`));
+}

From 1ebe8625115aaca4e3fab3ec46dd86e1b54642cb Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 03:49:53 +0000
Subject: [PATCH 11/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 50 1427

---
 src/html/escape.d | 48 ++++++++++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 191c67d..04f7ef1 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -29,7 +29,6 @@ bool checkEnum(alias Escapes, bool escape = true)
   foreach(e;EnumMembers!Escapes) {
 	auto repr = e.to!dchar.to!string;
 	auto name = e.to!string;
-	writeln("okay... ",chunk," ",repr," ",name);
 	if(repr == "\"")
 	  repr = "\\\"";
 	static if(escape == true) {
@@ -63,27 +62,32 @@ auto unescape(bool unicode = true,
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
-  writeln(checkEnum!(HTMLEscapes,false)(s,app));
 
   foreach(chunk; chunks) {
-	writeln(chunk);
+	import std.algorithm: min;
 	bool handle() {
 	  if(chunk.length == 0) return false;
+	  static if(html) {
+		if(checkEnum!(HTMLEscapes,false)(chunk,app)) return true;
+	  }
+	  static if(attribute) {
+		if(checkEnum!(AttributeEscapes,false)(chunk,app)) return true;
+	  }
 	  static if(unicode) {
-		switch(chunk[1]) {
+		switch(chunk[0]) {
 		case '#':
-		  auto pos = chunk[2..$-1].countUntil(';');
+		  auto pos = chunk[1..$].countUntil(';');
 		  if(pos < 0) return false;
-		  auto num = chunk[2..pos];
+		  auto num = chunk[1..pos];
 		  if(!isNumeric(num)) return false;
 		  
 		  app.put(num.to!int.to!dchar.to!string);
-		  app.put(chunk[pos..$-1]);
+		  app.put(chunk[pos..$]);
 		  return true;
 		case 'x':
-		  auto pos = chunk[2..$-1].countUntil(';');
+		  auto pos = chunk[1..$].countUntil(';');
 		  if(pos < 0) return false;
-		  auto num = chunk[2..pos];
+		  auto num = chunk[1..pos];
 		  if(num.count!((c) => 0 == "abcdefABCDEF0123456789".count(c)) > 0)
 			return false;
 		
@@ -93,15 +97,10 @@ auto unescape(bool unicode = true,
 		  if(checkEnum!(NamedEscapes, false)(chunk,app)) return true;
 		}
 	  }
-	  static if(html) {
-		if(checkEnum!(HTMLEscapes,false)(chunk,app)) return true;
-	  }
-	  static if(attribute) {
-		if(checkEnum!(AttributeEscapes,false)(chunk,app)) return true;
-	  }
 	  return false;
 	}
 	if(!handle()) {
+	  app.put('&');
 	  app.put(chunk);
 	}
   }
@@ -110,7 +109,10 @@ auto unescape(bool unicode = true,
 
 unittest {
   import std.stdio;
-  writeln("hmmm ",unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#160; &x37;"));
+  import std.algorithm.comparison: equal;
+  assert
+	(equal(unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#160; &x37;"),
+		   `<html>&amp; 0; `));
 }
 
 auto escape(bool unicode = true,
@@ -119,6 +121,7 @@ auto escape(bool unicode = true,
   (HTMLString s) {
   import std.array: appender;
   import std.algorithm.iteration: splitter;
+  import std.ascii: isPrintable;
   auto app = appender!HTMLString;
   bool criteria(const(char) c) {
 	static if(unicode) {
@@ -143,14 +146,15 @@ auto escape(bool unicode = true,
 
   import std.range: isForwardRange;
   import std.functional: unaryFun;
-  static assert(isForwardRange!(typeof(s)));
-  pragma(msg,typeid(typeof(criteria)));
-  pragma(msg,is(typeof(unaryFun!criteria(s[0]))));
-  auto chunks = splitter!(a => a == ' ')(s);
+  pragma(msg,typeid(typeof((cast(Range)s).front)))
+  static assert(isForwardRange!(typeof(s))
+				&& is(typeof(unaryFun!criteria((cast(Range)s).front))));
+  auto chunks = splitter!(criteria)(s);
   if(chunks.empty) return s;
   chunks.popFront();
   if(chunks.empty) return s;
   foreach(chunk; chunks) {
+	writeln("okay... ",chunk);
 	bool handle() {
 	  static if(unicode) {
 		import std.utf: decode;
@@ -159,7 +163,7 @@ auto escape(bool unicode = true,
 		  size_t num = 0;
 		  auto point = decode(chunk,num);
 		  app.put("&x");
-		  app.put(to!uint(point,0x10));
+		  app.put(to!string(to!uint(point),0x10));
 		  app.put(";");
 		  app.put(chunk[num..$]);
 		  return true;
@@ -174,9 +178,11 @@ auto escape(bool unicode = true,
 	  return false;
 	}
 	if(!handle()) {
+	  app.put('&');
 	  app.put(chunk);
 	}
   }
+  return app.data;
 }
 	
 unittest {

From 77d6af4e5344a57164d5cd6a1d3e95a9af57cff5 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 04:27:38 +0000
Subject: [PATCH 12/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 71 1526

---
 src/html/escape.d | 74 +++++++++++++++++++++++++++--------------------
 1 file changed, 42 insertions(+), 32 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 04f7ef1..b5574a6 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -24,7 +24,7 @@ import std.array: Appender;
 
 bool checkEnum(alias Escapes, bool escape = true)
   (ref HTMLString chunk,
-   Appender!HTMLString app) {
+   ref Appender!HTMLString app) {
   import std.string: startsWith;
   foreach(e;EnumMembers!Escapes) {
 	auto repr = e.to!dchar.to!string;
@@ -32,6 +32,7 @@ bool checkEnum(alias Escapes, bool escape = true)
 	if(repr == "\"")
 	  repr = "\\\"";
 	static if(escape == true) {
+	  writeln("hmm",repr," ",chunk);
 	  if(chunk.startsWith(repr)) {
 		app.put("&"~name~";");
 		app.put(chunk[repr.length..$]);
@@ -78,20 +79,20 @@ auto unescape(bool unicode = true,
 		case '#':
 		  auto pos = chunk[1..$].countUntil(';');
 		  if(pos < 0) return false;
-		  auto num = chunk[1..pos];
+		  auto num = chunk[1..pos+1];
 		  if(!isNumeric(num)) return false;
-		  
 		  app.put(num.to!int.to!dchar.to!string);
-		  app.put(chunk[pos..$]);
+		  app.put(chunk[pos+2..$]);
 		  return true;
 		case 'x':
 		  auto pos = chunk[1..$].countUntil(';');
 		  if(pos < 0) return false;
-		  auto num = chunk[1..pos];
+		  auto num = chunk[1..pos+1];
 		  if(num.count!((c) => 0 == "abcdefABCDEF0123456789".count(c)) > 0)
 			return false;
 		
 		  app.put(to!int(num,0x10).to!dchar.to!string);
+		  app.put(chunk[pos+2..$]);
 		  return true;
 		default:
 		  if(checkEnum!(NamedEscapes, false)(chunk,app)) return true;
@@ -110,76 +111,85 @@ auto unescape(bool unicode = true,
 unittest {
   import std.stdio;
   import std.algorithm.comparison: equal;
-  assert
-	(equal(unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#160; &x37;"),
-		   `<html>&amp; 0; `));
+  void assert_equal(HTMLString a, HTMLString b) {
+	if(a != b) {
+	  writeln("fail");
+	  writeln(a);
+	  writeln(b);
+	  assert(false);
+	}
+  }
+  assert_equal
+	(unescape!(true,true,true)("&lt;html&gt;&amp;amp; &#42; &x42;"),
+	 "<html>&amp; * B");
 }
 
 auto escape(bool unicode = true,
 			  bool html = false,
 			  bool attribute = false)
   (HTMLString s) {
+  if(s.length == 0) return s;
+  
   import std.array: appender;
   import std.algorithm.iteration: splitter;
   import std.ascii: isPrintable;
-  auto app = appender!HTMLString;
-  bool criteria(const(char) c) {
+
+  bool criteria(const(dchar) c) {
 	static if(unicode) {
 	  // break on utf-8 multibyte characters, or control characters.
 	  if(!isPrintable(c)) return true;
 	  foreach(e;EnumMembers!NamedEscapes) {
-		if(e.to!char == c) return true;
+		if(e.to!dchar == c) return true;
 	  }
 	}
 	static if(html) {
 	  foreach(e;EnumMembers!HTMLEscapes) {
-		if(e.to!char == c) return true;
+		if(e.to!dchar == c) return true;
 	  }
 	}
 	static if(attribute) {
 	  foreach(e;EnumMembers!AttributeEscapes) {
-		if(e.to!char == c) return true;
+		if(e.to!dchar == c) return true;
 	  }
 	}
 	return false;
   }
 
-  import std.range: isForwardRange;
-  import std.functional: unaryFun;
-  pragma(msg,typeid(typeof((cast(Range)s).front)))
-  static assert(isForwardRange!(typeof(s))
-				&& is(typeof(unaryFun!criteria((cast(Range)s).front))));
-  auto chunks = splitter!(criteria)(s);
-  if(chunks.empty) return s;
-  chunks.popFront();
-  if(chunks.empty) return s;
-  foreach(chunk; chunks) {
-	writeln("okay... ",chunk);
+  auto app = appender!HTMLString;
+
+  /* it's fastest to just iterate over the bytes...
+	 because we can't memchr since we don't know what we're looking for.
+  */
+  int last = 0;
+  for(int i=0;i<s.length;++i) {
+	if(!criteria(s[i])) continue;
+	if(i > last) {
+	  app.put(s[last..i-1]);
+	}
+	writeln("okay... ",s[i]);
 	bool handle() {
 	  static if(unicode) {
 		import std.utf: decode;
-		if(checkEnum!(NamedEscapes, true)(chunk,app)) return true;
-		if(chunk[0] > 0x7f) {
+		if(checkEnum!(NamedEscapes, true)(&s[i],app)) return true;
+		if(s[i] > 0x7f) {
 		  size_t num = 0;
-		  auto point = decode(chunk,num);
+		  auto point = decode(&s[i],num);
 		  app.put("&x");
 		  app.put(to!string(to!uint(point),0x10));
 		  app.put(";");
-		  app.put(chunk[num..$]);
 		  return true;
 		}
 	  }
 	  static if(html) {
-		if(checkEnum!(HTMLEscapes, true)(chunk,app)) return true;
+		if(checkEnum!(HTMLEscapes, true)(&s[i],app)) return true;
 	  }
 	  static if(attribute) {
-		if(checkEnum!(AttributeEscapes, true)(chunk,app)) return true;		
+		if(checkEnum!(AttributeEscapes, true)(&s[i],app)) return true;		
 	  }
 	  return false;
 	}
 	if(!handle()) {
-	  app.put('&');
-	  app.put(chunk);
+	  app.put(s[i]);
 	}
   }
   return app.data;

From c98a2b0ca4730b769c7466ccb667ea5af8d7bb62 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 04:41:29 +0000
Subject: [PATCH 13/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 76 1826

---
 src/html/escape.d | 97 ++++++++++++++++++++++++++---------------------
 1 file changed, 53 insertions(+), 44 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index b5574a6..cf37eed 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -22,7 +22,7 @@ enum NamedEscapes {
 
 import std.array: Appender;
 
-bool checkEnum(alias Escapes, bool escape = true)
+bool unescapeEnum(alias Escapes)
   (ref HTMLString chunk,
    ref Appender!HTMLString app) {
   import std.string: startsWith;
@@ -31,19 +31,25 @@ bool checkEnum(alias Escapes, bool escape = true)
 	auto name = e.to!string;
 	if(repr == "\"")
 	  repr = "\\\"";
-	static if(escape == true) {
-	  writeln("hmm",repr," ",chunk);
-	  if(chunk.startsWith(repr)) {
-		app.put("&"~name~";");
-		app.put(chunk[repr.length..$]);
-		return true;
-	  }
-	} else {
-	  if(chunk.startsWith(name ~ ";")) {
-		app.put(repr);
-		app.put(chunk[name.length+1..$]);
-		return true;
-	  }
+	if(chunk.startsWith(name ~ ";")) {
+	  app.put(repr);
+	  app.put(chunk[name.length+1..$]);
+	  return true;
+	}
+  }
+  return false;
+}
+
+bool escapeEnum(alias Escapes)
+  (const(char) c,
+   ref Appender!HTMLString app) {
+  foreach(e;EnumMembers!Escapes) {
+	if(c == e) {
+	  auto name = e.to!string;
+	  app.put('&');
+	  app.put(name);
+	  app.put(';');
+	  return true;
 	}
   }
   return false;
@@ -65,14 +71,13 @@ auto unescape(bool unicode = true,
   if(chunks.empty) return s;
 
   foreach(chunk; chunks) {
-	import std.algorithm: min;
 	bool handle() {
 	  if(chunk.length == 0) return false;
 	  static if(html) {
-		if(checkEnum!(HTMLEscapes,false)(chunk,app)) return true;
+		if(unescapeEnum!(HTMLEscapes,false)(chunk,app)) return true;
 	  }
 	  static if(attribute) {
-		if(checkEnum!(AttributeEscapes,false)(chunk,app)) return true;
+		if(unescapeEnum!(AttributeEscapes,false)(chunk,app)) return true;
 	  }
 	  static if(unicode) {
 		switch(chunk[0]) {
@@ -90,12 +95,12 @@ auto unescape(bool unicode = true,
 		  auto num = chunk[1..pos+1];
 		  if(num.count!((c) => 0 == "abcdefABCDEF0123456789".count(c)) > 0)
 			return false;
-		
+
 		  app.put(to!int(num,0x10).to!dchar.to!string);
 		  app.put(chunk[pos+2..$]);
 		  return true;
 		default:
-		  if(checkEnum!(NamedEscapes, false)(chunk,app)) return true;
+		  if(unescapeEnum!(NamedEscapes, false)(chunk,app)) return true;
 		}
 	  }
 	  return false;
@@ -129,7 +134,7 @@ auto escape(bool unicode = true,
 			  bool attribute = false)
   (HTMLString s) {
   if(s.length == 0) return s;
-  
+
   import std.array: appender;
   import std.algorithm.iteration: splitter;
   import std.ascii: isPrintable;
@@ -137,7 +142,7 @@ auto escape(bool unicode = true,
   bool criteria(const(dchar) c) {
 	static if(unicode) {
 	  // break on utf-8 multibyte characters, or control characters.
-	  if(!isPrintable(c)) return true;
+
 	  foreach(e;EnumMembers!NamedEscapes) {
 		if(e.to!dchar == c) return true;
 	  }
@@ -162,39 +167,43 @@ auto escape(bool unicode = true,
   */
   int last = 0;
   for(int i=0;i<s.length;++i) {
-	if(!criteria(s[i])) continue;
-	if(i > last) {
-	  app.put(s[last..i-1]);
-	}
-	writeln("okay... ",s[i]);
+	HTMLString derp;
 	bool handle() {
-	  static if(unicode) {
-		import std.utf: decode;
-		if(checkEnum!(NamedEscapes, true)(&s[i],app)) return true;
-		if(s[i] > 0x7f) {
-		  size_t num = 0;
-		  auto point = decode(&s[i],num);
-		  app.put("&x");
-		  app.put(to!string(to!uint(point),0x10));
-		  app.put(";");
-		  return true;
-		}
-	  }
 	  static if(html) {
-		if(checkEnum!(HTMLEscapes, true)(&s[i],app)) return true;
+		if(escapeEnum!HTMLEscapes(s[i], derp)) return true;
 	  }
 	  static if(attribute) {
-		if(checkEnum!(AttributeEscapes, true)(&s[i],app)) return true;		
+		if(escapeEnum!AttributeEscapes(s[i], derp)) return true;
 	  }
-	  return false;
+	  static if(!unicode) {
+		return false;
+	  }
+	  if(escapeEnum!NamedEscapes(s[i], derp)) return true;
+	  if(isPrintable(s[i])) return false;
+
+	  if(s[i] < 0x7f) {
+		app.put("&x");
+		app.put(to!string(s[i],0x10));
+		app.put(';');
+		return true;
+	  }
+	  size_t num = 0;
+	  auto point = decode(s[i..min($,i+4)],num);
+	  app.put("&x");
+	  app.put(to!string(to!uint(point),0x10));
+	  app.put(";");
+	  return true;
 	}
-	if(!handle()) {
-	  app.put(s[i]);
+	if(handle()) {
+	  last = i + 1;
 	}
   }
+  if(last < s.length) {
+	app.put(s[last..$]);
+  }
   return app.data;
 }
-	
+
 unittest {
   writeln(escape!(true,true,true)(`<hi>
 

From acdb7a4299fa03e14507d6244742cf01863b4e51 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 04:58:47 +0000
Subject: [PATCH 14/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 57 1188

---
 src/html/escape.d | 65 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 20 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index cf37eed..90e0c88 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -42,13 +42,12 @@ bool unescapeEnum(alias Escapes)
 
 bool escapeEnum(alias Escapes)
   (const(char) c,
-   ref Appender!HTMLString app) {
+   ref HTMLString dest) {
   foreach(e;EnumMembers!Escapes) {
 	if(c == e) {
 	  auto name = e.to!string;
-	  app.put('&');
-	  app.put(name);
-	  app.put(';');
+	  // mehh
+	  dest = "&" ~ name ~ ";";
 	  return true;
 	}
   }
@@ -74,10 +73,10 @@ auto unescape(bool unicode = true,
 	bool handle() {
 	  if(chunk.length == 0) return false;
 	  static if(html) {
-		if(unescapeEnum!(HTMLEscapes,false)(chunk,app)) return true;
+		if(unescapeEnum!HTMLEscapes(chunk,app)) return true;
 	  }
 	  static if(attribute) {
-		if(unescapeEnum!(AttributeEscapes,false)(chunk,app)) return true;
+		if(unescapeEnum!AttributeEscapes(chunk,app)) return true;
 	  }
 	  static if(unicode) {
 		switch(chunk[0]) {
@@ -100,7 +99,7 @@ auto unescape(bool unicode = true,
 		  app.put(chunk[pos+2..$]);
 		  return true;
 		default:
-		  if(unescapeEnum!(NamedEscapes, false)(chunk,app)) return true;
+		  if(unescapeEnum!NamedEscapes(chunk,app)) return true;
 		}
 	  }
 	  return false;
@@ -137,7 +136,7 @@ auto escape(bool unicode = true,
 
   import std.array: appender;
   import std.algorithm.iteration: splitter;
-  import std.ascii: isPrintable;
+  import std.ascii: isPrintable, isWhite;
 
   bool criteria(const(dchar) c) {
 	static if(unicode) {
@@ -161,13 +160,12 @@ auto escape(bool unicode = true,
   }
 
   auto app = appender!HTMLString;
-
   /* it's fastest to just iterate over the bytes...
 	 because we can't memchr since we don't know what we're looking for.
   */
   int last = 0;
   for(int i=0;i<s.length;++i) {
-	HTMLString derp;
+	HTMLString derp = null;
 	bool handle() {
 	  static if(html) {
 		if(escapeEnum!HTMLEscapes(s[i], derp)) return true;
@@ -180,22 +178,35 @@ auto escape(bool unicode = true,
 	  }
 	  if(escapeEnum!NamedEscapes(s[i], derp)) return true;
 	  if(isPrintable(s[i])) return false;
-
+	  if(isWhite(s[i])) return false;
 	  if(s[i] < 0x7f) {
-		app.put("&x");
-		app.put(to!string(s[i],0x10));
-		app.put(';');
+		derp = "&x"
+		  ~ to!string(to!byte(s[i]),0x10)
+		  ~ ";";
 		return true;
 	  }
 	  size_t num = 0;
-	  auto point = decode(s[i..min($,i+4)],num);
-	  app.put("&x");
-	  app.put(to!string(to!uint(point),0x10));
-	  app.put(";");
+	  import std.utf: decode;
+	  import std.algorithm.comparison: min;
+	  try {
+		auto point = decode(s[i..min($,i+4)],num);
+		i += num; // auto-++
+		derp = "&x"
+		  ~ to!string(to!uint(point),0x10)
+		  ~ ";";
+		last = i + 1;
+	  } catch(Exception e) {
+		writeln(s[i-1..min($,i+4)]);
+		throw e;
+	  }
 	  return true;
 	}
 	if(handle()) {
+	  if(last < i) {
+		app.put(s[last..i]);
+	  }
 	  last = i + 1;
+	  app.put(derp);
 	}
   }
   if(last < s.length) {
@@ -204,8 +215,22 @@ auto escape(bool unicode = true,
   return app.data;
 }
 
+void assert_equal(T)(T a, T b) {
+  if(a != b) {
+	import std.stdio;
+	writeln("ugggh ");
+	writeln(a);
+	assert(false);
+  }
+}
+
 unittest {
-  writeln(escape!(true,true,true)(`<hi>
+  assert_equal(escape!(true,true,true)
+			   (`<hi>
+
+--—--`),
+			   `&lt;hi&gt;
+
+--&x2014;--`);
 
---—--`));
 }

From 77b1b72ebc6328d22d086ed0aae963e0bba17f4d Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 05:14:41 +0000
Subject: [PATCH 15/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 50 1068

---
 src/html/escape.d | 68 +++++++++++++++++++++++++++--------------------
 1 file changed, 39 insertions(+), 29 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 90e0c88..5a4e5e6 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -8,6 +8,7 @@ import html: HTMLString;
 enum HTMLEscapes {
   lt = '<',
   gt = '>',
+  amp = '&'
 };
 
 enum AttributeEscapes {
@@ -17,7 +18,6 @@ enum AttributeEscapes {
 
 enum NamedEscapes {
   nbsp = ' ',
-  amp = '&'
 }
 
 import std.array: Appender;
@@ -166,6 +166,7 @@ auto escape(bool unicode = true,
   int last = 0;
   for(int i=0;i<s.length;++i) {
 	HTMLString derp = null;
+	size_t num = 0; // need last, before sequence, AND after sequence
 	bool handle() {
 	  static if(html) {
 		if(escapeEnum!HTMLEscapes(s[i], derp)) return true;
@@ -173,40 +174,39 @@ auto escape(bool unicode = true,
 	  static if(attribute) {
 		if(escapeEnum!AttributeEscapes(s[i], derp)) return true;
 	  }
-	  static if(!unicode) {
-		return false;
-	  }
-	  if(escapeEnum!NamedEscapes(s[i], derp)) return true;
-	  if(isPrintable(s[i])) return false;
-	  if(isWhite(s[i])) return false;
-	  if(s[i] < 0x7f) {
-		derp = "&x"
-		  ~ to!string(to!byte(s[i]),0x10)
-		  ~ ";";
+	  static if(unicode) {
+		if(escapeEnum!NamedEscapes(s[i], derp)) return true;
+		if(isPrintable(s[i])) return false;
+		if(isWhite(s[i])) return false;
+		if(s[i] < 0x7f) {
+		  derp = "&x"
+			~ to!string(to!byte(s[i]),0x10)
+			~ ";";
+		  return true;
+		}
+		import std.utf: decode;
+		import std.algorithm.comparison: min;
+		try {
+		  auto point = decode(s[i..min($,i+4)],num);
+		  derp = "&x"
+			~ to!string(to!uint(point),0x10)
+			~ ";";
+		} catch(Exception e) {
+		  writeln(s[i-1..min($,i+4)]);
+		  throw e;
+		}
 		return true;
 	  }
-	  size_t num = 0;
-	  import std.utf: decode;
-	  import std.algorithm.comparison: min;
-	  try {
-		auto point = decode(s[i..min($,i+4)],num);
-		i += num; // auto-++
-		derp = "&x"
-		  ~ to!string(to!uint(point),0x10)
-		  ~ ";";
-		last = i + 1;
-	  } catch(Exception e) {
-		writeln(s[i-1..min($,i+4)]);
-		throw e;
-	  }
-	  return true;
+	  return false;
 	}
 	if(handle()) {
 	  if(last < i) {
 		app.put(s[last..i]);
 	  }
-	  last = i + 1;
 	  app.put(derp);
+	  if(num > 0)
+		i += num - 1;
+	  last = i + 1;
 	}
   }
   if(last < s.length) {
@@ -228,9 +228,19 @@ unittest {
   assert_equal(escape!(true,true,true)
 			   (`<hi>
 
---—--`),
+--—--<>`),
 			   `&lt;hi&gt;
 
---&x2014;--`);
+--&x2014;--&lt;&gt;`);
 
 }
+
+alias escapeHTML = escape!(false,true,false);
+alias escapeAttribute = escape!(false,true,true);
+alias escapeEntities = escape!(true,false,false);
+alias escapeEverything = escape!(true,true,true);
+
+unittest {
+  assert_equal(escapeHTML(`<test>—--</te`,
+						  `&lt;test&gt;—--&lt;/te`));
+  }

From 33a6be2cbef606c55b9e6b45eb868c57aa1d1bf9 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 05:23:59 +0000
Subject: [PATCH 16/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/escape.d) 68 1590

---
 src/html/escape.d | 72 ++++++++++++++++++++++-------------------------
 1 file changed, 33 insertions(+), 39 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 5a4e5e6..76afde4 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -1,14 +1,18 @@
 module html.escape;
-  import std.stdio;
-  import std.traits: EnumMembers;
-  import std.conv: to;
+import std.traits: EnumMembers;
+import std.conv: to;
 
 import html: HTMLString;
 
+enum MandatoryEscapes {
+  // justification: if we don't escape &, when we unescape, it could get
+  // considered an escape!
+  amp = '&'
+}
+
 enum HTMLEscapes {
   lt = '<',
   gt = '>',
-  amp = '&'
 };
 
 enum AttributeEscapes {
@@ -60,9 +64,8 @@ auto unescape(bool unicode = true,
   (HTMLString s) {
   import std.array: appender;
   import std.algorithm.iteration: splitter;
-  import std.conv: to;
   import std.string: isNumeric;
-  import std.algorithm.searching: countUntil, count,startsWith;
+  import std.algorithm.searching: countUntil, count;
   auto app = appender!HTMLString;
   auto chunks = s.splitter("&");
   if(chunks.empty) return s;
@@ -72,6 +75,7 @@ auto unescape(bool unicode = true,
   foreach(chunk; chunks) {
 	bool handle() {
 	  if(chunk.length == 0) return false;
+	  if(unescapeEnum!MandatoryEscapes(chunk,app)) return true;
 	  static if(html) {
 		if(unescapeEnum!HTMLEscapes(chunk,app)) return true;
 	  }
@@ -113,10 +117,11 @@ auto unescape(bool unicode = true,
 }
 
 unittest {
-  import std.stdio;
   import std.algorithm.comparison: equal;
   void assert_equal(HTMLString a, HTMLString b) {
-	if(a != b) {
+	if(!equal(a,b)) {
+	  import std.stdio;
+		
 	  writeln("fail");
 	  writeln(a);
 	  writeln(b);
@@ -135,39 +140,23 @@ auto escape(bool unicode = true,
   if(s.length == 0) return s;
 
   import std.array: appender;
-  import std.algorithm.iteration: splitter;
   import std.ascii: isPrintable, isWhite;
 
-  bool criteria(const(dchar) c) {
-	static if(unicode) {
-	  // break on utf-8 multibyte characters, or control characters.
-
-	  foreach(e;EnumMembers!NamedEscapes) {
-		if(e.to!dchar == c) return true;
-	  }
-	}
-	static if(html) {
-	  foreach(e;EnumMembers!HTMLEscapes) {
-		if(e.to!dchar == c) return true;
-	  }
-	}
-	static if(attribute) {
-	  foreach(e;EnumMembers!AttributeEscapes) {
-		if(e.to!dchar == c) return true;
-	  }
-	}
-	return false;
-  }
-
   auto app = appender!HTMLString;
+
   /* it's fastest to just iterate over the bytes...
-	 because we can't memchr since we don't know what we're looking for.
+	 because we can't memchr, since we don't know what we're looking for.
   */
   int last = 0;
   for(int i=0;i<s.length;++i) {
 	HTMLString derp = null;
-	size_t num = 0; // need last, before sequence, AND after sequence
+	/* We need to remember after the last sequence,
+	   before the current sequence, AND after the current sequence
+	   for multi-byte UTF-8, the latter two are not the same.
+	*/
+	size_t sequence_length = 0; 
 	bool handle() {
+	  if(escapeEnum!MandatoryEscapes(s[i],derp)) return true;
 	  static if(html) {
 		if(escapeEnum!HTMLEscapes(s[i], derp)) return true;
 	  }
@@ -177,35 +166,40 @@ auto escape(bool unicode = true,
 	  static if(unicode) {
 		if(escapeEnum!NamedEscapes(s[i], derp)) return true;
 		if(isPrintable(s[i])) return false;
+		// never escape carriage returns, tabs, etc.
 		if(isWhite(s[i])) return false;
 		if(s[i] < 0x7f) {
+		  // if <0x7F, it cannot be the start of a utf-8 code sequence
+		  // it could be a control character though. So escape those too.
 		  derp = "&x"
-			~ to!string(to!byte(s[i]),0x10)
+			~ to!string(to!ubyte(s[i]),0x10)
 			~ ";";
 		  return true;
 		}
 		import std.utf: decode;
 		import std.algorithm.comparison: min;
 		try {
-		  auto point = decode(s[i..min($,i+4)],num);
+		  auto point = decode(s[i..min($,i+4)],sequence_length);
 		  derp = "&x"
 			~ to!string(to!uint(point),0x10)
 			~ ";";
 		} catch(Exception e) {
+		  import std.stdio;
 		  writeln(s[i-1..min($,i+4)]);
 		  throw e;
 		}
 		return true;
+	  } else {
+		return false;
 	  }
-	  return false;
 	}
 	if(handle()) {
 	  if(last < i) {
 		app.put(s[last..i]);
 	  }
 	  app.put(derp);
-	  if(num > 0)
-		i += num - 1;
+	  if(sequence_length > 0)
+		i += sequence_length - 1;
 	  last = i + 1;
 	}
   }
@@ -241,6 +235,6 @@ alias escapeEntities = escape!(true,false,false);
 alias escapeEverything = escape!(true,true,true);
 
 unittest {
-  assert_equal(escapeHTML(`<test>—--</te`,
-						  `&lt;test&gt;—--&lt;/te`));
+  assert_equal(escapeHTML(`<test>—--</te&lt;`),
+						  `&lt;test&gt;—--&lt;/te&amp;lt;`);
   }

From 2e1b7512bd6ce65012cf298f8c09585863c44b1d Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Tue, 29 Mar 2016 05:31:03 +0000
Subject: [PATCH 17/31] Restoring support for escaping entities

But independent of the document structure.
---
 src/html/escape.d | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/html/escape.d b/src/html/escape.d
index 76afde4..97883cc 100644
--- a/src/html/escape.d
+++ b/src/html/escape.d
@@ -20,6 +20,7 @@ enum AttributeEscapes {
   apos = '\'',
 }
 
+/* miscellanelambdaous names for different unicode code points */
 enum NamedEscapes {
   nbsp = ' ',
 }
@@ -171,14 +172,22 @@ auto escape(bool unicode = true,
 		if(s[i] < 0x7f) {
 		  // if <0x7F, it cannot be the start of a utf-8 code sequence
 		  // it could be a control character though. So escape those too.
+		  
+		  // this makes it display as a number, not a char
+		  ubyte b = to!ubyte(s[i]);
+		  // to!string(n,radix)
+		  string sb = to!string(to!ubyte(s[i]),0x10);
+		  // prepend a 0, if it's 1 digit.
+		  if(b < 0x10) sb = "0" ~ sb;
 		  derp = "&x"
-			~ to!string(to!ubyte(s[i]),0x10)
+			~ sb
 			~ ";";
 		  return true;
 		}
 		import std.utf: decode;
 		import std.algorithm.comparison: min;
 		try {
+		  // decode stores the sequence length in its ref parameter
 		  auto point = decode(s[i..min($,i+4)],sequence_length);
 		  derp = "&x"
 			~ to!string(to!uint(point),0x10)
@@ -190,6 +199,7 @@ auto escape(bool unicode = true,
 		}
 		return true;
 	  } else {
+		// not escaping unicode, just keep going past it.
 		return false;
 	  }
 	}
@@ -220,10 +230,10 @@ void assert_equal(T)(T a, T b) {
 
 unittest {
   assert_equal(escape!(true,true,true)
-			   (`<hi>
+			   (`<hi>`~"\a"~`
 
 --—--<>`),
-			   `&lt;hi&gt;
+			   `&lt;hi&gt;&x07;
 
 --&x2014;--&lt;&gt;`);
 
@@ -237,4 +247,7 @@ alias escapeEverything = escape!(true,true,true);
 unittest {
   assert_equal(escapeHTML(`<test>—--</te&lt;`),
 						  `&lt;test&gt;—--&lt;/te&amp;lt;`);
+
+  assert_equal(escapeEntities(`<test>—--</te&lt;`),
+							  `<test>&x2014;--</te&amp;lt;`);
   }

From 2ae4b3835fb567989b4c10bec928c350329af6bd Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 06:52:55 +0000
Subject: [PATCH 18/31] Various cleanups

---
 src/html/dom.d | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 78b6e91..c04ff2a 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -15,12 +15,6 @@ import html.utils;
 
 alias HTMLString = const(char)[];
 
-enum DOMCreateOptions {
-	None = 0,
-	Default = None,
-}
-
-
 enum OnlyElements = "(a) => { return a.isElementNode; }";
 
 
@@ -284,12 +278,12 @@ struct Node {
 		attrs_.remove(name);
 	}
 
-	@property void html(size_t options = DOMCreateOptions.Default)(HTMLString html) {
+	@property void html(HTMLString html) {
 		assert(isElementNode, "cannot add html to non-element nodes");
 
 		destroyChildren();
 		auto builder = DOMBuilder!(Document)(document_, &this);
-		parseHTML!(typeof(builder), parserOptions)(html, builder);
+		parseHTML!(typeof(builder))(html, builder);
 	}
 
 	@property auto html() const {
@@ -534,7 +528,7 @@ struct Node {
 
 				if (value.length) {
 					app.put("=\"");
-					writeHTMLEscaped(app, value);
+					app.put(value);
 					app.put("\"");
 				}
 			}
@@ -606,7 +600,7 @@ struct Node {
 			}
 			break;
 		case Text:
-			writeHTMLEscaped(app, tag_);
+			app.put(tag_);
 			break;
 		case Comment:
 			app.put("<!--");
@@ -853,7 +847,7 @@ public:/*package:*/
 	Document* document_;
 }
 
-auto ref createDocument(size_t options = DOMCreateOptions.Default)(HTMLString source) {
+auto ref createDocument(HTMLString source) {
 	auto document = createDocument();
 	auto builder = DOMBuilder!(Document)(document);
 	parseHTML!(typeof(builder))(source, builder);
@@ -1114,7 +1108,7 @@ unittest {
 	auto cloned = doc.clone(doc.root);
 	assert(cloned.html == src, cloned.html);
 	assert(doc.root.html == src, cloned.html);
-	
+
 	assert(!cloned.find("child").empty);
 	assert(!cloned.find("parent").empty);
 

From 781ee7b2e130417ccf1d27278ed05a6aac98d1d1 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 06:55:53 +0000
Subject: [PATCH 19/31] Remove debug thing

oops
---
 src/html/dom.d | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index c04ff2a..4dfb0c1 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -320,10 +320,6 @@ struct Node {
 	}
 
 	void appendChild(Node* node) {
-		if(document_ != node.document_) {
-			import std.stdio;
-			writeln("oyyy ",document_," ",node.document_);
-		}	
 		assert(document_ == node.document_);
 		assert(isElementNode, "cannot append to non-element nodes");
 

From 0725932bc035292324a9eada85f0f6f166d1cc2b Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 07:01:20 +0000
Subject: [PATCH 20/31] Cleaner detaching

insertAfter was creating cycles, by not setting next.prev to prev!

A better solution would be a setLink function, that if set to next, set the destination's next.prev.next to this, set the destination's next.prev to this, etc, to make sure no dangling links to old places were around. But... this should work...?
---
 src/html/dom.d | 110 ++++++++++++++++++++++++-------------------------
 1 file changed, 53 insertions(+), 57 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 4dfb0c1..2f0b0e3 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -302,8 +302,8 @@ struct Node {
 		assert(document_ == node.document_);
 		assert(isElementNode, "cannot prepend to non-element nodes");
 
-		if (node.parent_)
-			node.detach();
+		node.detachFast();
+
 		node.parent_ = &this;
 		if (firstChild_) {
 			assert(!firstChild_.prev_);
@@ -316,15 +316,18 @@ struct Node {
 			lastChild_ = node;
 			lastChild_.next_ = null;
 		}
-		firstChild_.prev_ = null;
+        if(firstChild_.prev_) {
+            firstChild_.prev_.next_ = null;
+            firstChild_.prev_ = null;
+        }
 	}
 
 	void appendChild(Node* node) {
 		assert(document_ == node.document_);
 		assert(isElementNode, "cannot append to non-element nodes");
 
-		if (node.parent_)
-			node.detach();
+		node.detachFast();
+
 		node.parent_ = &this;
 		if (lastChild_) {
 			assert(!lastChild_.next_);
@@ -337,7 +340,10 @@ struct Node {
 			firstChild_.prev_ = null;
 			lastChild_ = node;
 		}
-		lastChild_.next_ = null;
+        if(lastChild.next_) {
+            lastChild.next_.prev_ = null;
+            lastChild_.next_ = null;
+        }
 	}
 
 	void removeChild(Node* node) {
@@ -391,6 +397,7 @@ struct Node {
 	void insertBefore(Node* node) {
 		assert(document_ == node.document_);
 		assert(node);
+		detachFast();
 
 		parent_ = node.parent_;
 		prev_ = node.prev_;
@@ -407,6 +414,7 @@ struct Node {
 
 	void insertAfter(Node* node) {
 		assert(document_ == node.document_);
+		detachFast();
 
 		parent_ = node.parent_;
 		prev_ = node;
@@ -420,84 +428,72 @@ struct Node {
 		}
 	}
 
-	void detach() {
+	private void packageDetach(bool careful)() {
 		if (parent_) {
 			if (parent_.firstChild_ == &this) {
-			  assert(!prev_);
 				parent_.firstChild_ = next_;
 				if (next_) {
 					next_.prev_ = null;
-					next_ = null;
+					static if(careful) {
+					  next_ = null;
+					}
 				} else {
 					parent_.lastChild_ = null;
 				}
 
-				assert(prev_ == null);
-			} else if (parent_.lastChild_ == &this) {
-				parent_.lastChild_ = prev_;
-				assert(prev_);
-				assert(!next_);
-				prev_.next_ = null;
-				prev_ = null;
-			} else {
-				assert(prev_);
-
-				prev_.next_ = next_;
-				if (next_) {
-					next_.prev_ = prev_;
-					next_ = null;
-				}
-				prev_ = null;
-			}
-			parent_ = null;
-		} else {
-		  if(prev_) {
-			prev_.next_ = next_;
-		  }
-		  if(next_) {
-			next_.prev_ = prev_;
-		  }
-		}
-		prev_ = null;
-		next_ = null;
-	}
-
-	package void detachFast() {
-		if (parent_) {
-			if (parent_.firstChild_ == &this) {
-				parent_.firstChild_ = next_;
-				if (next_) {
-					next_.prev_ = null;
-				} else {
-					parent_.lastChild_ = null;
+				static if(careful) {
+				  assert(prev_ == null);
 				}
-
-				assert(prev_ == null);
 			} else if (parent_.lastChild_ == &this) {
 				parent_.lastChild_ = prev_;
 				assert(prev_);
-				assert(!next_);
+				assert(next_ is null);
 				prev_.next_ = null;
+				static if(careful) {
+				  prev_ = null;
+				}
 			} else {
 				assert(prev_);
 
 				prev_.next_ = next_;
+				static if(careful) {
+				  prev_ = null;
+				}
 				if (next_) {
 					next_.prev_ = prev_;
+					static if(careful) {
+					  next_ = null;
+					}
 				}
 			}
 		} else {
-		  if(prev_) {
-			prev_.next_ = next_;
-		  }
-		  if(next_) {
-			next_.prev_ = prev_;
+		  static if(careful) {
+			if(prev_) {
+			  prev_.next_ = next_;
+			  static if(careful) {
+				prev_ = null;
+			  }
+			}
+			if(next_) {
+			  next_.prev_ = prev_;
+			  static if(careful) {
+				next_ = null;
+			  }
+			}
+		  } else {
+			assert(prev_ is null);
+			assert(next_ is null);
 		  }
 		}
-		prev_ = null;
-		next_ = null;
+	  static if(careful) {
+		assert(prev_ is null);
+		assert(next_ is null);
+	  }
 	}
 
+    public alias detach = packageDetach!true;
+    package alias detachFast = packageDetach!false;
+
 	void destroy() {
 		detachFast();
 		destroyChildren();

From bb5b84e267b7633e556ec9dabdc6b2a66c120fd4 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 07:27:05 +0000
Subject: [PATCH 21/31] Just some ramblings on inserting and detaching

---
 detach-link-notes.md | 54 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 detach-link-notes.md

diff --git a/detach-link-notes.md b/detach-link-notes.md
new file mode 100644
index 0000000..2fc5d84
--- /dev/null
+++ b/detach-link-notes.md
@@ -0,0 +1,54 @@
+* D E F
+* A B C
+
+`E.insertAfter(B) ->`
+
+* D F
+* A B E C
+
+* B
+  * _next_ = C
+  * prev = A
+
+* C
+ * next = null
+ * _prev_ = B
+
+* E
+ * _next_ = F
+ * _prev_ = D
+ * _parent_ = ???
+
+* D
+ * _next_ = E
+ * _prev_ = F
+
+* F
+  * next = null
+  * _prev_ = E
+
+italic properties must change.
+
+```D
+// first, fix old nodes.
+if(E == E.parent.firstChild) // nope
+  // E.prev must be null if this is true, short circuit logic?
+  E.parent.firstChild = E.next;
+if(E == E.parent.lastChild) // nope
+  // E.next must be null if this is true, short circuit logic?
+  E.parent.lastChild = E.prev;
+if(E.next) // F
+  E.next.prev = E.prev;
+if(E.prev) // D
+  E.prev.next = E.next;
+// insertBefore is an exact mirror of this beyond this point, and identical before.
+// the links on E are free to scram now
+E.prev = B;
+E.next = B.next;
+
+// now, set links to E
+
+if(B.next) // C
+  B.next.prev = E;
+B.next = E;
+```

From 57b4b2e47141c17b67626762591c1aaa3ef42385 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 07:43:49 +0000
Subject: [PATCH 22/31] this assertion should be guaranteed, but isn't...

not firstChild, therefore prev_ !is null, right? hmph...
---
 src/html/dom.d | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 2f0b0e3..827b0d7 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -453,18 +453,18 @@ struct Node {
 				  prev_ = null;
 				}
 			} else {
-				assert(prev_);
-
+			  if(prev_) {
 				prev_.next_ = next_;
 				static if(careful) {
 				  prev_ = null;
 				}
-				if (next_) {
-					next_.prev_ = prev_;
-					static if(careful) {
-					  next_ = null;
-					}
+			  }
+			  if (next_) {
+				next_.prev_ = prev_;
+				static if(careful) {
+				  next_ = null;
 				}
+			  }
 			}
 		} else {
 		  static if(careful) {

From 87cb8cf8a4896ea0d82f69ef4efadd0cf93fc345 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Wed, 30 Mar 2016 23:09:25 +0000
Subject: [PATCH 23/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/dom.d) 140 3473

---
 detach-link-notes.md |  14 +++++
 src/html/dom.d       | 145 +++++++++++++++++++++++++++----------------
 2 files changed, 106 insertions(+), 53 deletions(-)

diff --git a/detach-link-notes.md b/detach-link-notes.md
index 2fc5d84..8d0fb58 100644
--- a/detach-link-notes.md
+++ b/detach-link-notes.md
@@ -52,3 +52,17 @@ if(B.next) // C
   B.next.prev = E;
 B.next = E;
 ```
+
+in addition to setting, 
+Any time you set next, you have to check old.next.prev, and old.parent.lastChild
+- insertAfter
+- also insertBefore for setting dest.next
+Any time you set prev, you have to check old.prev.next, and old.parent.firstChild
+- insertBefore
+- also insertAfter, for setting dest.prev
+Any time you set parent, you have to check old.parent.firstChild and old.parent.lastChild
+- ??? insertChild? probably never do this. below will both be needed
+Any time you set firstChild you have to check old.parent.firstChild (set it to new.next, set it.prev = new)
+- appendChild
+Any time you set lastChild, you have to check old.parent.lastChild
+- prependChild
diff --git a/src/html/dom.d b/src/html/dom.d
index 827b0d7..83426a4 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -298,12 +298,74 @@ struct Node {
 		return app.data;
 	}
 
-	void prependChild(Node* node) {
-		assert(document_ == node.document_);
-		assert(isElementNode, "cannot prepend to non-element nodes");
+	void removeChild(Node* node) {
+		assert(node.parent_ == &this);
+		node.detach();
+	}
 
-		node.detachFast();
+	void destroyChildren() {
+		auto child = firstChild_;
+		while (child) {
+			auto next = child.next_;
+			child.destroy();
+			child = next;
+		}
 
+		firstChild_ = null;
+		lastChild_ = null;
+	}
+
+  void setNext(Node* target) {
+	if(parent_ && parent_.lastChild_ == &this)
+	  parent_.lastChild_ = target;
+	if(next_)
+	  next_.prev_ = target;
+	next_ = target;
+  }
+  void setPrev(Node* target) {
+	if(parent_ && parent_.firstChild_ == &this)
+	  parent_.firstChild_ = target;
+	if(prev_)
+	  prev_.next_ = target;
+	prev_ = target;
+  }
+  void setFirstChild(Node* target) {
+	if(firstChild_) {
+	  // firstChild_.setPrev!(withoutChecking)(target);
+	  target.next_ = firstChild_;
+	  firstChild_.prev_ = target;
+	  firstChild_ = target;
+	  
+	} else {
+	  firstChild_ = target;
+	  target.prev_ = null;
+	}
+  }
+  void setLastChild(Node* target) {
+	if(lastChild_) {
+	  lastChild_.setNext(target);
+	} else {
+	  lastChild_ = target;
+	  target.next_ = null;
+	}
+  }
+
+  void setParent(Node* target) {
+	if(parent_) {
+	  if(parent_.firstChild_ == &this)
+		parent_.setFirstChild(parent_.firstChild_.next_);
+	  if(parent_.lastChild_ == &this)
+		parent_.setLastChild(parent_.firstChild_.next_);
+	}
+  }
+  
+		
+
+  void prependChild(Node* node) {
+	assert(document_ == node.document_);
+	assert(isElementNode, "cannot prepend to non-element nodes");
+
+	
 		node.parent_ = &this;
 		if (firstChild_) {
 			assert(!firstChild_.prev_);
@@ -337,62 +399,28 @@ struct Node {
 		} else {
 			assert(!firstChild_);
 			firstChild_ = node;
-			firstChild_.prev_ = null;
+			if(firstChild_.prev_) {
+			  firstChild_.prev_.next_ = null;
+			  firstChild_.prev_ = null;
+			}
 			lastChild_ = node;
 		}
-        if(lastChild.next_) {
-            lastChild.next_.prev_ = null;
+        if(lastChild_.next_) {
+            lastChild_.next_.prev_ = null;
             lastChild_.next_ = null;
         }
 	}
 
-	void removeChild(Node* node) {
-		assert(node.parent_ == &this);
-		node.detach();
-	}
-
-	void destroyChildren() {
-		auto child = firstChild_;
-		while (child) {
-			auto next = child.next_;
-			child.destroy();
-			child = next;
-		}
-
-		firstChild_ = null;
-		lastChild_ = null;
-	}
-
-	void prependText(HTMLString text) {
-		auto node = document_.createTextNode(text);
-		if (firstChild_) {
-			assert(firstChild_.prev_ == null);
-			firstChild_.prev_ = node;
-			node.next_ = firstChild_;
-			firstChild_ = node;
-		} else {
-			assert(lastChild_ == null);
-			firstChild_ = node;
-			lastChild_ = node;
-		}
-		node.parent_ = &this;
-	}
+  
+  void prependText(HTMLString text) {
+	// TODO: merge with firstChild_ if firstChild_.isTextNode
+	prependChild(document_.createTextNode(text));
+  }
 
-	void appendText(HTMLString text) {
-		auto node = document_.createTextNode(text);
-		if (lastChild_) {
-			assert(lastChild_.next_ == null);
-			lastChild_.next_ = node;
-			node.prev_ = lastChild_;
-			lastChild_ = node;
-		} else {
-			assert(firstChild_ == null);
-			firstChild_ = node;
-			lastChild_ = node;
-		}
-		lastChild_.next_ = null;
-		node.parent_ = &this;
-	}
+  void appendText(HTMLString text) {
+	// TODO: merge with lastChild_ if lastChild_.isTextNode
+	appendChild(document_.createTextNode(text));
+  }
 
 	void insertBefore(Node* node) {
 		assert(document_ == node.document_);
@@ -413,6 +441,7 @@ struct Node {
 	}
 
 	void insertAfter(Node* node) {
+	  assert(node);
 		assert(document_ == node.document_);
 		detachFast();
 
@@ -458,7 +487,14 @@ struct Node {
 				static if(careful) {
 				  prev_ = null;
 				}
+			  } else {
+				import std.format;
+				import std.stdio;
+				writeln(format("debug me! %x == %x ",
+									parent_.firstChild_,&this));
 			  }
+
+			  // uggh next_ should be non-null too! how is it not happening?
 			  if (next_) {
 				next_.prev_ = prev_;
 				static if(careful) {
@@ -466,6 +502,9 @@ struct Node {
 				}
 			  }
 			}
+			static if(careful) {
+			  parent_ = null;
+			}
 		} else {
 		  static if(careful) {
 			if(prev_) {

From c7d700785dc606c61d79ace88f284c59dca220e0 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 01:22:01 +0000
Subject: [PATCH 24/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/dom.d) 116 2678

---
 src/html/dom.d | 198 +++++++++++++++++++------------------------------
 1 file changed, 77 insertions(+), 121 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 83426a4..48dc7d3 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -216,6 +216,10 @@ enum NodeTypes : ubyte {
 	ProcessingInstruction,
 }
 
+void debugme(string message) {
+  import std.stdio;
+  writeln("debug me! ",message);
+}
 
 struct Node {
 	package this(Document* document, HTMLString tag) {
@@ -315,102 +319,46 @@ struct Node {
 		lastChild_ = null;
 	}
 
-  void setNext(Node* target) {
-	if(parent_ && parent_.lastChild_ == &this)
-	  parent_.lastChild_ = target;
-	if(next_)
-	  next_.prev_ = target;
-	next_ = target;
-  }
-  void setPrev(Node* target) {
-	if(parent_ && parent_.firstChild_ == &this)
-	  parent_.firstChild_ = target;
-	if(prev_)
-	  prev_.next_ = target;
-	prev_ = target;
-  }
-  void setFirstChild(Node* target) {
-	if(firstChild_) {
-	  // firstChild_.setPrev!(withoutChecking)(target);
-	  target.next_ = firstChild_;
-	  firstChild_.prev_ = target;
-	  firstChild_ = target;
-	  
-	} else {
-	  firstChild_ = target;
-	  target.prev_ = null;
-	}
-  }
-  void setLastChild(Node* target) {
-	if(lastChild_) {
-	  lastChild_.setNext(target);
-	} else {
-	  lastChild_ = target;
-	  target.next_ = null;
-	}
-  }
+  void prependChild(Node* node) {
+	assert(document_ == node.document_);
+	assert(isElementNode, "cannot prepend to non-element nodes");
 
-  void setParent(Node* target) {
-	if(parent_) {
-	  if(parent_.firstChild_ == &this)
-		parent_.setFirstChild(parent_.firstChild_.next_);
-	  if(parent_.lastChild_ == &this)
-		parent_.setLastChild(parent_.firstChild_.next_);
+	node.detachFast();
+	node.parent_ = &this;
+	if (firstChild_) {
+	  assert(!firstChild_.prev_);
+	  firstChild_.prev_ = node;
+	  node.next_ = firstChild_;
+	  firstChild_ = node;
+	} else {
+	  assert(!lastChild_);
+	  firstChild_ = node;
+	  lastChild_ = node;
+	  firstChild_.prev_ = null;
+	  lastChild_.next_ = null;
 	}
   }
   
-		
-
-  void prependChild(Node* node) {
+  void appendChild(Node* node) {
 	assert(document_ == node.document_);
-	assert(isElementNode, "cannot prepend to non-element nodes");
-
+	assert(isElementNode, "cannot append to non-element nodes");
 	
-		node.parent_ = &this;
-		if (firstChild_) {
-			assert(!firstChild_.prev_);
-			firstChild_.prev_ = node;
-			node.next_ = firstChild_;
-			firstChild_ = node;
-		} else {
-			assert(!lastChild_);
-			firstChild_ = node;
-			lastChild_ = node;
-			lastChild_.next_ = null;
-		}
-        if(firstChild_.prev_) {
-            firstChild_.prev_.next_ = null;
-            firstChild_.prev_ = null;
-        }
-	}
-
-	void appendChild(Node* node) {
-		assert(document_ == node.document_);
-		assert(isElementNode, "cannot append to non-element nodes");
-
-		node.detachFast();
-
-		node.parent_ = &this;
-		if (lastChild_) {
-			assert(!lastChild_.next_);
-			lastChild_.next_ = node;
-			node.prev_ = lastChild_;
-			lastChild_ = node;
-		} else {
-			assert(!firstChild_);
-			firstChild_ = node;
-			if(firstChild_.prev_) {
-			  firstChild_.prev_.next_ = null;
-			  firstChild_.prev_ = null;
-			}
-			lastChild_ = node;
-		}
-        if(lastChild_.next_) {
-            lastChild_.next_.prev_ = null;
-            lastChild_.next_ = null;
-        }
+	node.detachFast();
+
+	node.parent_ = &this;
+	if (lastChild_) {
+	  assert(!lastChild_.next_);
+	  lastChild_.next_ = node;
+	  node.prev_ = lastChild_;
+	  lastChild_ = node;
+	} else {
+	  assert(!firstChild_);
+	  firstChild_ = node;
+	  lastChild_ = node;
+	  firstChild_.prev_ = null;
+	  lastChild_.next_ = null;
 	}
-
+  }
   
   void prependText(HTMLString text) {
 	// TODO: merge with firstChild_ if firstChild_.isTextNode
@@ -422,41 +370,46 @@ struct Node {
 	appendChild(document_.createTextNode(text));
   }
 
-	void insertBefore(Node* node) {
-		assert(document_ == node.document_);
-		assert(node);
-		detachFast();
+  void insertBefore(Node* node) {
+	assert(document_ == node.document_);
+	assert(node);
+	detachFast();
 
-		parent_ = node.parent_;
-		prev_ = node.prev_;
-		next_ = node;
-		node.prev_ = &this;
+	parent_ = node.parent_;
+	prev_ = node.prev_;
+	next_ = node;
+	node.prev_ = &this;
 
-		if (parent_ && (parent_.firstChild_ == node)) {
-		  assert(!prev_);
-		  parent_.firstChild_ = &this;
-		} else if(prev_) {
-		  prev_.next_ = &this;
-		}
+	if (parent_ && (parent_.firstChild_ == node)) {
+	  assert(!prev_);
+	  parent_.firstChild_ = &this;
+	} else if(prev_) {
+	  prev_.next_ = &this;
 	}
+  }
 
-	void insertAfter(Node* node) {
-	  assert(node);
-		assert(document_ == node.document_);
-		detachFast();
+  void insertAfter(Node* node) {
+	assert(node);
+	assert(document_ == node.document_);
+	detachFast();
 
-		parent_ = node.parent_;
-		prev_ = node;
-		next_ = node.next_;
-		node.next_ = &this;
-		if(parent_ && (parent_.lastChild_ == node)) {
-		  assert(!next_);
-		  parent_.lastChild_ = &this;
-		} else if(next_) {
-		  next_.prev_ = &this;
-		}
+	parent_ = node.parent_;
+	next_ = node.next_;
+	prev_ = node;
+	node.next_ = &this;
+
+	if(parent_ && (parent_.lastChild_ == node)) {
+	  assert(!next_);
+	  parent_.lastChild_ = &this;
+	} else if(next_) {
+	  next_.prev_ = &this;
 	}
+  }
 
+  /* !careful => detach everything else, but leave our pointers pointing
+	 old places.
+	 careful => set our pointers to null
+  */
 	private void packageDetach(bool careful)() {
 		if (parent_) {
 			if (parent_.firstChild_ == &this) {
@@ -488,10 +441,7 @@ struct Node {
 				  prev_ = null;
 				}
 			  } else {
-				import std.format;
-				import std.stdio;
-				writeln(format("debug me! %x == %x ",
-									parent_.firstChild_,&this));
+				debugme("prev_ should be non-null");
 			  }
 
 			  // uggh next_ should be non-null too! how is it not happening?
@@ -500,12 +450,16 @@ struct Node {
 				static if(careful) {
 				  next_ = null;
 				}
+			  } else {
+				debugme("next_ should be non-null");
 			  }
 			}
 			static if(careful) {
 			  parent_ = null;
 			}
 		} else {
+		  // when not being careful, let's just assume a parentless node
+		  // was just created, so shall have no next or prev to check.
 		  static if(careful) {
 			if(prev_) {
 			  prev_.next_ = next_;
@@ -525,6 +479,8 @@ struct Node {
 		  }
 		}
 	  static if(careful) {
+		// just making sure no non-nulls slip through when we're being
+		// careful.
 		assert(prev_ is null);
 		assert(next_ is null);
 	  }

From e6e971f786628bd4dfefc01e9679eeb4b98ef87a Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 03:23:26 +0000
Subject: [PATCH 25/31] auto
 (/extra/home/packages/git/dlang/htmld/src/html/dom.d) 50 1070

---
 src/html/dom.d | 58 ++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 44 insertions(+), 14 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 48dc7d3..afbd710 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -216,9 +216,19 @@ enum NodeTypes : ubyte {
 	ProcessingInstruction,
 }
 
-void debugme(string message) {
+void debugderp(T)(T tag) {
   import std.stdio;
-  writeln("debug me! ",message);
+  import std.string;
+  import std.algorithm.comparison;
+  writeln(tag
+		  .replace("\n",`\n`)
+		  .replace("\t",`\t`)[0..min($,20)]);
+}
+
+void debugme(T)(T message) {
+  import std.stdio;
+  import std.conv: to;
+  throw new Exception("debug me! "~to!string(message));
 }
 
 struct Node {
@@ -319,30 +329,42 @@ struct Node {
 		lastChild_ = null;
 	}
 
+  void derp(string message, Node* node) {
+	import std.stdio;
+	writeln(message);
+	debugderp(tag_);
+	writeln(prev_);
+	debugderp(node.tag_);
+	writeln(node.prev_);
+  }
+
   void prependChild(Node* node) {
 	assert(document_ == node.document_);
 	assert(isElementNode, "cannot prepend to non-element nodes");
-
+	scope(exit) derp("prependChild",node);
 	node.detachFast();
 	node.parent_ = &this;
 	if (firstChild_) {
 	  assert(!firstChild_.prev_);
 	  firstChild_.prev_ = node;
 	  node.next_ = firstChild_;
+	  node.prev_ = null;
 	  firstChild_ = node;
 	} else {
 	  assert(!lastChild_);
+	  node.prev_ = node.next_ = null;
 	  firstChild_ = node;
 	  lastChild_ = node;
-	  firstChild_.prev_ = null;
-	  lastChild_.next_ = null;
 	}
   }
   
   void appendChild(Node* node) {
 	assert(document_ == node.document_);
 	assert(isElementNode, "cannot append to non-element nodes");
-	
+	derp("appendChild",node);
+	if(node.tag_.find("Waking up groggi").length > 0) {
+	  debugme("derp");
+	}
 	node.detachFast();
 
 	node.parent_ = &this;
@@ -350,13 +372,13 @@ struct Node {
 	  assert(!lastChild_.next_);
 	  lastChild_.next_ = node;
 	  node.prev_ = lastChild_;
+	  node.next_ = null;
 	  lastChild_ = node;
 	} else {
 	  assert(!firstChild_);
+	  node.prev_ = node.next_ = null;
 	  firstChild_ = node;
 	  lastChild_ = node;
-	  firstChild_.prev_ = null;
-	  lastChild_.next_ = null;
 	}
   }
   
@@ -373,6 +395,7 @@ struct Node {
   void insertBefore(Node* node) {
 	assert(document_ == node.document_);
 	assert(node);
+	derp("insertBefore",node);
 	detachFast();
 
 	parent_ = node.parent_;
@@ -391,6 +414,7 @@ struct Node {
   void insertAfter(Node* node) {
 	assert(node);
 	assert(document_ == node.document_);
+	derp("insertAfter",node);
 	detachFast();
 
 	parent_ = node.parent_;
@@ -413,6 +437,7 @@ struct Node {
 	private void packageDetach(bool careful)() {
 		if (parent_) {
 			if (parent_.firstChild_ == &this) {
+			  assert(prev_ is null);
 				parent_.firstChild_ = next_;
 				if (next_) {
 					next_.prev_ = null;
@@ -427,21 +452,26 @@ struct Node {
 				  assert(prev_ == null);
 				}
 			} else if (parent_.lastChild_ == &this) {
+			  assert(next_ is null);
 				parent_.lastChild_ = prev_;
-				assert(prev_);
-				assert(next_ is null);
-				prev_.next_ = null;
-				static if(careful) {
-				  prev_ = null;
+				if (prev_) {
+					prev_.next_ = null;
+					static if(careful) {
+					  prev_ = null;
+					}
+				} else {
+				  parent_.firstChild_ = null;
 				}
 			} else {
+			  // somewhere in the middle
 			  if(prev_) {
 				prev_.next_ = next_;
 				static if(careful) {
 				  prev_ = null;
 				}
 			  } else {
-				debugme("prev_ should be non-null");
+				debugderp(tag_);
+				debugme("prev_ should be non-null ");
 			  }
 
 			  // uggh next_ should be non-null too! how is it not happening?

From 39e0665c5c4b0407a2435fb805a503cf2b33f945 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 03:49:56 +0000
Subject: [PATCH 26/31] detach setting prev_ to null erroneously

---
 src/html/dom.d | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index afbd710..8c9aeaf 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -363,7 +363,8 @@ struct Node {
 	assert(isElementNode, "cannot append to non-element nodes");
 	derp("appendChild",node);
 	if(node.tag_.find("Waking up groggi").length > 0) {
-	  debugme("derp");
+	  import std.stdio;
+	  writeln("derp");
 	}
 	node.detachFast();
 
@@ -466,23 +467,21 @@ struct Node {
 			  // somewhere in the middle
 			  if(prev_) {
 				prev_.next_ = next_;
-				static if(careful) {
-				  prev_ = null;
-				}
 			  } else {
 				debugderp(tag_);
 				debugme("prev_ should be non-null ");
 			  }
-
 			  // uggh next_ should be non-null too! how is it not happening?
 			  if (next_) {
 				next_.prev_ = prev_;
-				static if(careful) {
-				  next_ = null;
-				}
 			  } else {
 				debugme("next_ should be non-null");
 			  }
+			  
+			  static if(careful) {
+				prev_ = next_ = null;
+			  }
+
 			}
 			static if(careful) {
 			  parent_ = null;

From 235cddf5b4ee93103b8eda5e061345ac63fab94a Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 04:36:50 +0000
Subject: [PATCH 27/31] Support for merging text nodes

Tired of lonely text nodes with just "\n" in them.
---
 src/html/dom.d | 66 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 47 insertions(+), 19 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 8c9aeaf..85b9d03 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -12,7 +12,6 @@ import html.parser;
 import html.alloc;
 import html.utils;
 
-
 alias HTMLString = const(char)[];
 
 enum OnlyElements = "(a) => { return a.isElementNode; }";
@@ -346,10 +345,16 @@ struct Node {
 	node.parent_ = &this;
 	if (firstChild_) {
 	  assert(!firstChild_.prev_);
+	  if(document_.mergeTextNodes &&
+		 firstChild_.isTextNode && node.isTextNode) {
+		firstChild_.tag_ = node.tag_ ~ firstChild_.tag_;
+		node.document_.destroyNode(node);
+		return;
+	  }	  
 	  firstChild_.prev_ = node;
 	  node.next_ = firstChild_;
 	  node.prev_ = null;
-	  firstChild_ = node;
+	  firstChild_ = node;	
 	} else {
 	  assert(!lastChild_);
 	  node.prev_ = node.next_ = null;
@@ -371,6 +376,13 @@ struct Node {
 	node.parent_ = &this;
 	if (lastChild_) {
 	  assert(!lastChild_.next_);
+	  if(document_.mergeTextNodes &&
+		 lastChild_.isTextNode && node.isTextNode) {
+		lastChild_.tag_ = lastChild_.tag_ ~ node.tag_;
+		node.document_.destroyNode(node);
+		return;
+	  }
+
 	  lastChild_.next_ = node;
 	  node.prev_ = lastChild_;
 	  node.next_ = null;
@@ -384,13 +396,19 @@ struct Node {
   }
   
   void prependText(HTMLString text) {
-	// TODO: merge with firstChild_ if firstChild_.isTextNode
-	prependChild(document_.createTextNode(text));
+	if(isElementNode) {
+	  prependChild(document_.createTextNode(text));
+	} else {
+	  tag_ = text ~ tag;
+	}
   }
 
   void appendText(HTMLString text) {
-	// TODO: merge with lastChild_ if lastChild_.isTextNode
-	appendChild(document_.createTextNode(text));
+	if(isElementNode) {
+	  appendChild(document_.createTextNode(text));
+	} else {
+	  tag_ = tag ~ text;
+	}
   }
 
   void insertBefore(Node* node) {
@@ -398,6 +416,12 @@ struct Node {
 	assert(node);
 	derp("insertBefore",node);
 	detachFast();
+	if(document_.mergeTextNodes &&
+	   isTextNode && node.isTextNode) {
+	  node.tag_ = tag_ ~ node.tag_;
+	  document_.destroyNode(&this);
+	  return;
+	}	
 
 	parent_ = node.parent_;
 	prev_ = node.prev_;
@@ -417,7 +441,12 @@ struct Node {
 	assert(document_ == node.document_);
 	derp("insertAfter",node);
 	detachFast();
-
+	if(document_.mergeTextNodes &&
+	   isTextNode && node.isTextNode) {
+	  node.tag_ = node.tag_ ~ tag_;
+	  document_.destroyNode(&this);
+	  return;
+	}	
 	parent_ = node.parent_;
 	next_ = node.next_;
 	prev_ = node;
@@ -492,15 +521,12 @@ struct Node {
 		  static if(careful) {
 			if(prev_) {
 			  prev_.next_ = next_;
-			  static if(careful) {
-				prev_ = null;
-			  }
 			}
 			if(next_) {
 			  next_.prev_ = prev_;
-			  static if(careful) {
-				next_ = null;
-			  }
+			}
+			static if(careful) {
+			  next_ = prev_ = null;
 			}
 		  } else {
 			assert(prev_ is null);
@@ -863,8 +889,8 @@ public:/*package:*/
 	Document* document_;
 }
 
-auto ref createDocument(HTMLString source) {
-	auto document = createDocument();
+auto ref createDocument(HTMLString source, bool mergeTextNodes = true) {
+	auto document = createDocument(mergeTextNodes);
 	auto builder = DOMBuilder!(Document)(document);
 	parseHTML!(typeof(builder))(source, builder);
 	return document;
@@ -918,9 +944,9 @@ unittest {
 
 
 
-static auto ref createDocument() {
+static auto ref createDocument(bool mergeTextNodes = true) {
 	auto document = new Document;
-	document.initialize();
+	document.initialize(mergeTextNodes);
 	document.root(document.createElement("root"));
 	return document;
 }
@@ -992,7 +1018,7 @@ struct Document {
 
 	Document* clone() const {
 		Document* other = new Document;
-		other.initialize();
+		other.initialize(this.mergeTextNodes);
 		other.root(other.clone(this.root_));
 		return other;
 	}
@@ -1104,12 +1130,14 @@ struct Document {
 	}
 
 public:/*private:*/
-	void initialize() {
+	void initialize(bool mergeTextNodes) {
 		alloc_.init;
+		this.mergeTextNodes = mergeTextNodes;
 	}
 
 	Node* root_;
 	PageAllocator!(Node, 1024) alloc_;
+    bool mergeTextNodes;
 }
 
 

From 0eb9b907265493cb54cc8045e5b9d172b3885f51 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 04:39:17 +0000
Subject: [PATCH 28/31] Removing debug stuff

---
 src/html/dom.d | 49 +++++--------------------------------------------
 1 file changed, 5 insertions(+), 44 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 85b9d03..56e316c 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -215,21 +215,6 @@ enum NodeTypes : ubyte {
 	ProcessingInstruction,
 }
 
-void debugderp(T)(T tag) {
-  import std.stdio;
-  import std.string;
-  import std.algorithm.comparison;
-  writeln(tag
-		  .replace("\n",`\n`)
-		  .replace("\t",`\t`)[0..min($,20)]);
-}
-
-void debugme(T)(T message) {
-  import std.stdio;
-  import std.conv: to;
-  throw new Exception("debug me! "~to!string(message));
-}
-
 struct Node {
 	package this(Document* document, HTMLString tag) {
 		tag_ = tag;
@@ -328,19 +313,9 @@ struct Node {
 		lastChild_ = null;
 	}
 
-  void derp(string message, Node* node) {
-	import std.stdio;
-	writeln(message);
-	debugderp(tag_);
-	writeln(prev_);
-	debugderp(node.tag_);
-	writeln(node.prev_);
-  }
-
   void prependChild(Node* node) {
 	assert(document_ == node.document_);
 	assert(isElementNode, "cannot prepend to non-element nodes");
-	scope(exit) derp("prependChild",node);
 	node.detachFast();
 	node.parent_ = &this;
 	if (firstChild_) {
@@ -366,11 +341,6 @@ struct Node {
   void appendChild(Node* node) {
 	assert(document_ == node.document_);
 	assert(isElementNode, "cannot append to non-element nodes");
-	derp("appendChild",node);
-	if(node.tag_.find("Waking up groggi").length > 0) {
-	  import std.stdio;
-	  writeln("derp");
-	}
 	node.detachFast();
 
 	node.parent_ = &this;
@@ -414,7 +384,6 @@ struct Node {
   void insertBefore(Node* node) {
 	assert(document_ == node.document_);
 	assert(node);
-	derp("insertBefore",node);
 	detachFast();
 	if(document_.mergeTextNodes &&
 	   isTextNode && node.isTextNode) {
@@ -439,7 +408,6 @@ struct Node {
   void insertAfter(Node* node) {
 	assert(node);
 	assert(document_ == node.document_);
-	derp("insertAfter",node);
 	detachFast();
 	if(document_.mergeTextNodes &&
 	   isTextNode && node.isTextNode) {
@@ -494,18 +462,11 @@ struct Node {
 				}
 			} else {
 			  // somewhere in the middle
-			  if(prev_) {
-				prev_.next_ = next_;
-			  } else {
-				debugderp(tag_);
-				debugme("prev_ should be non-null ");
-			  }
-			  // uggh next_ should be non-null too! how is it not happening?
-			  if (next_) {
-				next_.prev_ = prev_;
-			  } else {
-				debugme("next_ should be non-null");
-			  }
+			  assert(prev_,"prev_ should be non-null");
+			  prev_.next_ = next_;
+
+			  assert(next_,"next_ should be non-null");
+			  next_.prev_ = prev_;
 			  
 			  static if(careful) {
 				prev_ = next_ = null;

From a77ba715bba2231b67118c974e5d1a6c7fea25f4 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 04:40:12 +0000
Subject: [PATCH 29/31] Just a diagram of some tree mutations

---
 tree-mutation.dia | Bin 0 -> 14721 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tree-mutation.dia

diff --git a/tree-mutation.dia b/tree-mutation.dia
new file mode 100644
index 0000000000000000000000000000000000000000..ee50f729de97196388adead8c2b7601006e2a68b
GIT binary patch
literal 14721
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
ATL1t6

literal 0
HcmV?d00001


From e315362863c4c6fd289f65abbc9231b35e6ad11d Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 31 Mar 2016 08:24:44 +0000
Subject: [PATCH 30/31] added an assert gotcha while inserting

could probably just ignore the asserts in detachFast, instead.
---
 src/html/dom.d | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 56e316c..7b3dc54 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -407,6 +407,9 @@ struct Node {
 
   void insertAfter(Node* node) {
 	assert(node);
+    assert(node.parent_);
+    // can't insert into a parentless node
+    // since we're assuming in detachFast that !parent implies !prev
 	assert(document_ == node.document_);
 	detachFast();
 	if(document_.mergeTextNodes &&
@@ -414,7 +417,7 @@ struct Node {
 	  node.tag_ = node.tag_ ~ tag_;
 	  document_.destroyNode(&this);
 	  return;
-	}	
+	}
 	parent_ = node.parent_;
 	next_ = node.next_;
 	prev_ = node;
@@ -490,7 +493,7 @@ struct Node {
 			  next_ = prev_ = null;
 			}
 		  } else {
-			assert(prev_ is null);
+			assert(prev_ is null); 
 			assert(next_ is null);
 		  }
 		}

From a063c660831fc95e26038ecbe1cfacf4b31939a8 Mon Sep 17 00:00:00 2001
From: user <nobody>
Date: Thu, 10 Aug 2017 17:33:42 +0000
Subject: [PATCH 31/31] use implicit hashing

---
 src/html/dom.d | 44 +++++++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/src/html/dom.d b/src/html/dom.d
index 7b3dc54..c97c302 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -16,7 +16,6 @@ alias HTMLString = const(char)[];
 
 enum OnlyElements = "(a) => { return a.isElementNode; }";
 
-
 package NodeWrapper!T wrap(T)(T* node) {
 	return NodeWrapper!T(node);
 }
@@ -1272,7 +1271,6 @@ public:/*private:*/
 	HTMLString text_;
 }
 
-
 private struct Rule {
 	enum Flags : ushort {
 		HasTag          = 1 << 0,
@@ -1372,62 +1370,62 @@ private struct Rule {
 
 		if (flags_ & Flags.HasPseudo) {
 			switch (pseudo_) {
-			case hashOf("checked"):
+			case "checked":
 				if (!element.hasAttr("checked"))
 					return false;
 				break;
 
-			case hashOf("enabled"):
+			case "enabled":
 				if (element.hasAttr("disabled"))
 					return false;
 				break;
 
-			case hashOf("disabled"):
+			case "disabled":
 				if (!element.hasAttr("disabled"))
 					return false;
 				break;
 
-			case hashOf("empty"):
+			case "empty":
 				if (element.firstChild_)
 					return false;
 				break;
 
-			case hashOf("optional"):
+			case "optional":
 				if (element.hasAttr("required"))
 					return false;
 				break;
 
-			case hashOf("read-only"):
+			case "read-only":
 				if (!element.hasAttr("readonly"))
 					return false;
 				break;
 
-			case hashOf("read-write"):
+			case "read-write":
 				if (element.hasAttr("readonly"))
 					return false;
 				break;
 
-			case hashOf("required"):
+			case "required":
 				if (!element.hasAttr("required"))
 					return false;
 				break;
 
-			case hashOf("lang"):
+			case "lang":
 				if (element.attr("lang") != pseudoArg_)
 					return false;
 				break;
 
-			case hashOf("first-child"):
+			case "first-child":
 				if (!element.parent_ || (element.parent_.firstChild != element))
 					return false;
 				break;
 
-			case hashOf("last-child"):
+			case "last-child":
 				if (!element.parent_ || (element.parent_.lastChild != element))
 					return false;
 				break;
 
-			case hashOf("first-of-type"):
+			case "first-of-type":
 				auto sibling = element.previousSibling;
 				while (sibling) {
 					if (sibling.isElementNode && sibling.tag.equalsCI(element.tag))
@@ -1436,7 +1434,7 @@ private struct Rule {
 				}
 				break;
 
-			case hashOf("last-of-type"):
+			case "last-of-type":
 				auto sibling = element.nextSibling;
 				while (sibling) {
 					if (sibling.isElementNode && sibling.tag.equalsCI(element.tag))
@@ -1445,7 +1443,7 @@ private struct Rule {
 				}
 				break;
 
-			case hashOf("nth-child"):
+			case "nth-child":
 				auto ith = 1;
 				auto sibling = element.previousSibling;
 				while (sibling) {
@@ -1459,7 +1457,7 @@ private struct Rule {
 					return false;
 				break;
 
-			case hashOf("nth-last-child"):
+			case "nth-last-child":
 				auto ith = 1;
 				auto sibling = element.nextSibling;
 				while (sibling) {
@@ -1473,7 +1471,7 @@ private struct Rule {
 					return false;
 				break;
 
-			case hashOf("nth-of-type"):
+			case "nth-of-type":
 				auto ith = 1;
 				auto sibling = element.previousSibling;
 				while (sibling) {
@@ -1487,7 +1485,7 @@ private struct Rule {
 					return false;
 				break;
 
-			case hashOf("nth-last-of-type"):
+			case "nth-last-of-type":
 				auto ith = 1;
 				auto sibling = element.nextSibling;
 				while (sibling) {
@@ -1501,7 +1499,7 @@ private struct Rule {
 					return false;
 				break;
 
-			case hashOf("only-of-type"):
+			case "only-of-type":
 				auto sibling = element.previousSibling;
 				while (sibling) {
 					if (sibling.isElementNode && sibling.tag.equalsCI(element.tag))
@@ -1516,7 +1514,7 @@ private struct Rule {
 				}
 				break;
 
-			case hashOf("only-child"):
+			case "only-child":
 				auto parent = element.parent_;
 				if (!parent)
 					return false;
@@ -1544,7 +1542,7 @@ public:/*package:*/
 	ushort flags_;
 	MatchType match_;
 	Relation relation_;
-	size_t pseudo_;
+	string pseudo_;
 	HTMLString tag_;
 	HTMLString attr_;
 	HTMLString value_;
@@ -1803,7 +1801,7 @@ struct Selector {
 				if (ptr == end)
 					continue;
 
-				rule.pseudo_ = hashOf(start[0..ptr-start]);
+				rule.pseudo_ = to!string(start[0..ptr-start]);
 				rule.flags_ |= Rule.Flags.HasPseudo;
 				if (*ptr != '(') {
 					state = PostIdentifier;