diff --git a/detach-link-notes.md b/detach-link-notes.md
new file mode 100644
index 0000000..8d0fb58
--- /dev/null
+++ b/detach-link-notes.md
@@ -0,0 +1,68 @@
+* 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;
+```
+
+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 068c00a..c97c302 100644
--- a/src/html/dom.d
+++ b/src/html/dom.d
@@ -12,20 +12,10 @@ import html.parser;
 import html.alloc;
 import html.utils;
 
-
 alias HTMLString = const(char)[];
 
-enum DOMCreateOptions {
-	None = 0,
-	DecodeEntities  = 1 << 0,
-
-	Default = DecodeEntities,
-}
-
-
 enum OnlyElements = "(a) => { return a.isElementNode; }";
 
-
 package NodeWrapper!T wrap(T)(T* node) {
 	return NodeWrapper!T(node);
 }
@@ -224,7 +214,6 @@ enum NodeTypes : ubyte {
 	ProcessingInstruction,
 }
 
-
 struct Node {
 	package this(Document* document, HTMLString tag) {
 		tag_ = tag;
@@ -286,15 +275,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");
 
-		enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
-
 		destroyChildren();
-
-		auto builder = DOMBuilder!(Document)(*document_, &this);
-		parseHTML!(typeof(builder), parserOptions)(html, builder);
+		auto builder = DOMBuilder!(Document)(document_, &this);
+		parseHTML!(typeof(builder))(html, builder);
 	}
 
 	@property auto html() const {
@@ -309,44 +295,6 @@ struct Node {
 		return app.data;
 	}
 
-	void prependChild(Node* node) {
-		assert(document_ == node.document_);
-		assert(isElementNode, "cannot prepend to non-element nodes");
-
-		if (node.parent_)
-			node.detach();
-		node.parent_ = &this;
-		if (firstChild_) {
-			assert(!firstChild_.prev_);
-			firstChild_.prev_ = node;
-			node.next_ = firstChild_;
-			firstChild_ = node;
-		} else {
-			assert(!lastChild_);
-			firstChild_ = node;
-			lastChild_ = node;
-		}
-	}
-
-	void appendChild(Node* node) {
-		assert(document_ == node.document_);
-		assert(isElementNode, "cannot append to non-element nodes");
-
-		if (node.parent_)
-			node.detach();
-		node.parent_ = &this;
-		if (lastChild_) {
-			assert(!lastChild_.next_);
-			lastChild_.next_ = node;
-			node.prev_ = lastChild_;
-			lastChild_ = node;
-		} else {
-			assert(!firstChild_);
-			firstChild_ = node;
-			lastChild_ = node;
-		}
-	}
-
 	void removeChild(Node* node) {
 		assert(node.parent_ == &this);
 		node.detach();
@@ -364,116 +312,201 @@ struct Node {
 		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 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;
-		}
-		node.parent_ = &this;
-	}
-
-	void insertBefore(Node* node) {
-		assert(document_ == node.document_);
-
-		parent_ = node.parent_;
-		prev_ = node.prev_;
-		next_ = node;
-		node.prev_ = &this;
-
-		if (parent_ && (parent_.firstChild_ == node))
-			parent_.firstChild_ = &this;
-	}
-
-	void insertAfter(Node* node) {
-		assert(document_ == node.document_);
-
-		parent_ = node.parent_;
-		prev_ = node;
-		next_ = node.next_;
-		node.next_ = &this;
-	}
-
-	void detach() {
+  void prependChild(Node* node) {
+	assert(document_ == node.document_);
+	assert(isElementNode, "cannot prepend to non-element nodes");
+	node.detachFast();
+	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;	
+	} else {
+	  assert(!lastChild_);
+	  node.prev_ = node.next_ = null;
+	  firstChild_ = node;
+	  lastChild_ = node;
+	}
+  }
+  
+  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_);
+	  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;
+	  lastChild_ = node;
+	} else {
+	  assert(!firstChild_);
+	  node.prev_ = node.next_ = null;
+	  firstChild_ = node;
+	  lastChild_ = node;
+	}
+  }
+  
+  void prependText(HTMLString text) {
+	if(isElementNode) {
+	  prependChild(document_.createTextNode(text));
+	} else {
+	  tag_ = text ~ tag;
+	}
+  }
+
+  void appendText(HTMLString text) {
+	if(isElementNode) {
+	  appendChild(document_.createTextNode(text));
+	} else {
+	  tag_ = tag ~ text;
+	}
+  }
+
+  void insertBefore(Node* node) {
+	assert(document_ == node.document_);
+	assert(node);
+	detachFast();
+	if(document_.mergeTextNodes &&
+	   isTextNode && node.isTextNode) {
+	  node.tag_ = tag_ ~ node.tag_;
+	  document_.destroyNode(&this);
+	  return;
+	}	
+
+	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;
+	}
+  }
+
+  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 &&
+	   isTextNode && node.isTextNode) {
+	  node.tag_ = node.tag_ ~ tag_;
+	  document_.destroyNode(&this);
+	  return;
+	}
+	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) {
+			  assert(prev_ is null);
 				parent_.firstChild_ = next_;
 				if (next_) {
 					next_.prev_ = null;
-					next_ = null;
+					static if(careful) {
+					  next_ = null;
+					}
 				} else {
 					parent_.lastChild_ = null;
 				}
 
-				assert(prev_ == null);
+				static if(careful) {
+				  assert(prev_ == null);
+				}
 			} else if (parent_.lastChild_ == &this) {
+			  assert(next_ is null);
 				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;
-		}
-	}
-
-	package void detachFast() {
-		if (parent_) {
-			if (parent_.firstChild_ == &this) {
-				parent_.firstChild_ = next_;
-				if (next_) {
-					next_.prev_ = null;
+				if (prev_) {
+					prev_.next_ = null;
+					static if(careful) {
+					  prev_ = null;
+					}
 				} else {
-					parent_.lastChild_ = null;
+				  parent_.firstChild_ = null;
 				}
-
-				assert(prev_ == null);
-			} else if (parent_.lastChild_ == &this) {
-				parent_.lastChild_ = prev_;
-				assert(prev_);
-				assert(!next_);
-				prev_.next_ = null;
 			} else {
-				assert(prev_);
+			  // somewhere in the middle
+			  assert(prev_,"prev_ should be non-null");
+			  prev_.next_ = next_;
 
-				prev_.next_ = next_;
-				if (next_) {
-					next_.prev_ = prev_;
-				}
+			  assert(next_,"next_ should be non-null");
+			  next_.prev_ = prev_;
+			  
+			  static if(careful) {
+				prev_ = next_ = 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_;
 			}
+			if(next_) {
+			  next_.prev_ = prev_;
+			}
+			static if(careful) {
+			  next_ = prev_ = null;
+			}
+		  } else {
+			assert(prev_ is null); 
+			assert(next_ is null);
+		  }
 		}
+	  static if(careful) {
+		// just making sure no non-nulls slip through when we're being
+		// careful.
+		assert(prev_ is null);
+		assert(next_ is null);
+	  }
 	}
 
+    public alias detach = packageDetach!true;
+    package alias detachFast = packageDetach!false;
+
 	void destroy() {
 		detachFast();
 		destroyChildren();
@@ -500,7 +533,7 @@ struct Node {
 
 				if (value.length) {
 					app.put("=\"");
-					writeHTMLEscaped(app, value);
+					app.put(value);
 					app.put("\"");
 				}
 			}
@@ -524,7 +557,7 @@ struct Node {
 			}
 			break;
 		case Text:
-			writeHTMLEscaped(app, tag_);
+		  app.put(tag_);
 			break;
 		case Comment:
 			app.put("<!--");
@@ -561,7 +594,7 @@ struct Node {
 
 				if (value.length) {
 					app.put("=\"");
-					writeHTMLEscaped(app, value);
+					app.put(value);
 					app.put("\"");
 				}
 			}
@@ -572,7 +605,7 @@ struct Node {
 			}
 			break;
 		case Text:
-			writeHTMLEscaped(app, tag_);
+			app.put(tag_);
 			break;
 		case Comment:
 			app.put("<!--");
@@ -796,7 +829,7 @@ struct Node {
 		return document_.clone(&this);
 	}
 
-package:
+public:/*package:*/
 	enum TypeMask	= 0x7;
 	enum TypeShift	= 0;
 	enum FlagsBit	= TypeMask + 1;
@@ -819,21 +852,16 @@ package:
 	Document* document_;
 }
 
-auto createDocument(size_t options = DOMCreateOptions.Default)(HTMLString source) {
-	enum parserOptions = ((options & DOMCreateOptions.DecodeEntities) ? ParserOptions.DecodeEntities : 0);
-
-	auto document = createDocument();
+auto ref createDocument(HTMLString source, bool mergeTextNodes = true) {
+	auto document = createDocument(mergeTextNodes);
 	auto builder = DOMBuilder!(Document)(document);
-
-	parseHTML!(typeof(builder), parserOptions)(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>&#160;</body></html></root>`);
-	doc = createDocument!(DOMCreateOptions.None)(`<html><body>&nbsp;</body></html>`);
-	assert(doc.root.outerHTML == `<root><html><body>&amp;nbsp;</body></html></root>`);
+  auto doc = createDocument(`<html><body>&nbsp;</body></html>`);
+	assert(doc.root.outerHTML == `<root><html><body>&nbsp;</body></html></root>`,doc.root.outerHTML);
 	doc = createDocument(`<script>&nbsp;</script>`);
 	assert(doc.root.outerHTML == `<root><script>&nbsp;</script></root>`, doc.root.outerHTML);
 	doc = createDocument(`<style>&nbsp;</style>`);
@@ -870,24 +898,25 @@ 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>`);
 }
 
 
 
-static auto createDocument() {
-	auto document = Document();
-	document.init();
+static auto ref createDocument(bool mergeTextNodes = true) {
+	auto document = new Document;
+	document.initialize(mergeTextNodes);
 	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);
@@ -950,9 +979,9 @@ struct Document {
 		return source.clone(&this);
 	}
 
-	Document clone() const {
-		Document other = Document();
-		other.init();
+	Document* clone() const {
+		Document* other = new Document;
+		other.initialize(this.mergeTextNodes);
 		other.root(other.clone(this.root_));
 		return other;
 	}
@@ -1005,8 +1034,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;
 		}
@@ -1017,6 +1047,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;
 		}
@@ -1060,13 +1092,15 @@ struct Document {
 		return alloc_;
 	}
 
-private:
-	void init() {
+public:/*private:*/
+	void initialize(bool mergeTextNodes) {
 		alloc_.init;
+		this.mergeTextNodes = mergeTextNodes;
 	}
 
 	Node* root_;
 	PageAllocator!(Node, 1024) alloc_;
+    bool mergeTextNodes;
 }
 
 
@@ -1081,7 +1115,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);
 
@@ -1101,10 +1135,23 @@ 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;
+  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;
 	}
 
@@ -1126,7 +1173,6 @@ struct DOMBuilder(Document) {
 			element_.appendText(text_);
 			text_.length = 0;
 		}
-
 		auto element = document_.createElement(data, element_);
 		element_ = element;
 	}
@@ -1183,7 +1229,7 @@ struct DOMBuilder(Document) {
 	}
 
 	void onComment(HTMLString data) {
-		document_.createCommentNode(data, element_);
+	  document_.createCommentNode(data, element_);
 	}
 
 	void onDeclaration(HTMLString data) {
@@ -1204,29 +1250,13 @@ struct DOMBuilder(Document) {
 				element_.appendText(text_);
 				text_.length = 0;
 			} else {
-				document_.root.appendText(text_);
-			}
-		}
-	}
-
-	void onNamedEntity(HTMLString data) {
-	}
-
-	void onNumericEntity(HTMLString data) {
-	}
 
-	void onHexEntity(HTMLString data) {
-	}
-
-	void onEntity(HTMLString data, HTMLString decoded) {
-		if (state_ == States.Global) {
-			text_ ~= decoded;
-		} else {
-			value_ ~= decoded;
+			  document_.root.appendText(text_);
+			}
 		}
 	}
 
-private:
+public:/*private:*/
 	Document* document_;
 	Node* element_;
 	States state_;
@@ -1241,7 +1271,6 @@ private:
 	HTMLString text_;
 }
 
-
 private struct Rule {
 	enum Flags : ushort {
 		HasTag          = 1 << 0,
@@ -1341,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))
@@ -1405,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))
@@ -1414,7 +1443,7 @@ private struct Rule {
 				}
 				break;
 
-			case hashOf("nth-child"):
+			case "nth-child":
 				auto ith = 1;
 				auto sibling = element.previousSibling;
 				while (sibling) {
@@ -1428,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) {
@@ -1442,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) {
@@ -1456,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) {
@@ -1470,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))
@@ -1485,7 +1514,7 @@ private struct Rule {
 				}
 				break;
 
-			case hashOf("only-child"):
+			case "only-child":
 				auto parent = element.parent_;
 				if (!parent)
 					return false;
@@ -1509,11 +1538,11 @@ private struct Rule {
 		return relation_;
 	}
 
-package:
+public:/*package:*/
 	ushort flags_;
 	MatchType match_;
 	Relation relation_;
-	size_t pseudo_;
+	string pseudo_;
 	HTMLString tag_;
 	HTMLString attr_;
 	HTMLString value_;
@@ -1772,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;
@@ -1888,7 +1917,7 @@ struct Selector {
 		return true;
 	}
 
-private:
+public:/*private:*/
 	HTMLString source_;
 	Rule[] rules_;
 }
diff --git a/src/html/escape.d b/src/html/escape.d
new file mode 100644
index 0000000..97883cc
--- /dev/null
+++ b/src/html/escape.d
@@ -0,0 +1,253 @@
+module html.escape;
+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 = '>',
+};
+
+enum AttributeEscapes {
+  quot = '"',
+  apos = '\'',
+}
+
+/* miscellanelambdaous names for different unicode code points */
+enum NamedEscapes {
+  nbsp = ' ',
+}
+
+import std.array: Appender;
+
+bool unescapeEnum(alias Escapes)
+  (ref HTMLString chunk,
+   ref Appender!HTMLString app) {
+  import std.string: startsWith;
+  foreach(e;EnumMembers!Escapes) {
+	auto repr = e.to!dchar.to!string;
+	auto name = e.to!string;
+	if(repr == "\"")
+	  repr = "\\\"";
+	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 HTMLString dest) {
+  foreach(e;EnumMembers!Escapes) {
+	if(c == e) {
+	  auto name = e.to!string;
+	  // mehh
+	  dest = "&" ~ name ~ ";";
+	  return true;
+	}
+  }
+  return false;
+}
+
+auto unescape(bool unicode = true,
+			  bool html = false,
+			  bool attribute = false)
+  (HTMLString s) {
+  import std.array: appender;
+  import std.algorithm.iteration: splitter;
+  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();
+  if(chunks.empty) return s;
+
+  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;
+	  }
+	  static if(attribute) {
+		if(unescapeEnum!AttributeEscapes(chunk,app)) return true;
+	  }
+	  static if(unicode) {
+		switch(chunk[0]) {
+		case '#':
+		  auto pos = chunk[1..$].countUntil(';');
+		  if(pos < 0) return false;
+		  auto num = chunk[1..pos+1];
+		  if(!isNumeric(num)) return false;
+		  app.put(num.to!int.to!dchar.to!string);
+		  app.put(chunk[pos+2..$]);
+		  return true;
+		case 'x':
+		  auto pos = chunk[1..$].countUntil(';');
+		  if(pos < 0) return false;
+		  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(unescapeEnum!NamedEscapes(chunk,app)) return true;
+		}
+	  }
+	  return false;
+	}
+	if(!handle()) {
+	  app.put('&');
+	  app.put(chunk);
+	}
+  }
+  return app.data;
+}
+
+unittest {
+  import std.algorithm.comparison: equal;
+  void assert_equal(HTMLString a, HTMLString b) {
+	if(!equal(a,b)) {
+	  import std.stdio;
+		
+	  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.ascii: isPrintable, isWhite;
+
+  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 = null;
+	/* 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;
+	  }
+	  static if(attribute) {
+		if(escapeEnum!AttributeEscapes(s[i], derp)) return 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.
+		  
+		  // 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"
+			~ 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)
+			~ ";";
+		} catch(Exception e) {
+		  import std.stdio;
+		  writeln(s[i-1..min($,i+4)]);
+		  throw e;
+		}
+		return true;
+	  } else {
+		// not escaping unicode, just keep going past it.
+		return false;
+	  }
+	}
+	if(handle()) {
+	  if(last < i) {
+		app.put(s[last..i]);
+	  }
+	  app.put(derp);
+	  if(sequence_length > 0)
+		i += sequence_length - 1;
+	  last = i + 1;
+	}
+  }
+  if(last < s.length) {
+	app.put(s[last..$]);
+  }
+  return app.data;
+}
+
+void assert_equal(T)(T a, T b) {
+  if(a != b) {
+	import std.stdio;
+	writeln("ugggh ");
+	writeln(a);
+	assert(false);
+  }
+}
+
+unittest {
+  assert_equal(escape!(true,true,true)
+			   (`<hi>`~"\a"~`
+
+--—--<>`),
+			   `&lt;hi&gt;&x07;
+
+--&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;`),
+						  `&lt;test&gt;—--&lt;/te&amp;lt;`);
+
+  assert_equal(escapeEntities(`<test>—--</te&lt;`),
+							  `<test>&x2014;--</te&amp;lt;`);
+  }
diff --git a/src/html/parser.d b/src/html/parser.d
index f6c7467..508aca2 100644
--- a/src/html/parser.d
+++ b/src/html/parser.d
@@ -7,7 +7,6 @@ import std.ascii;
 import std.conv;
 import std.traits;
 
-import html.entities;
 import html.utils;
 
 
@@ -40,13 +39,6 @@ private enum ParserStates {
 	PostComment1,
 	PostComment2,
 
-	// entities
-	PreEntity,
-	PreNumericEntity,
-	NamedEntity,
-	NumericEntity,
-	HexEntity,
-
 	// cdata
 	PreCDATA,
 	PreCDATA_C,
@@ -90,85 +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);
-				handler.onEntity(name, cast(const(char)[])bytes_[offset..offset + codeLength(*pindex)]);
-			}
-
-			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;
@@ -179,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) != '/')))
@@ -203,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:
@@ -420,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:
@@ -662,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;
@@ -925,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) &&
diff --git a/tree-mutation.dia b/tree-mutation.dia
new file mode 100644
index 0000000..ee50f72
Binary files /dev/null and b/tree-mutation.dia differ