node_modules

author: Florian Dold <florian.dold@gmail.com> 2017-05-03 15:35:00 +0200
committer: Florian Dold <florian.dold@gmail.com> 2017-05-03 15:35:00 +0200
commit: de98e0b232509d5f40c135d540a70e415272ff85 (patch)
tree: a79222a5b58484ab3b80d18efcaaa7ccc4769b33 /node_modules/htmlparser2
parent: e0c9d480a73fa629c1e4a47d3e721f1d2d345406 (diff)
76 files changed, 8496 insertions, 0 deletions
diff --git a/node_modules/htmlparser2/.gitattributes b/node_modules/htmlparser2/.gitattributes
new file mode 100644
index 000000000..4bb50dc17
--- /dev/null
+++ b/node_modules/htmlparser2/.gitattributes
@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text eol=lf
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/.npmignore b/node_modules/htmlparser2/.npmignore
new file mode 100644
index 000000000..0db216bfa
--- /dev/null
+++ b/node_modules/htmlparser2/.npmignore
@@ -0,0 +1,2 @@
+npm-debug.log
+node_modules
diff --git a/node_modules/htmlparser2/.travis.yml b/node_modules/htmlparser2/.travis.yml
new file mode 100644
index 000000000..d63ba0956
--- /dev/null
+++ b/node_modules/htmlparser2/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.8
+  - 0.10
+  - 0.11
diff --git a/node_modules/htmlparser2/LICENSE b/node_modules/htmlparser2/LICENSE
new file mode 100644
index 000000000..0a35e029a
--- /dev/null
+++ b/node_modules/htmlparser2/LICENSE
@@ -0,0 +1,18 @@
+Copyright 2010, 2011, Chris Winberry <chris@winberry.net>. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/README.md b/node_modules/htmlparser2/README.md
new file mode 100644
index 000000000..9ed236d41
--- /dev/null
+++ b/node_modules/htmlparser2/README.md
@@ -0,0 +1,81 @@
+#htmlparser2 [![NPM version](https://badge.fury.io/js/htmlparser2.png)](https://npmjs.org/package/htmlparser2) [![Build Status](https://secure.travis-ci.org/fb55/htmlparser2.png)](http://travis-ci.org/fb55/htmlparser2) [![Dependency Status](https://david-dm.org/fb55/htmlparser2.png)](https://david-dm.org/fb55/htmlparser2)
+
+A forgiving HTML/XML/RSS parser written in JS for NodeJS. The parser can handle streams (chunked data) and supports custom handlers for writing custom DOMs/output.
+
+##Installing
+	npm install htmlparser2
+	
+A live demo of htmlparser2 is available at http://demos.forbeslindesay.co.uk/htmlparser2/
+
+##Usage
+
+```javascript
+var htmlparser = require("htmlparser2");
+var parser = new htmlparser.Parser({
+	onopentag: function(name, attribs){
+		if(name === "script" && attribs.type === "text/javascript"){
+			console.log("JS! Hooray!");
+		}
+	},
+	ontext: function(text){
+		console.log("-->", text);
+	},
+	onclosetag: function(tagname){
+		if(tagname === "script"){
+			console.log("That's it?!");
+		}
+	}
+});
+parser.write("Xyz <script type='text/javascript'>var foo = '<<bar>>';</ script>");
+parser.end();
+```
+
+Output (simplified):
+
+```javascript
+--> Xyz 
+JS! Hooray!
+--> var foo = '<<bar>>';
+That's it?!
+```
+
+Read more about the parser in the [wiki](https://github.com/fb55/htmlparser2/wiki/Parser-options).
+
+##Get a DOM
+The `DomHandler` (known as `DefaultHandler` in the original `htmlparser` module) produces a DOM (document object model) that can be manipulated using the [`DomUtils`](https://github.com/fb55/DomUtils) helper.
+
+The `DomHandler`, while still bundled with this module, was moved to its [own module](https://github.com/fb55/domhandler). Have a look at it for further information.
+
+##Parsing RSS/RDF/Atom Feeds
+
+```javascript
+new htmlparser.FeedHandler(function(<error> error, <object> feed){
+    ...
+});
+```
+
+##Performance
+
+After having some artificial benchmarks for some time, __@AndreasMadsen__ published his [`htmlparser-benchmark`](https://github.com/AndreasMadsen/htmlparser-benchmark), which benchmarks HTML parses based on real-world websites.
+
+At the time of writing, the latest versions of all supported parsers show the following performance characteristics on [Travis CI](https://travis-ci.org/AndreasMadsen/htmlparser-benchmark/builds/10805007) (please note that Travis doesn't guarantee equal conditions for all tests):
+
+```
+gumbo-parser   : 34.9208 ms/file ± 21.4238
+html-parser    : 24.8224 ms/file ± 15.8703
+html5          : 419.597 ms/file ± 264.265
+htmlparser     : 60.0722 ms/file ± 384.844
+htmlparser2-dom: 12.0749 ms/file ± 6.49474
+htmlparser2    : 7.49130 ms/file ± 5.74368
+hubbub         : 30.4980 ms/file ± 16.4682
+libxmljs       : 14.1338 ms/file ± 18.6541
+parse5         : 22.0439 ms/file ± 15.3743
+sax            : 49.6513 ms/file ± 26.6032
+```
+
+##How is this different from [node-htmlparser](https://github.com/tautologistics/node-htmlparser)?
+This is a fork of the `htmlparser` module. The main difference is that this is intended to be used only with node (it runs on other platforms using [browserify](https://github.com/substack/node-browserify)). `htmlparser2` was rewritten multiple times and, while it maintains an API that's compatible with `htmlparser` in most cases, the projects don't share any code anymore.
+
+The parser now provides a callback interface close to [sax.js](https://github.com/isaacs/sax-js) (originally targeted at [readabilitySAX](https://github.com/fb55/readabilitysax)). As a result, old handlers won't work anymore.
+
+The `DefaultHandler` and the `RssHandler` were renamed to clarify their purpose (to `DomHandler` and `FeedHandler`). The old names are still available when requiring `htmlparser2`, so your code should work as expected.
diff --git a/node_modules/htmlparser2/lib/CollectingHandler.js b/node_modules/htmlparser2/lib/CollectingHandler.js
new file mode 100644
index 000000000..8d63305ae
--- /dev/null
+++ b/node_modules/htmlparser2/lib/CollectingHandler.js
@@ -0,0 +1,55 @@
+module.exports = CollectingHandler;
+
+function CollectingHandler(cbs){
+	this._cbs = cbs || {};
+	this.events = [];
+}
+
+var EVENTS = require("./").EVENTS;
+Object.keys(EVENTS).forEach(function(name){
+	if(EVENTS[name] === 0){
+		name = "on" + name;
+		CollectingHandler.prototype[name] = function(){
+			this.events.push([name]);
+			if(this._cbs[name]) this._cbs[name]();
+		};
+	} else if(EVENTS[name] === 1){
+		name = "on" + name;
+		CollectingHandler.prototype[name] = function(a){
+			this.events.push([name, a]);
+			if(this._cbs[name]) this._cbs[name](a);
+		};
+	} else if(EVENTS[name] === 2){
+		name = "on" + name;
+		CollectingHandler.prototype[name] = function(a, b){
+			this.events.push([name, a, b]);
+			if(this._cbs[name]) this._cbs[name](a, b);
+		};
+	} else {
+		throw Error("wrong number of arguments");
+	}
+});
+
+CollectingHandler.prototype.onreset = function(){
+	this.events = [];
+	if(this._cbs.onreset) this._cbs.onreset();
+};
+
+CollectingHandler.prototype.restart = function(){
+	if(this._cbs.onreset) this._cbs.onreset();
+
+	for(var i = 0, len = this.events.length; i < len; i++){
+		if(this._cbs[this.events[i][0]]){
+
+			var num = this.events[i].length;
+
+			if(num === 1){
+				this._cbs[this.events[i][0]]();
+			} else if(num === 2){
+				this._cbs[this.events[i][0]](this.events[i][1]);
+			} else {
+				this._cbs[this.events[i][0]](this.events[i][1], this.events[i][2]);
+			}
+		}
+	}
+};
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/FeedHandler.js b/node_modules/htmlparser2/lib/FeedHandler.js
new file mode 100644
index 000000000..8b7d32cd0
--- /dev/null
+++ b/node_modules/htmlparser2/lib/FeedHandler.js
@@ -0,0 +1,95 @@
+var index = require("./index.js"),
+    DomHandler = index.DomHandler,
+	DomUtils = index.DomUtils;
+
+//TODO: make this a streamable handler
+function FeedHandler(callback, options){
+	this.init(callback, options);
+}
+
+require("util").inherits(FeedHandler, DomHandler);
+
+FeedHandler.prototype.init = DomHandler;
+
+function getElements(what, where){
+	return DomUtils.getElementsByTagName(what, where, true);
+}
+function getOneElement(what, where){
+	return DomUtils.getElementsByTagName(what, where, true, 1)[0];
+}
+function fetch(what, where, recurse){
+	return DomUtils.getText(
+		DomUtils.getElementsByTagName(what, where, recurse, 1)
+	).trim();
+}
+
+function addConditionally(obj, prop, what, where, recurse){
+	var tmp = fetch(what, where, recurse);
+	if(tmp) obj[prop] = tmp;
+}
+
+var isValidFeed = function(value) {
+	return value === "rss" || value === "feed" || value === "rdf:RDF";
+};
+
+FeedHandler.prototype.onend = function() {
+	var feed = {},
+		feedRoot = getOneElement(isValidFeed, this.dom),
+		tmp, childs;
+
+	if (feedRoot) {
+		if(feedRoot.name === "feed"){
+			childs = feedRoot.children;
+
+			feed.type = "atom";
+			addConditionally(feed, "id", "id", childs);
+			addConditionally(feed, "title", "title", childs);
+			if((tmp = getOneElement("link", childs)) && (tmp = tmp.attribs) && (tmp = tmp.href)) feed.link = tmp;
+			addConditionally(feed, "description", "subtitle", childs);
+			if(tmp = fetch("updated", childs)) feed.updated = new Date(tmp);
+			addConditionally(feed, "author", "email", childs, true);
+
+			feed.items = getElements("entry", childs).map(function(item){
+				var entry = {}, tmp;
+
+				item = item.children;
+
+				addConditionally(entry, "id", "id", item);
+				addConditionally(entry, "title", "title", item);
+				if((tmp = getOneElement("link", item)) && (tmp = tmp.attribs) && (tmp = tmp.href)) entry.link = tmp;
+				addConditionally(entry, "description", "summary", item);
+				if(tmp = fetch("updated", item)) entry.pubDate = new Date(tmp);
+				return entry;
+			});
+		} else{
+			childs = getOneElement("channel", feedRoot.children).children;
+
+			feed.type = feedRoot.name.substr(0, 3);
+			feed.id = "";
+			addConditionally(feed, "title", "title", childs);
+			addConditionally(feed, "link", "link", childs);
+			addConditionally(feed, "description", "description", childs);
+			if(tmp = fetch("lastBuildDate", childs)) feed.updated = new Date(tmp);
+			addConditionally(feed, "author", "managingEditor", childs, true);
+
+			feed.items = getElements("item", feedRoot.children).map(function(item){
+				var entry = {}, tmp;
+
+				item = item.children;
+
+				addConditionally(entry, "id", "guid", item);
+				addConditionally(entry, "title", "title", item);
+				addConditionally(entry, "link", "link", item);
+				addConditionally(entry, "description", "description", item);
+				if(tmp = fetch("pubDate", item)) entry.pubDate = new Date(tmp);
+				return entry;
+			});
+		}
+	}
+	this.dom = feed;
+	DomHandler.prototype._handleCallback.call(
+		this, feedRoot ? null : Error("couldn't find root of feed")
+	);
+};
+
+module.exports = FeedHandler;
diff --git a/node_modules/htmlparser2/lib/Parser.js b/node_modules/htmlparser2/lib/Parser.js
new file mode 100644
index 000000000..e94e346f8
--- /dev/null
+++ b/node_modules/htmlparser2/lib/Parser.js
@@ -0,0 +1,314 @@
+var Tokenizer = require("./Tokenizer.js");
+
+/*
+	Options:
+
+	xmlMode: Special behavior for script/style tags (true by default)
+	lowerCaseAttributeNames: call .toLowerCase for each attribute name (true if xmlMode is `false`)
+	lowerCaseTags: call .toLowerCase for each tag name (true if xmlMode is `false`)
+*/
+
+/*
+	Callbacks:
+
+	oncdataend,
+	oncdatastart,
+	onclosetag,
+	oncomment,
+	oncommentend,
+	onerror,
+	onopentag,
+	onprocessinginstruction,
+	onreset,
+	ontext
+*/
+
+var formTags = {
+	input: true,
+	option: true,
+	optgroup: true,
+	select: true,
+	button: true,
+	datalist: true,
+	textarea: true
+};
+
+var openImpliesClose = {
+	tr      : { tr:true, th:true, td:true },
+	th      : { th:true },
+	td      : { thead:true, td:true },
+	body    : { head:true, link:true, script:true },
+	li      : { li:true },
+	p       : { p:true },
+	select  : formTags,
+	input   : formTags,
+	output  : formTags,
+	button  : formTags,
+	datalist: formTags,
+	textarea: formTags,
+	option  : { option:true },
+	optgroup: { optgroup:true }
+};
+
+var voidElements = {
+	__proto__: null,
+	area: true,
+	base: true,
+	basefont: true,
+	br: true,
+	col: true,
+	command: true,
+	embed: true,
+	frame: true,
+	hr: true,
+	img: true,
+	input: true,
+	isindex: true,
+	keygen: true,
+	link: true,
+	meta: true,
+	param: true,
+	source: true,
+	track: true,
+	wbr: true
+};
+
+var re_nameEnd = /\s|\//;
+
+function Parser(cbs, options){
+	this._options = options || {};
+	this._cbs = cbs || {};
+
+	this._tagname = "";
+	this._attribname = "";
+	this._attribvalue = "";
+	this._attribs = null;
+	this._stack = [];
+	this._done = false;
+
+	this.startIndex = 0;
+	this.endIndex = null;
+
+	this._tokenizer = new Tokenizer(options, this);
+}
+
+require("util").inherits(Parser, require("events").EventEmitter);
+
+Parser.prototype._updatePosition = function(initialOffset){
+	if(this.endIndex === null){
+		this.startIndex = this._tokenizer._sectionStart <= initialOffset ? 0 : this._tokenizer._sectionStart - initialOffset;
+	}
+	this.startIndex = this.endIndex + 1;
+	this.endIndex = this._tokenizer._index;
+};
+
+//Tokenizer event handlers
+Parser.prototype.ontext = function(data){
+	this._updatePosition(1);
+	this.endIndex--;
+
+	if(this._cbs.ontext) this._cbs.ontext(data);
+};
+
+Parser.prototype.onopentagname = function(name){
+	if(!(this._options.xmlMode || "lowerCaseTags" in this._options) || this._options.lowerCaseTags){
+		name = name.toLowerCase();
+	}
+
+	this._tagname = name;
+
+	if (!this._options.xmlMode && name in openImpliesClose) {
+		for(
+			var el;
+			(el = this._stack[this._stack.length-1]) in openImpliesClose[name];
+			this.onclosetag(el)
+		);
+	}
+
+	if(this._options.xmlMode || !(name in voidElements)){
+		this._stack.push(name);
+	}
+
+	if(this._cbs.onopentagname) this._cbs.onopentagname(name);
+	if(this._cbs.onopentag) this._attribs = {};
+};
+
+Parser.prototype.onopentagend = function(){
+	this._updatePosition(1);
+    
+	if(this._attribs){
+		if(this._cbs.onopentag) this._cbs.onopentag(this._tagname, this._attribs);
+		this._attribs = null;
+	}
+    
+	if(!this._options.xmlMode && this._cbs.onclosetag && this._tagname in voidElements){
+		this._cbs.onclosetag(this._tagname);
+	}
+    
+	this._tagname = "";
+};
+
+Parser.prototype.onclosetag = function(name){
+	this._updatePosition(1);
+
+	if(!(this._options.xmlMode || "lowerCaseTags" in this._options) || this._options.lowerCaseTags){
+		name = name.toLowerCase();
+	}
+
+	if(this._stack.length && (!(name in voidElements) || this._options.xmlMode)){
+		var pos = this._stack.lastIndexOf(name);
+		if(pos !== -1){
+			if(this._cbs.onclosetag){
+				pos = this._stack.length - pos;
+				while(pos--) this._cbs.onclosetag(this._stack.pop());
+			}
+			else this._stack.length = pos;
+		} else if(name === "p" && !this._options.xmlMode){
+			this.onopentagname(name);
+			this._closeCurrentTag();
+		}
+	} else if(!this._options.xmlMode && (name === "br" || name === "p")){
+		this.onopentagname(name);
+		this._closeCurrentTag();
+	}
+};
+
+Parser.prototype.onselfclosingtag = function(){
+	if(this._options.xmlMode){
+		this._closeCurrentTag();
+	} else {
+		this.onopentagend();
+	}
+};
+
+Parser.prototype._closeCurrentTag = function(){
+	var name = this._tagname;
+
+	this.onopentagend();
+
+	//self-closing tags will be on the top of the stack
+	//(cheaper check than in onclosetag)
+	if(this._stack[this._stack.length-1] === name){
+		if(this._cbs.onclosetag){
+			this._cbs.onclosetag(name);
+		}
+		this._stack.pop();
+	}
+};
+
+Parser.prototype.onattribname = function(name){
+	if(!(this._options.xmlMode || "lowerCaseAttributeNames" in this._options) || this._options.lowerCaseAttributeNames){
+		name = name.toLowerCase();
+	}
+	this._attribname = name;
+};
+
+Parser.prototype.onattribdata = function(value){
+	this._attribvalue += value;
+};
+
+Parser.prototype.onattribend = function(){
+	if(this._cbs.onattribute) this._cbs.onattribute(this._attribname, this._attribvalue);
+	if(
+		this._attribs &&
+		!Object.prototype.hasOwnProperty.call(this._attribs, this._attribname)
+	){
+		this._attribs[this._attribname] = this._attribvalue;
+	}
+	this._attribname = "";
+	this._attribvalue = "";
+};
+
+Parser.prototype.ondeclaration = function(value){
+	if(this._cbs.onprocessinginstruction){
+		var idx = value.search(re_nameEnd),
+		    name = idx < 0 ? value : value.substr(0, idx);
+
+		if(!(this._options.xmlMode || "lowerCaseTags" in this._options) || this._options.lowerCaseTags){
+			name = name.toLowerCase();
+		}
+		this._cbs.onprocessinginstruction("!" + name, "!" + value);
+	}
+};
+
+Parser.prototype.onprocessinginstruction = function(value){
+	if(this._cbs.onprocessinginstruction){
+		var idx = value.search(re_nameEnd),
+		    name = idx < 0 ? value : value.substr(0, idx);
+
+		if(!(this._options.xmlMode || "lowerCaseTags" in this._options) || this._options.lowerCaseTags){
+			name = name.toLowerCase();
+		}
+		this._cbs.onprocessinginstruction("?" + name, "?" + value);
+	}
+};
+
+Parser.prototype.oncomment = function(value){
+	this._updatePosition(4);
+
+	if(this._cbs.oncomment) this._cbs.oncomment(value);
+	if(this._cbs.oncommentend) this._cbs.oncommentend();
+};
+
+Parser.prototype.oncdata = function(value){
+	this._updatePosition(1);
+
+	if(this._options.xmlMode){
+		if(this._cbs.oncdatastart) this._cbs.oncdatastart();
+		if(this._cbs.ontext) this._cbs.ontext(value);
+		if(this._cbs.oncdataend) this._cbs.oncdataend();
+	} else {
+		this.oncomment("[CDATA[" + value + "]]");
+	}
+};
+
+Parser.prototype.onerror = function(err){
+	if(this._cbs.onerror) this._cbs.onerror(err);
+};
+
+Parser.prototype.onend = function(){
+	if(this._cbs.onclosetag){
+		for(
+			var i = this._stack.length;
+			i > 0;
+			this._cbs.onclosetag(this._stack[--i])
+		);
+	}
+	if(this._cbs.onend) this._cbs.onend();
+};
+
+
+//Resets the parser to a blank state, ready to parse a new HTML document
+Parser.prototype.reset = function(){
+	if(this._cbs.onreset) this._cbs.onreset();
+	this._tokenizer.reset();
+
+	this._tagname = "";
+	this._attribname = "";
+	this._attribs = null;
+	this._stack = [];
+	this._done = false;
+};
+
+//Parses a complete HTML document and pushes it to the handler
+Parser.prototype.parseComplete = function(data){
+	this.reset();
+	this.end(data);
+};
+
+Parser.prototype.write = function(chunk){
+	if(this._done) this.onerror(Error(".write() after done!"));
+	this._tokenizer.write(chunk);
+};
+
+Parser.prototype.end = function(chunk){
+	if(this._done) this.onerror(Error(".end() after done!"));
+	this._tokenizer.end(chunk);
+	this._done = true;
+};
+
+//alias for backwards compat
+Parser.prototype.parseChunk = Parser.prototype.write;
+Parser.prototype.done = Parser.prototype.end;
+
+module.exports = Parser;
diff --git a/node_modules/htmlparser2/lib/ProxyHandler.js b/node_modules/htmlparser2/lib/ProxyHandler.js
new file mode 100644
index 000000000..1f9f38a76
--- /dev/null
+++ b/node_modules/htmlparser2/lib/ProxyHandler.js
@@ -0,0 +1,27 @@
+module.exports = ProxyHandler;
+
+var ProxyHandler = function(cbs){
+	this._cbs = cbs || {};
+};
+
+var EVENTS = require("./").EVENTS;
+Object.keys(EVENTS).forEach(function(name){
+	if(EVENTS[name] === 0){
+		name = "on" + name;
+		ProxyHandler.prototype[name] = function(){
+			if(this._cbs[name]) this._cbs[name]();
+		};
+	} else if(EVENTS[name] === 1){
+		name = "on" + name;
+		ProxyHandler.prototype[name] = function(a){
+			if(this._cbs[name]) this._cbs[name](a);
+		};
+	} else if(EVENTS[name] === 2){
+		name = "on" + name;
+		ProxyHandler.prototype[name] = function(a, b){
+			if(this._cbs[name]) this._cbs[name](a, b);
+		};
+	} else {
+		throw Error("wrong number of arguments");
+	}
+});
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/Stream.js b/node_modules/htmlparser2/lib/Stream.js
new file mode 100644
index 000000000..29a819b1b
--- /dev/null
+++ b/node_modules/htmlparser2/lib/Stream.js
@@ -0,0 +1,35 @@
+module.exports = Stream;
+
+var Parser = require("./WritableStream.js");
+
+function Stream(options){
+	Parser.call(this, new Cbs(this), options);
+}
+
+require("util").inherits(Stream, Parser);
+
+Stream.prototype.readable = true;
+
+function Cbs(scope){
+	this.scope = scope;
+}
+
+var EVENTS = require("../").EVENTS;
+
+Object.keys(EVENTS).forEach(function(name){
+	if(EVENTS[name] === 0){
+		Cbs.prototype["on" + name] = function(){
+			this.scope.emit(name);
+		};
+	} else if(EVENTS[name] === 1){
+		Cbs.prototype["on" + name] = function(a){
+			this.scope.emit(name, a);
+		};
+	} else if(EVENTS[name] === 2){
+		Cbs.prototype["on" + name] = function(a, b){
+			this.scope.emit(name, a, b);
+		};
+	} else {
+		throw Error("wrong number of arguments!");
+	}
+});
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/Tokenizer.js b/node_modules/htmlparser2/lib/Tokenizer.js
new file mode 100644
index 000000000..ef98766b8
--- /dev/null
+++ b/node_modules/htmlparser2/lib/Tokenizer.js
@@ -0,0 +1,876 @@
+module.exports = Tokenizer;
+
+var entityMap = require("./entities/entities.json"),
+    legacyMap = require("./entities/legacy.json"),
+    xmlMap    = require("./entities/xml.json"),
+    decodeMap = require("./entities/decode.json"),
+
+    i = 0,
+
+    TEXT                      = i++,
+    BEFORE_TAG_NAME           = i++, //after <
+    IN_TAG_NAME               = i++,
+    IN_SELF_CLOSING_TAG       = i++,
+    BEFORE_CLOSING_TAG_NAME   = i++,
+    IN_CLOSING_TAG_NAME       = i++,
+    AFTER_CLOSING_TAG_NAME    = i++,
+
+    //attributes
+    BEFORE_ATTRIBUTE_NAME     = i++,
+    IN_ATTRIBUTE_NAME         = i++,
+    AFTER_ATTRIBUTE_NAME      = i++,
+    BEFORE_ATTRIBUTE_VALUE    = i++,
+    IN_ATTRIBUTE_VALUE_DQ     = i++, // "
+    IN_ATTRIBUTE_VALUE_SQ     = i++, // '
+    IN_ATTRIBUTE_VALUE_NQ     = i++,
+
+    //declarations
+    BEFORE_DECLARATION        = i++, // !
+    IN_DECLARATION            = i++,
+
+    //processing instructions
+    IN_PROCESSING_INSTRUCTION = i++, // ?
+
+    //comments
+    BEFORE_COMMENT            = i++,
+    IN_COMMENT                = i++,
+    AFTER_COMMENT_1           = i++,
+    AFTER_COMMENT_2           = i++,
+
+    //cdata
+    BEFORE_CDATA_1            = i++, // [
+    BEFORE_CDATA_2            = i++, // C
+    BEFORE_CDATA_3            = i++, // D
+    BEFORE_CDATA_4            = i++, // A
+    BEFORE_CDATA_5            = i++, // T
+    BEFORE_CDATA_6            = i++, // A
+    IN_CDATA                  = i++,// [
+    AFTER_CDATA_1             = i++, // ]
+    AFTER_CDATA_2             = i++, // ]
+
+    //special tags
+    BEFORE_SPECIAL            = i++, //S
+    BEFORE_SPECIAL_END        = i++,   //S
+
+    BEFORE_SCRIPT_1           = i++, //C
+    BEFORE_SCRIPT_2           = i++, //R
+    BEFORE_SCRIPT_3           = i++, //I
+    BEFORE_SCRIPT_4           = i++, //P
+    BEFORE_SCRIPT_5           = i++, //T
+    AFTER_SCRIPT_1            = i++, //C
+    AFTER_SCRIPT_2            = i++, //R
+    AFTER_SCRIPT_3            = i++, //I
+    AFTER_SCRIPT_4            = i++, //P
+    AFTER_SCRIPT_5            = i++, //T
+
+    BEFORE_STYLE_1            = i++, //T
+    BEFORE_STYLE_2            = i++, //Y
+    BEFORE_STYLE_3            = i++, //L
+    BEFORE_STYLE_4            = i++, //E
+    AFTER_STYLE_1             = i++, //T
+    AFTER_STYLE_2             = i++, //Y
+    AFTER_STYLE_3             = i++, //L
+    AFTER_STYLE_4             = i++, //E
+
+    BEFORE_ENTITY             = i++, //&
+    BEFORE_NUMERIC_ENTITY     = i++, //#
+    IN_NAMED_ENTITY           = i++,
+    IN_NUMERIC_ENTITY         = i++,
+    IN_HEX_ENTITY             = i++, //X
+
+    j = 0,
+
+    SPECIAL_NONE              = j++,
+    SPECIAL_SCRIPT            = j++,
+    SPECIAL_STYLE             = j++;
+
+function whitespace(c){
+	return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
+}
+
+function ifElseState(upper, SUCCESS, FAILURE){
+	var lower = upper.toLowerCase();
+
+	if(upper === lower){
+		return function(c){
+			this._state = c === lower ? SUCCESS : FAILURE;
+		};
+	} else {
+		return function(c){
+			this._state = (c === lower || c === upper) ? SUCCESS : FAILURE;
+		};
+	}
+}
+
+function consumeSpecialNameChar(upper, NEXT_STATE){
+	var lower = upper.toLowerCase();
+
+	return function(c){
+		if(c === lower || c === upper){
+			this._state = NEXT_STATE;
+		} else {
+			this._state = IN_TAG_NAME;
+			this._index--; //consume the token again
+		}
+	};
+}
+
+function Tokenizer(options, cbs){
+	this._state = TEXT;
+	this._buffer = "";
+	this._sectionStart = 0;
+	this._index = 0;
+	this._baseState = TEXT;
+	this._special = SPECIAL_NONE;
+	this._cbs = cbs;
+	this._running = true;
+	this._xmlMode = !!(options && options.xmlMode);
+	this._decodeEntities = !!(options && options.decodeEntities);
+}
+
+Tokenizer.prototype._stateText = function(c){
+	if(c === "<"){
+		if(this._index > this._sectionStart){
+			this._cbs.ontext(this._getSection());
+		}
+		this._state = BEFORE_TAG_NAME;
+		this._sectionStart = this._index;
+	} else if(this._decodeEntities && this._special === SPECIAL_NONE && c === "&"){
+		if(this._index > this._sectionStart){
+			this._cbs.ontext(this._getSection());
+		}
+		this._baseState = TEXT;
+		this._state = BEFORE_ENTITY;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateBeforeTagName = function(c){
+	if(c === "/"){
+		this._state = BEFORE_CLOSING_TAG_NAME;
+	} else if(c === ">" || this._special !== SPECIAL_NONE || whitespace(c)) {
+		this._state = TEXT;
+	} else if(c === "!"){
+		this._state = BEFORE_DECLARATION;
+		this._sectionStart = this._index + 1;
+	} else if(c === "?"){
+		this._state = IN_PROCESSING_INSTRUCTION;
+		this._sectionStart = this._index + 1;
+	} else if(c === "<"){
+		this._cbs.ontext(this._getSection());
+		this._sectionStart = this._index;
+	} else {
+		this._state = (!this._xmlMode && (c === "s" || c === "S")) ?
+						BEFORE_SPECIAL : IN_TAG_NAME;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInTagName = function(c){
+	if(c === "/" || c === ">" || whitespace(c)){
+		this._emitToken("onopentagname");
+		this._state = BEFORE_ATTRIBUTE_NAME;
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._stateBeforeCloseingTagName = function(c){
+	if(whitespace(c));
+	else if(c === ">"){
+		this._state = TEXT;
+	} else if(this._special !== SPECIAL_NONE){
+		if(c === "s" || c === "S"){
+			this._state = BEFORE_SPECIAL_END;
+		} else {
+			this._state = TEXT;
+			this._index--;
+		}
+	} else {
+		this._state = IN_CLOSING_TAG_NAME;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInCloseingTagName = function(c){
+	if(c === ">" || whitespace(c)){
+		this._emitToken("onclosetag");
+		this._state = AFTER_CLOSING_TAG_NAME;
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._stateAfterCloseingTagName = function(c){
+	//skip everything until ">"
+	if(c === ">"){
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	}
+};
+
+Tokenizer.prototype._stateBeforeAttributeName = function(c){
+	if(c === ">"){
+		this._cbs.onopentagend();
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	} else if(c === "/"){
+		this._state = IN_SELF_CLOSING_TAG;
+	} else if(!whitespace(c)){
+		this._state = IN_ATTRIBUTE_NAME;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInSelfClosingTag = function(c){
+	if(c === ">"){
+		this._cbs.onselfclosingtag();
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	} else if(!whitespace(c)){
+		this._state = BEFORE_ATTRIBUTE_NAME;
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._stateInAttributeName = function(c){
+	if(c === "=" || c === "/" || c === ">" || whitespace(c)){
+		if(this._index > this._sectionStart){
+			this._cbs.onattribname(this._getSection());
+		}
+		this._sectionStart = -1;
+		this._state = AFTER_ATTRIBUTE_NAME;
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._stateAfterAttributeName = function(c){
+	if(c === "="){
+		this._state = BEFORE_ATTRIBUTE_VALUE;
+	} else if(c === "/" || c === ">"){
+		this._cbs.onattribend();
+		this._state = BEFORE_ATTRIBUTE_NAME;
+		this._index--;
+	} else if(!whitespace(c)){
+		this._cbs.onattribend();
+		this._state = IN_ATTRIBUTE_NAME;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateBeforeAttributeValue = function(c){
+	if(c === "\""){
+		this._state = IN_ATTRIBUTE_VALUE_DQ;
+		this._sectionStart = this._index + 1;
+	} else if(c === "'"){
+		this._state = IN_ATTRIBUTE_VALUE_SQ;
+		this._sectionStart = this._index + 1;
+	} else if(!whitespace(c)){
+		this._state = IN_ATTRIBUTE_VALUE_NQ;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInAttributeValueDoubleQuotes = function(c){
+	if(c === "\""){
+		this._emitToken("onattribdata");
+		this._cbs.onattribend();
+		this._state = BEFORE_ATTRIBUTE_NAME;
+	} else if(this._decodeEntities && c === "&"){
+		this._emitToken("onattribdata");
+		this._baseState = this._state;
+		this._state = BEFORE_ENTITY;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInAttributeValueSingleQuotes = function(c){
+	if(c === "'"){
+		this._emitToken("onattribdata");
+		this._cbs.onattribend();
+		this._state = BEFORE_ATTRIBUTE_NAME;
+	} else if(this._decodeEntities && c === "&"){
+		this._emitToken("onattribdata");
+		this._baseState = this._state;
+		this._state = BEFORE_ENTITY;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateInAttributeValueNoQuotes = function(c){
+	if(whitespace(c) || c === ">"){
+		this._emitToken("onattribdata");
+		this._cbs.onattribend();
+		this._state = BEFORE_ATTRIBUTE_NAME;
+		this._index--;
+	} else if(this._decodeEntities && c === "&"){
+		this._emitToken("onattribdata");
+		this._baseState = this._state;
+		this._state = BEFORE_ENTITY;
+		this._sectionStart = this._index;
+	}
+};
+
+Tokenizer.prototype._stateBeforeDeclaration = function(c){
+	this._state = c === "[" ? BEFORE_CDATA_1 :
+					c === "-" ? BEFORE_COMMENT :
+						IN_DECLARATION;
+};
+
+Tokenizer.prototype._stateInDeclaration = function(c){
+	if(c === ">"){
+		this._cbs.ondeclaration(this._getSection());
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	}
+};
+
+Tokenizer.prototype._stateInProcessingInstruction = function(c){
+	if(c === ">"){
+		this._cbs.onprocessinginstruction(this._getSection());
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	}
+};
+
+Tokenizer.prototype._stateBeforeComment = function(c){
+	if(c === "-"){
+		this._state = IN_COMMENT;
+		this._sectionStart = this._index + 1;
+	} else {
+		this._state = IN_DECLARATION;
+	}
+};
+
+Tokenizer.prototype._stateInComment = function(c){
+	if(c === "-") this._state = AFTER_COMMENT_1;
+};
+
+Tokenizer.prototype._stateAfterComment1 = ifElseState("-", AFTER_COMMENT_2, IN_COMMENT);
+
+Tokenizer.prototype._stateAfterComment2 = function(c){
+	if(c === ">"){
+		//remove 2 trailing chars
+		this._cbs.oncomment(this._buffer.substring(this._sectionStart, this._index - 2));
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	} else if(c !== "-"){
+		this._state = IN_COMMENT;
+	}
+	// else: stay in AFTER_COMMENT_2 (`--->`)
+};
+
+Tokenizer.prototype._stateBeforeCdata1 = ifElseState("C", BEFORE_CDATA_2, IN_DECLARATION);
+Tokenizer.prototype._stateBeforeCdata2 = ifElseState("D", BEFORE_CDATA_3, IN_DECLARATION);
+Tokenizer.prototype._stateBeforeCdata3 = ifElseState("A", BEFORE_CDATA_4, IN_DECLARATION);
+Tokenizer.prototype._stateBeforeCdata4 = ifElseState("T", BEFORE_CDATA_5, IN_DECLARATION);
+Tokenizer.prototype._stateBeforeCdata5 = ifElseState("A", BEFORE_CDATA_6, IN_DECLARATION);
+
+Tokenizer.prototype._stateBeforeCdata6 = function(c){
+	if(c === "["){
+		this._state = IN_CDATA;
+		this._sectionStart = this._index + 1;
+	} else {
+		this._state = IN_DECLARATION;
+	}
+};
+
+Tokenizer.prototype._stateInCdata = function(c){
+	if(c === "]") this._state = AFTER_CDATA_1;
+};
+
+Tokenizer.prototype._stateAfterCdata1 = ifElseState("]", AFTER_CDATA_2, IN_CDATA);
+
+Tokenizer.prototype._stateAfterCdata2 = function(c){
+	if(c === ">"){
+		//remove 2 trailing chars
+		this._cbs.oncdata(this._buffer.substring(this._sectionStart, this._index - 2));
+		this._state = TEXT;
+		this._sectionStart = this._index + 1;
+	} else if (c !== "]") {
+		this._state = IN_CDATA;
+	}
+	//else: stay in AFTER_CDATA_2 (`]]]>`)
+};
+
+Tokenizer.prototype._stateBeforeSpecial = function(c){
+	if(c === "c" || c === "C"){
+		this._state = BEFORE_SCRIPT_1;
+	} else if(c === "t" || c === "T"){
+		this._state = BEFORE_STYLE_1;
+	} else {
+		this._state = IN_TAG_NAME;
+		this._index--; //consume the token again
+	}
+};
+
+Tokenizer.prototype._stateBeforeSpecialEnd = function(c){
+	if(this._special === SPECIAL_SCRIPT && (c === "c" || c === "C")){
+		this._state = AFTER_SCRIPT_1;
+	} else if(this._special === SPECIAL_STYLE && (c === "t" || c === "T")){
+		this._state = AFTER_STYLE_1;
+	}
+	else this._state = TEXT;
+};
+
+Tokenizer.prototype._stateBeforeScript1 = consumeSpecialNameChar("R", BEFORE_SCRIPT_2);
+Tokenizer.prototype._stateBeforeScript2 = consumeSpecialNameChar("I", BEFORE_SCRIPT_3);
+Tokenizer.prototype._stateBeforeScript3 = consumeSpecialNameChar("P", BEFORE_SCRIPT_4);
+Tokenizer.prototype._stateBeforeScript4 = consumeSpecialNameChar("T", BEFORE_SCRIPT_5);
+
+Tokenizer.prototype._stateBeforeScript5 = function(c){
+	if(c === "/" || c === ">" || whitespace(c)){
+		this._special = SPECIAL_SCRIPT;
+	}
+	this._state = IN_TAG_NAME;
+	this._index--; //consume the token again
+};
+
+Tokenizer.prototype._stateAfterScript1 = ifElseState("R", AFTER_SCRIPT_2, TEXT);
+Tokenizer.prototype._stateAfterScript2 = ifElseState("I", AFTER_SCRIPT_3, TEXT);
+Tokenizer.prototype._stateAfterScript3 = ifElseState("P", AFTER_SCRIPT_4, TEXT);
+Tokenizer.prototype._stateAfterScript4 = ifElseState("T", AFTER_SCRIPT_5, TEXT);
+
+Tokenizer.prototype._stateAfterScript5 = function(c){
+	if(c === ">" || whitespace(c)){
+		this._special = SPECIAL_NONE;
+		this._state = IN_CLOSING_TAG_NAME;
+		this._sectionStart = this._index - 6;
+		this._index--; //reconsume the token
+	}
+	else this._state = TEXT;
+};
+
+Tokenizer.prototype._stateBeforeStyle1 = consumeSpecialNameChar("Y", BEFORE_STYLE_2);
+Tokenizer.prototype._stateBeforeStyle2 = consumeSpecialNameChar("L", BEFORE_STYLE_3);
+Tokenizer.prototype._stateBeforeStyle3 = consumeSpecialNameChar("E", BEFORE_STYLE_4);
+
+Tokenizer.prototype._stateBeforeStyle4 = function(c){
+	if(c === "/" || c === ">" || whitespace(c)){
+		this._special = SPECIAL_STYLE;
+	}
+	this._state = IN_TAG_NAME;
+	this._index--; //consume the token again
+};
+
+Tokenizer.prototype._stateAfterStyle1 = ifElseState("Y", AFTER_STYLE_2, TEXT);
+Tokenizer.prototype._stateAfterStyle2 = ifElseState("L", AFTER_STYLE_3, TEXT);
+Tokenizer.prototype._stateAfterStyle3 = ifElseState("E", AFTER_STYLE_4, TEXT);
+
+Tokenizer.prototype._stateAfterStyle4 = function(c){
+	if(c === ">" || whitespace(c)){
+		this._special = SPECIAL_NONE;
+		this._state = IN_CLOSING_TAG_NAME;
+		this._sectionStart = this._index - 5;
+		this._index--; //reconsume the token
+	}
+	else this._state = TEXT;
+};
+
+Tokenizer.prototype._stateBeforeEntity = ifElseState("#", BEFORE_NUMERIC_ENTITY, IN_NAMED_ENTITY);
+Tokenizer.prototype._stateBeforeNumericEntity = ifElseState("X", IN_HEX_ENTITY, IN_NUMERIC_ENTITY);
+
+//for entities within attributes
+Tokenizer.prototype._parseNamedEntityStrict = function(){
+	//offset = 1
+	if(this._sectionStart + 1 < this._index){
+		var entity = this._buffer.substring(this._sectionStart + 1, this._index),
+		    map = this._xmlMode ? xmlMap : entityMap;
+
+		if(map.hasOwnProperty(entity)){
+			this._emitPartial(map[entity]);
+			this._sectionStart = this._index + 1;
+		}
+	}
+};
+
+
+//parses legacy entities (without trailing semicolon)
+Tokenizer.prototype._parseLegacyEntity = function(){
+	var start = this._sectionStart + 1,
+	    limit = this._index - start;
+
+	if(limit > 6) limit = 6; //the max length of legacy entities is 6
+
+	while(limit >= 2){ //the min length of legacy entities is 2
+		var entity = this._buffer.substr(start, limit);
+
+		if(legacyMap.hasOwnProperty(entity)){
+			this._emitPartial(legacyMap[entity]);
+			this._sectionStart += limit + 2;
+			break;
+		} else {
+			limit--;
+		}
+	}
+};
+
+Tokenizer.prototype._stateInNamedEntity = function(c){
+	if(c === ";"){
+		this._parseNamedEntityStrict();
+		if(this._sectionStart + 1 < this._index && !this._xmlMode){
+			this._parseLegacyEntity();
+		}
+		this._state = this._baseState;
+	} else if((c < "a" || c > "z") && (c < "A" || c > "Z") && (c < "0" || c > "9")){
+		if(this._xmlMode);
+		else if(this._baseState !== TEXT){
+			if(c !== "="){
+				this._parseNamedEntityStrict();
+				this._sectionStart--; //include the current character in the section
+			}
+		} else {
+			this._parseLegacyEntity();
+			this._sectionStart--;
+		}
+		this._state = this._baseState;
+		this._index--;
+	}
+};
+
+// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
+function decodeCodePoint(codePoint){
+	var output = "";
+
+	if((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF){
+		return "\uFFFD";
+	}
+
+	if(codePoint in decodeMap){
+		codePoint = decodeMap[codePoint];
+	}
+
+	if(codePoint > 0xFFFF){
+		codePoint -= 0x10000;
+		output += String.fromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+		codePoint = 0xDC00 | codePoint & 0x3FF;
+	}
+
+	output += String.fromCharCode(codePoint);
+	return output;
+}
+
+Tokenizer.prototype._decodeNumericEntity = function(offset, base){
+	var sectionStart = this._sectionStart + offset;
+
+	if(sectionStart !== this._index){
+		//parse entity
+		var entity = this._buffer.substring(sectionStart, this._index);
+		var parsed = parseInt(entity, base);
+
+		if(parsed === parsed){ //not NaN (TODO: when can this happen?)
+			this._emitPartial(decodeCodePoint(parsed));
+			this._sectionStart = this._index;
+		}
+	}
+
+	this._state = this._baseState;
+};
+
+Tokenizer.prototype._stateInNumericEntity = function(c){
+	if(c === ";"){
+		this._decodeNumericEntity(2, 10);
+		this._sectionStart++;
+	} else if(c < "0" || c > "9"){
+		if(!this._xmlMode){
+			this._decodeNumericEntity(2, 10);
+		} else {
+			this._state = this._baseState;
+		}
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._stateInHexEntity = function(c){
+	if(c === ";"){
+		this._decodeNumericEntity(3, 16);
+		this._sectionStart++;
+	} else if((c < "a" || c > "f") && (c < "A" || c > "F") && (c < "0" || c > "9")){
+		if(!this._xmlMode){
+			this._decodeNumericEntity(3, 16);
+		} else {
+			this._state = this._baseState;
+		}
+		this._index--;
+	}
+};
+
+Tokenizer.prototype._cleanup = function () {
+	if(this._sectionStart < 0){
+		this._buffer = "";
+		this._index = 0;
+	} else {
+		if(this._state === TEXT){
+			if(this._sectionStart !== this._index){
+				this._cbs.ontext(this._buffer.substr(this._sectionStart));
+			}
+			this._buffer = "";
+			this._index = 0;
+		} else if(this._sectionStart === this._index){
+			//the section just started
+			this._buffer = "";
+			this._index = 0;
+		} else {
+			//remove everything unnecessary
+			this._buffer = this._buffer.substr(this._sectionStart);
+			this._index -= this._sectionStart;
+		}
+
+		this._sectionStart = 0;
+	}
+};
+
+//TODO make events conditional
+Tokenizer.prototype.write = function(chunk){
+	this._buffer += chunk;
+
+	while(this._index < this._buffer.length && this._running){
+		var c = this._buffer.charAt(this._index);
+		if(this._state === TEXT) {
+			this._stateText(c);
+		} else if(this._state === BEFORE_TAG_NAME){
+			this._stateBeforeTagName(c);
+		} else if(this._state === IN_TAG_NAME) {
+			this._stateInTagName(c);
+		} else if(this._state === BEFORE_CLOSING_TAG_NAME){
+			this._stateBeforeCloseingTagName(c);
+		} else if(this._state === IN_CLOSING_TAG_NAME){
+			this._stateInCloseingTagName(c);
+		} else if(this._state === AFTER_CLOSING_TAG_NAME){
+			this._stateAfterCloseingTagName(c);
+		} else if(this._state === IN_SELF_CLOSING_TAG){
+			this._stateInSelfClosingTag(c);
+		}
+
+		/*
+		*	attributes
+		*/
+		else if(this._state === BEFORE_ATTRIBUTE_NAME){
+			this._stateBeforeAttributeName(c);
+		} else if(this._state === IN_ATTRIBUTE_NAME){
+			this._stateInAttributeName(c);
+		} else if(this._state === AFTER_ATTRIBUTE_NAME){
+			this._stateAfterAttributeName(c);
+		} else if(this._state === BEFORE_ATTRIBUTE_VALUE){
+			this._stateBeforeAttributeValue(c);
+		} else if(this._state === IN_ATTRIBUTE_VALUE_DQ){
+			this._stateInAttributeValueDoubleQuotes(c);
+		} else if(this._state === IN_ATTRIBUTE_VALUE_SQ){
+			this._stateInAttributeValueSingleQuotes(c);
+		} else if(this._state === IN_ATTRIBUTE_VALUE_NQ){
+			this._stateInAttributeValueNoQuotes(c);
+		}
+
+		/*
+		*	declarations
+		*/
+		else if(this._state === BEFORE_DECLARATION){
+			this._stateBeforeDeclaration(c);
+		} else if(this._state === IN_DECLARATION){
+			this._stateInDeclaration(c);
+		}
+
+		/*
+		*	processing instructions
+		*/
+		else if(this._state === IN_PROCESSING_INSTRUCTION){
+			this._stateInProcessingInstruction(c);
+		}
+
+		/*
+		*	comments
+		*/
+		else if(this._state === BEFORE_COMMENT){
+			this._stateBeforeComment(c);
+		} else if(this._state === IN_COMMENT){
+			this._stateInComment(c);
+		} else if(this._state === AFTER_COMMENT_1){
+			this._stateAfterComment1(c);
+		} else if(this._state === AFTER_COMMENT_2){
+			this._stateAfterComment2(c);
+		}
+
+		/*
+		*	cdata
+		*/
+		else if(this._state === BEFORE_CDATA_1){
+			this._stateBeforeCdata1(c);
+		} else if(this._state === BEFORE_CDATA_2){
+			this._stateBeforeCdata2(c);
+		} else if(this._state === BEFORE_CDATA_3){
+			this._stateBeforeCdata3(c);
+		} else if(this._state === BEFORE_CDATA_4){
+			this._stateBeforeCdata4(c);
+		} else if(this._state === BEFORE_CDATA_5){
+			this._stateBeforeCdata5(c);
+		} else if(this._state === BEFORE_CDATA_6){
+			this._stateBeforeCdata6(c);
+		} else if(this._state === IN_CDATA){
+			this._stateInCdata(c);
+		} else if(this._state === AFTER_CDATA_1){
+			this._stateAfterCdata1(c);
+		} else if(this._state === AFTER_CDATA_2){
+			this._stateAfterCdata2(c);
+		}
+
+		/*
+		* special tags
+		*/
+		else if(this._state === BEFORE_SPECIAL){
+			this._stateBeforeSpecial(c);
+		} else if(this._state === BEFORE_SPECIAL_END){
+			this._stateBeforeSpecialEnd(c);
+		}
+
+		/*
+		* script
+		*/
+		else if(this._state === BEFORE_SCRIPT_1){
+			this._stateBeforeScript1(c);
+		} else if(this._state === BEFORE_SCRIPT_2){
+			this._stateBeforeScript2(c);
+		} else if(this._state === BEFORE_SCRIPT_3){
+			this._stateBeforeScript3(c);
+		} else if(this._state === BEFORE_SCRIPT_4){
+			this._stateBeforeScript4(c);
+		} else if(this._state === BEFORE_SCRIPT_5){
+			this._stateBeforeScript5(c);
+		}
+
+		else if(this._state === AFTER_SCRIPT_1){
+			this._stateAfterScript1(c);
+		} else if(this._state === AFTER_SCRIPT_2){
+			this._stateAfterScript2(c);
+		} else if(this._state === AFTER_SCRIPT_3){
+			this._stateAfterScript3(c);
+		} else if(this._state === AFTER_SCRIPT_4){
+			this._stateAfterScript4(c);
+		} else if(this._state === AFTER_SCRIPT_5){
+			this._stateAfterScript5(c);
+		}
+
+		/*
+		* style
+		*/
+		else if(this._state === BEFORE_STYLE_1){
+			this._stateBeforeStyle1(c);
+		} else if(this._state === BEFORE_STYLE_2){
+			this._stateBeforeStyle2(c);
+		} else if(this._state === BEFORE_STYLE_3){
+			this._stateBeforeStyle3(c);
+		} else if(this._state === BEFORE_STYLE_4){
+			this._stateBeforeStyle4(c);
+		}
+
+		else if(this._state === AFTER_STYLE_1){
+			this._stateAfterStyle1(c);
+		} else if(this._state === AFTER_STYLE_2){
+			this._stateAfterStyle2(c);
+		} else if(this._state === AFTER_STYLE_3){
+			this._stateAfterStyle3(c);
+		} else if(this._state === AFTER_STYLE_4){
+			this._stateAfterStyle4(c);
+		}
+
+		/*
+		* entities
+		*/
+		else if(this._state === BEFORE_ENTITY){
+			this._stateBeforeEntity(c);
+		} else if(this._state === BEFORE_NUMERIC_ENTITY){
+			this._stateBeforeNumericEntity(c);
+		} else if(this._state === IN_NAMED_ENTITY){
+			this._stateInNamedEntity(c);
+		} else if(this._state === IN_NUMERIC_ENTITY){
+			this._stateInNumericEntity(c);
+		} else if(this._state === IN_HEX_ENTITY){
+			this._stateInHexEntity(c);
+		}
+
+		else {
+			this._cbs.onerror(Error("unknown _state"), this._state);
+		}
+
+		this._index++;
+	}
+
+	this._cleanup();
+};
+
+Tokenizer.prototype.pause = function(){
+	this._running = false;
+};
+Tokenizer.prototype.resume = function(){
+	this._running = true;
+};
+
+Tokenizer.prototype.end = function(chunk){
+	if(chunk) this.write(chunk);
+
+	//if there is remaining data, emit it in a reasonable way
+	if(this._sectionStart < this._index){
+		this._handleTrailingData();
+	}
+
+	this._cbs.onend();
+};
+
+Tokenizer.prototype._handleTrailingData = function(){
+	var data = this._buffer.substr(this._sectionStart);
+
+	if(this._state === IN_CDATA || this._state === AFTER_CDATA_1 || this._state === AFTER_CDATA_2){
+		this._cbs.oncdata(data);
+	} else if(this._state === IN_COMMENT || this._state === AFTER_COMMENT_1 || this._state === AFTER_COMMENT_2){
+		this._cbs.oncomment(data);
+	} else if(this._state === IN_TAG_NAME){
+		this._cbs.onopentagname(data);
+	} else if(this._state === BEFORE_ATTRIBUTE_NAME || this._state === BEFORE_ATTRIBUTE_VALUE || this._state === AFTER_ATTRIBUTE_NAME){
+		this._cbs.onopentagend();
+	} else if(this._state === IN_ATTRIBUTE_NAME){
+		this._cbs.onattribname(data);
+	} else if(this._state === IN_ATTRIBUTE_VALUE_SQ || this._state === IN_ATTRIBUTE_VALUE_DQ || this._state === IN_ATTRIBUTE_VALUE_NQ){
+		this._cbs.onattribdata(data);
+		this._cbs.onattribend();
+	} else if(this._state === IN_CLOSING_TAG_NAME){
+		this._cbs.onclosetag(data);
+	} else if(this._state === IN_NAMED_ENTITY && !this._xmlMode){
+		this._parseLegacyEntity();
+		if(--this._sectionStart < this._index){
+			this._state = this._baseState;
+			this._handleTrailingData();
+		}
+	} else if(this._state === IN_NUMERIC_ENTITY && !this._xmlMode){
+		this._decodeNumericEntity(2, 10);
+		if(this._sectionStart < this._index){
+			this._state = this._baseState;
+			this._handleTrailingData();
+		}
+	} else if(this._state === IN_HEX_ENTITY && !this._xmlMode){
+		this._decodeNumericEntity(3, 16);
+		if(this._sectionStart < this._index){
+			this._state = this._baseState;
+			this._handleTrailingData();
+		}
+	} else {
+		this._cbs.ontext(data);
+	}
+};
+
+Tokenizer.prototype.reset = function(){
+	Tokenizer.call(this, {xmlMode: this._xmlMode, decodeEntities: this._decodeEntities}, this._cbs);
+};
+
+Tokenizer.prototype._getSection = function(){
+	return this._buffer.substring(this._sectionStart, this._index);
+};
+
+Tokenizer.prototype._emitToken = function(name){
+	this._cbs[name](this._getSection());
+	this._sectionStart = -1;
+};
+
+Tokenizer.prototype._emitPartial = function(value){
+	if(this._baseState !== TEXT){
+		this._cbs.onattribdata(value); //TODO implement the new event
+	} else {
+		this._cbs.ontext(value);
+	}
+};
diff --git a/node_modules/htmlparser2/lib/WritableStream.js b/node_modules/htmlparser2/lib/WritableStream.js
new file mode 100644
index 000000000..e65b0732b
--- /dev/null
+++ b/node_modules/htmlparser2/lib/WritableStream.js
@@ -0,0 +1,21 @@
+module.exports = Stream;
+
+var Parser = require("./Parser.js"),
+    WritableStream = require("stream").Writable || require("readable-stream").Writable;
+
+function Stream(cbs, options){
+	var parser = this._parser = new Parser(cbs, options);
+
+	WritableStream.call(this, {decodeStrings: false});
+
+	this.once("finish", function(){
+		parser.end();
+	});
+}
+
+require("util").inherits(Stream, WritableStream);
+
+WritableStream.prototype._write = function(chunk, encoding, cb){
+	this._parser.write(chunk);
+	cb();
+};
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/entities/decode.json b/node_modules/htmlparser2/lib/entities/decode.json
new file mode 100644
index 000000000..4ed2e8b04
--- /dev/null
+++ b/node_modules/htmlparser2/lib/entities/decode.json
@@ -0,0 +1 @@
+{"0":"\uFFFD","128":"\u20AC","130":"\u201A","131":"\u0192","132":"\u201E","133":"\u2026","134":"\u2020","135":"\u2021","136":"\u02C6","137":"\u2030","138":"\u0160","139":"\u2039","140":"\u0152","142":"\u017D","145":"\u2018","146":"\u2019","147":"\u201C","148":"\u201D","149":"\u2022","150":"\u2013","151":"\u2014","152":"\u02DC","153":"\u2122","154":"\u0161","155":"\u203A","156":"\u0153","158":"\u017E","159":"\u0178"}
diff --git a/node_modules/htmlparser2/lib/entities/entities.json b/node_modules/htmlparser2/lib/entities/entities.json
new file mode 100644
index 000000000..7ccfcd8bb
--- /dev/null
+++ b/node_modules/htmlparser2/lib/entities/entities.json
@@ -0,0 +1 @@
+{"Aacute":"\u00C1","aacute":"\u00E1","Abreve":"\u0102","abreve":"\u0103","ac":"\u223E","acd":"\u223F","acE":"\u223E\u0333","Acirc":"\u00C2","acirc":"\u00E2","acute":"\u00B4","Acy":"\u0410","acy":"\u0430","AElig":"\u00C6","aelig":"\u00E6","af":"\u2061","Afr":"\uD835\uDD04","afr":"\uD835\uDD1E","Agrave":"\u00C0","agrave":"\u00E0","alefsym":"\u2135","aleph":"\u2135","Alpha":"\u0391","alpha":"\u03B1","Amacr":"\u0100","amacr":"\u0101","amalg":"\u2A3F","amp":"&","AMP":"&","andand":"\u2A55","And":"\u2A53","and":"\u2227","andd":"\u2A5C","andslope":"\u2A58","andv":"\u2A5A","ang":"\u2220","ange":"\u29A4","angle":"\u2220","angmsdaa":"\u29A8","angmsdab":"\u29A9","angmsdac":"\u29AA","angmsdad":"\u29AB","angmsdae":"\u29AC","angmsdaf":"\u29AD","angmsdag":"\u29AE","angmsdah":"\u29AF","angmsd":"\u2221","angrt":"\u221F","angrtvb":"\u22BE","angrtvbd":"\u299D","angsph":"\u2222","angst":"\u00C5","angzarr":"\u237C","Aogon":"\u0104","aogon":"\u0105","Aopf":"\uD835\uDD38","aopf":"\uD835\uDD52","apacir":"\u2A6F","ap":"\u2248","apE":"\u2A70","ape":"\u224A","apid":"\u224B","apos":"'","ApplyFunction":"\u2061","approx":"\u2248","approxeq":"\u224A","Aring":"\u00C5","aring":"\u00E5","Ascr":"\uD835\uDC9C","ascr":"\uD835\uDCB6","Assign":"\u2254","ast":"*","asymp":"\u2248","asympeq":"\u224D","Atilde":"\u00C3","atilde":"\u00E3","Auml":"\u00C4","auml":"\u00E4","awconint":"\u2233","awint":"\u2A11","backcong":"\u224C","backepsilon":"\u03F6","backprime":"\u2035","backsim":"\u223D","backsimeq":"\u22CD","Backslash":"\u2216","Barv":"\u2AE7","barvee":"\u22BD","barwed":"\u2305","Barwed":"\u2306","barwedge":"\u2305","bbrk":"\u23B5","bbrktbrk":"\u23B6","bcong":"\u224C","Bcy":"\u0411","bcy":"\u0431","bdquo":"\u201E","becaus":"\u2235","because":"\u2235","Because":"\u2235","bemptyv":"\u29B0","bepsi":"\u03F6","bernou":"\u212C","Bernoullis":"\u212C","Beta":"\u0392","beta":"\u03B2","beth":"\u2136","between":"\u226C","Bfr":"\uD835\uDD05","bfr":"\uD835\uDD1F","bigcap":"\u22C2","bigcirc":"\u25EF","bigcup":"\u22C3","bigodot":"\u2A00","bigoplus":"\u2A01","bigotimes":"\u2A02","bigsqcup":"\u2A06","bigstar":"\u2605","bigtriangledown":"\u25BD","bigtriangleup":"\u25B3","biguplus":"\u2A04","bigvee":"\u22C1","bigwedge":"\u22C0","bkarow":"\u290D","blacklozenge":"\u29EB","blacksquare":"\u25AA","blacktriangle":"\u25B4","blacktriangledown":"\u25BE","blacktriangleleft":"\u25C2","blacktriangleright":"\u25B8","blank":"\u2423","blk12":"\u2592","blk14":"\u2591","blk34":"\u2593","block":"\u2588","bne":"=\u20E5","bnequiv":"\u2261\u20E5","bNot":"\u2AED","bnot":"\u2310","Bopf":"\uD835\uDD39","bopf":"\uD835\uDD53","bot":"\u22A5","bottom":"\u22A5","bowtie":"\u22C8","boxbox":"\u29C9","boxdl":"\u2510","boxdL":"\u2555","boxDl":"\u2556","boxDL":"\u2557","boxdr":"\u250C","boxdR":"\u2552","boxDr":"\u2553","boxDR":"\u2554","boxh":"\u2500","boxH":"\u2550","boxhd":"\u252C","boxHd":"\u2564","boxhD":"\u2565","boxHD":"\u2566","boxhu":"\u2534","boxHu":"\u2567","boxhU":"\u2568","boxHU":"\u2569","boxminus":"\u229F","boxplus":"\u229E","boxtimes":"\u22A0","boxul":"\u2518","boxuL":"\u255B","boxUl":"\u255C","boxUL":"\u255D","boxur":"\u2514","boxuR":"\u2558","boxUr":"\u2559","boxUR":"\u255A","boxv":"\u2502","boxV":"\u2551","boxvh":"\u253C","boxvH":"\u256A","boxVh":"\u256B","boxVH":"\u256C","boxvl":"\u2524","boxvL":"\u2561","boxVl":"\u2562","boxVL":"\u2563","boxvr":"\u251C","boxvR":"\u255E","boxVr":"\u255F","boxVR":"\u2560","bprime":"\u2035","breve":"\u02D8","Breve":"\u02D8","brvbar":"\u00A6","bscr":"\uD835\uDCB7","Bscr":"\u212C","bsemi":"\u204F","bsim":"\u223D","bsime":"\u22CD","bsolb":"\u29C5","bsol":"\\","bsolhsub":"\u27C8","bull":"\u2022","bullet":"\u2022","bump":"\u224E","bumpE":"\u2AAE","bumpe":"\u224F","Bumpeq":"\u224E","bumpeq":"\u224F","Cacute":"\u0106","cacute":"\u0107","capand":"\u2A44","capbrcup":"\u2A49","capcap":"\u2A4B","cap":"\u2229","Cap":"\u22D2","capcup":"\u2A47","capdot":"\u2A40","CapitalDifferentialD":"\u2145","caps":"\u2229\uFE00","caret":"\u2041","caron":"\u02C7","Cayleys":"\u212D","ccaps":"\u2A4D","Ccaron":"\u010C","ccaron":"\u010D","Ccedil":"\u00C7","ccedil":"\u00E7","Ccirc":"\u0108","ccirc":"\u0109","Cconint":"\u2230","ccups":"\u2A4C","ccupssm":"\u2A50","Cdot":"\u010A","cdot":"\u010B","cedil":"\u00B8","Cedilla":"\u00B8","cemptyv":"\u29B2","cent":"\u00A2","centerdot":"\u00B7","CenterDot":"\u00B7","cfr":"\uD835\uDD20","Cfr":"\u212D","CHcy":"\u0427","chcy":"\u0447","check":"\u2713","checkmark":"\u2713","Chi":"\u03A7","chi":"\u03C7","circ":"\u02C6","circeq":"\u2257","circlearrowleft":"\u21BA","circlearrowright":"\u21BB","circledast":"\u229B","circledcirc":"\u229A","circleddash":"\u229D","CircleDot":"\u2299","circledR":"\u00AE","circledS":"\u24C8","CircleMinus":"\u2296","CirclePlus":"\u2295","CircleTimes":"\u2297","cir":"\u25CB","cirE":"\u29C3","cire":"\u2257","cirfnint":"\u2A10","cirmid":"\u2AEF","cirscir":"\u29C2","ClockwiseContourIntegral":"\u2232","CloseCurlyDoubleQuote":"\u201D","CloseCurlyQuote":"\u2019","clubs":"\u2663","clubsuit":"\u2663","colon":":","Colon":"\u2237","Colone":"\u2A74","colone":"\u2254","coloneq":"\u2254","comma":",","commat":"@","comp":"\u2201","compfn":"\u2218","complement":"\u2201","complexes":"\u2102","cong":"\u2245","congdot":"\u2A6D","Congruent":"\u2261","conint":"\u222E","Conint":"\u222F","ContourIntegral":"\u222E","copf":"\uD835\uDD54","Copf":"\u2102","coprod":"\u2210","Coproduct":"\u2210","copy":"\u00A9","COPY":"\u00A9","copysr":"\u2117","CounterClockwiseContourIntegral":"\u2233","crarr":"\u21B5","cross":"\u2717","Cross":"\u2A2F","Cscr":"\uD835\uDC9E","cscr":"\uD835\uDCB8","csub":"\u2ACF","csube":"\u2AD1","csup":"\u2AD0","csupe":"\u2AD2","ctdot":"\u22EF","cudarrl":"\u2938","cudarrr":"\u2935","cuepr":"\u22DE","cuesc":"\u22DF","cularr":"\u21B6","cularrp":"\u293D","cupbrcap":"\u2A48","cupcap":"\u2A46","CupCap":"\u224D","cup":"\u222A","Cup":"\u22D3","cupcup":"\u2A4A","cupdot":"\u228D","cupor":"\u2A45","cups":"\u222A\uFE00","curarr":"\u21B7","curarrm":"\u293C","curlyeqprec":"\u22DE","curlyeqsucc":"\u22DF","curlyvee":"\u22CE","curlywedge":"\u22CF","curren":"\u00A4","curvearrowleft":"\u21B6","curvearrowright":"\u21B7","cuvee":"\u22CE","cuwed":"\u22CF","cwconint":"\u2232","cwint":"\u2231","cylcty":"\u232D","dagger":"\u2020","Dagger":"\u2021","daleth":"\u2138","darr":"\u2193","Darr":"\u21A1","dArr":"\u21D3","dash":"\u2010","Dashv":"\u2AE4","dashv":"\u22A3","dbkarow":"\u290F","dblac":"\u02DD","Dcaron":"\u010E","dcaron":"\u010F","Dcy":"\u0414","dcy":"\u0434","ddagger":"\u2021","ddarr":"\u21CA","DD":"\u2145","dd":"\u2146","DDotrahd":"\u2911","ddotseq":"\u2A77","deg":"\u00B0","Del":"\u2207","Delta":"\u0394","delta":"\u03B4","demptyv":"\u29B1","dfisht":"\u297F","Dfr":"\uD835\uDD07","dfr":"\uD835\uDD21","dHar":"\u2965","dharl":"\u21C3","dharr":"\u21C2","DiacriticalAcute":"\u00B4","DiacriticalDot":"\u02D9","DiacriticalDoubleAcute":"\u02DD","DiacriticalGrave":"`","DiacriticalTilde":"\u02DC","diam":"\u22C4","diamond":"\u22C4","Diamond":"\u22C4","diamondsuit":"\u2666","diams":"\u2666","die":"\u00A8","DifferentialD":"\u2146","digamma":"\u03DD","disin":"\u22F2","div":"\u00F7","divide":"\u00F7","divideontimes":"\u22C7","divonx":"\u22C7","DJcy":"\u0402","djcy":"\u0452","dlcorn":"\u231E","dlcrop":"\u230D","dollar":"$","Dopf":"\uD835\uDD3B","dopf":"\uD835\uDD55","Dot":"\u00A8","dot":"\u02D9","DotDot":"\u20DC","doteq":"\u2250","doteqdot":"\u2251","DotEqual":"\u2250","dotminus":"\u2238","dotplus":"\u2214","dotsquare":"\u22A1","doublebarwedge":"\u2306","DoubleContourIntegral":"\u222F","DoubleDot":"\u00A8","DoubleDownArrow":"\u21D3","DoubleLeftArrow":"\u21D0","DoubleLeftRightArrow":"\u21D4","DoubleLeftTee":"\u2AE4","DoubleLongLeftArrow":"\u27F8","DoubleLongLeftRightArrow":"\u27FA","DoubleLongRightArrow":"\u27F9","DoubleRightArrow":"\u21D2","DoubleRightTee":"\u22A8","DoubleUpArrow":"\u21D1","DoubleUpDownArrow":"\u21D5","DoubleVerticalBar":"\u2225","DownArrowBar":"\u2913","downarrow":"\u2193","DownArrow":"\u2193","Downarrow":"\u21D3","DownArrowUpArrow":"\u21F5","DownBreve":"\u0311","downdownarrows":"\u21CA","downharpoonleft":"\u21C3","downharpoonright":"\u21C2","DownLeftRightVector":"\u2950","DownLeftTeeVector":"\u295E","DownLeftVectorBar":"\u2956","DownLeftVector":"\u21BD","DownRightTeeVector":"\u295F","DownRightVectorBar":"\u2957","DownRightVector":"\u21C1","DownTeeArrow":"\u21A7","DownTee":"\u22A4","drbkarow":"\u2910","drcorn":"\u231F","drcrop":"\u230C","Dscr":"\uD835\uDC9F","dscr":"\uD835\uDCB9","DScy":"\u0405","dscy":"\u0455","dsol":"\u29F6","Dstrok":"\u0110","dstrok":"\u0111","dtdot":"\u22F1","dtri":"\u25BF","dtrif":"\u25BE","duarr":"\u21F5","duhar":"\u296F","dwangle":"\u29A6","DZcy":"\u040F","dzcy":"\u045F","dzigrarr":"\u27FF","Eacute":"\u00C9","eacute":"\u00E9","easter":"\u2A6E","Ecaron":"\u011A","ecaron":"\u011B","Ecirc":"\u00CA","ecirc":"\u00EA","ecir":"\u2256","ecolon":"\u2255","Ecy":"\u042D","ecy":"\u044D","eDDot":"\u2A77","Edot":"\u0116","edot":"\u0117","eDot":"\u2251","ee":"\u2147","efDot":"\u2252","Efr":"\uD835\uDD08","efr":"\uD835\uDD22","eg":"\u2A9A","Egrave":"\u00C8","egrave":"\u00E8","egs":"\u2A96","egsdot":"\u2A98","el":"\u2A99","Element":"\u2208","elinters":"\u23E7","ell":"\u2113","els":"\u2A95","elsdot":"\u2A97","Emacr":"\u0112","emacr":"\u0113","empty":"\u2205","emptyset":"\u2205","EmptySmallSquare":"\u25FB","emptyv":"\u2205","EmptyVerySmallSquare":"\u25AB","emsp13":"\u2004","emsp14":"\u2005","emsp":"\u2003","ENG":"\u014A","eng":"\u014B","ensp":"\u2002","Eogon":"\u0118","eogon":"\u0119","Eopf":"\uD835\uDD3C","eopf":"\uD835\uDD56","epar":"\u22D5","eparsl":"\u29E3","eplus":"\u2A71","epsi":"\u03B5","Epsilon":"\u0395","epsilon":"\u03B5","epsiv":"\u03F5","eqcirc":"\u2256","eqcolon":"\u2255","eqsim":"\u2242","eqslantgtr":"\u2A96","eqslantless":"\u2A95","Equal":"\u2A75","equals":"=","EqualTilde":"\u2242","equest":"\u225F","Equilibrium":"\u21CC","equiv":"\u2261","equivDD":"\u2A78","eqvparsl":"\u29E5","erarr":"\u2971","erDot":"\u2253","escr":"\u212F","Escr":"\u2130","esdot":"\u2250","Esim":"\u2A73","esim":"\u2242","Eta":"\u0397","eta":"\u03B7","ETH":"\u00D0","eth":"\u00F0","Euml":"\u00CB","euml":"\u00EB","euro":"\u20AC","excl":"!","exist":"\u2203","Exists":"\u2203","expectation":"\u2130","exponentiale":"\u2147","ExponentialE":"\u2147","fallingdotseq":"\u2252","Fcy":"\u0424","fcy":"\u0444","female":"\u2640","ffilig":"\uFB03","fflig":"\uFB00","ffllig":"\uFB04","Ffr":"\uD835\uDD09","ffr":"\uD835\uDD23","filig":"\uFB01","FilledSmallSquare":"\u25FC","FilledVerySmallSquare":"\u25AA","fjlig":"fj","flat":"\u266D","fllig":"\uFB02","fltns":"\u25B1","fnof":"\u0192","Fopf":"\uD835\uDD3D","fopf":"\uD835\uDD57","forall":"\u2200","ForAll":"\u2200","fork":"\u22D4","forkv":"\u2AD9","Fouriertrf":"\u2131","fpartint":"\u2A0D","frac12":"\u00BD","frac13":"\u2153","frac14":"\u00BC","frac15":"\u2155","frac16":"\u2159","frac18":"\u215B","frac23":"\u2154","frac25":"\u2156","frac34":"\u00BE","frac35":"\u2157","frac38":"\u215C","frac45":"\u2158","frac56":"\u215A","frac58":"\u215D","frac78":"\u215E","frasl":"\u2044","frown":"\u2322","fscr":"\uD835\uDCBB","Fscr":"\u2131","gacute":"\u01F5","Gamma":"\u0393","gamma":"\u03B3","Gammad":"\u03DC","gammad":"\u03DD","gap":"\u2A86","Gbreve":"\u011E","gbreve":"\u011F","Gcedil":"\u0122","Gcirc":"\u011C","gcirc":"\u011D","Gcy":"\u0413","gcy":"\u0433","Gdot":"\u0120","gdot":"\u0121","ge":"\u2265","gE":"\u2267","gEl":"\u2A8C","gel":"\u22DB","geq":"\u2265","geqq":"\u2267","geqslant":"\u2A7E","gescc":"\u2AA9","ges":"\u2A7E","gesdot":"\u2A80","gesdoto":"\u2A82","gesdotol":"\u2A84","gesl":"\u22DB\uFE00","gesles":"\u2A94","Gfr":"\uD835\uDD0A","gfr":"\uD835\uDD24","gg":"\u226B","Gg":"\u22D9","ggg":"\u22D9","gimel":"\u2137","GJcy":"\u0403","gjcy":"\u0453","gla":"\u2AA5","gl":"\u2277","glE":"\u2A92","glj":"\u2AA4","gnap":"\u2A8A","gnapprox":"\u2A8A","gne":"\u2A88","gnE":"\u2269","gneq":"\u2A88","gneqq":"\u2269","gnsim":"\u22E7","Gopf":"\uD835\uDD3E","gopf":"\uD835\uDD58","grave":"`","GreaterEqual":"\u2265","GreaterEqualLess":"\u22DB","GreaterFullEqual":"\u2267","GreaterGreater":"\u2AA2","GreaterLess":"\u2277","GreaterSlantEqual":"\u2A7E","GreaterTilde":"\u2273","Gscr":"\uD835\uDCA2","gscr":"\u210A","gsim":"\u2273","gsime":"\u2A8E","gsiml":"\u2A90","gtcc":"\u2AA7","gtcir":"\u2A7A","gt":">","GT":">","Gt":"\u226B","gtdot":"\u22D7","gtlPar":"\u2995","gtquest":"\u2A7C","gtrapprox":"\u2A86","gtrarr":"\u2978","gtrdot":"\u22D7","gtreqless":"\u22DB","gtreqqless":"\u2A8C","gtrless":"\u2277","gtrsim":"\u2273","gvertneqq":"\u2269\uFE00","gvnE":"\u2269\uFE00","Hacek":"\u02C7","hairsp":"\u200A","half":"\u00BD","hamilt":"\u210B","HARDcy":"\u042A","hardcy":"\u044A","harrcir":"\u2948","harr":"\u2194","hArr":"\u21D4","harrw":"\u21AD","Hat":"^","hbar":"\u210F","Hcirc":"\u0124","hcirc":"\u0125","hearts":"\u2665","heartsuit":"\u2665","hellip":"\u2026","hercon":"\u22B9","hfr":"\uD835\uDD25","Hfr":"\u210C","HilbertSpace":"\u210B","hksearow":"\u2925","hkswarow":"\u2926","hoarr":"\u21FF","homtht":"\u223B","hookleftarrow":"\u21A9","hookrightarrow":"\u21AA","hopf":"\uD835\uDD59","Hopf":"\u210D","horbar":"\u2015","HorizontalLine":"\u2500","hscr":"\uD835\uDCBD","Hscr":"\u210B","hslash":"\u210F","Hstrok":"\u0126","hstrok":"\u0127","HumpDownHump":"\u224E","HumpEqual":"\u224F","hybull":"\u2043","hyphen":"\u2010","Iacute":"\u00CD","iacute":"\u00ED","ic":"\u2063","Icirc":"\u00CE","icirc":"\u00EE","Icy":"\u0418","icy":"\u0438","Idot":"\u0130","IEcy":"\u0415","iecy":"\u0435","iexcl":"\u00A1","iff":"\u21D4","ifr":"\uD835\uDD26","Ifr":"\u2111","Igrave":"\u00CC","igrave":"\u00EC","ii":"\u2148","iiiint":"\u2A0C","iiint":"\u222D","iinfin":"\u29DC","iiota":"\u2129","IJlig":"\u0132","ijlig":"\u0133","Imacr":"\u012A","imacr":"\u012B","image":"\u2111","ImaginaryI":"\u2148","imagline":"\u2110","imagpart":"\u2111","imath":"\u0131","Im":"\u2111","imof":"\u22B7","imped":"\u01B5","Implies":"\u21D2","incare":"\u2105","in":"\u2208","infin":"\u221E","infintie":"\u29DD","inodot":"\u0131","intcal":"\u22BA","int":"\u222B","Int":"\u222C","integers":"\u2124","Integral":"\u222B","intercal":"\u22BA","Intersection":"\u22C2","intlarhk":"\u2A17","intprod":"\u2A3C","InvisibleComma":"\u2063","InvisibleTimes":"\u2062","IOcy":"\u0401","iocy":"\u0451","Iogon":"\u012E","iogon":"\u012F","Iopf":"\uD835\uDD40","iopf":"\uD835\uDD5A","Iota":"\u0399","iota":"\u03B9","iprod":"\u2A3C","iquest":"\u00BF","iscr":"\uD835\uDCBE","Iscr":"\u2110","isin":"\u2208","isindot":"\u22F5","isinE":"\u22F9","isins":"\u22F4","isinsv":"\u22F3","isinv":"\u2208","it":"\u2062","Itilde":"\u0128","itilde":"\u0129","Iukcy":"\u0406","iukcy":"\u0456","Iuml":"\u00CF","iuml":"\u00EF","Jcirc":"\u0134","jcirc":"\u0135","Jcy":"\u0419","jcy":"\u0439","Jfr":"\uD835\uDD0D","jfr":"\uD835\uDD27","jmath":"\u0237","Jopf":"\uD835\uDD41","jopf":"\uD835\uDD5B","Jscr":"\uD835\uDCA5","jscr":"\uD835\uDCBF","Jsercy":"\u0408","jsercy":"\u0458","Jukcy":"\u0404","jukcy":"\u0454","Kappa":"\u039A","kappa":"\u03BA","kappav":"\u03F0","Kcedil":"\u0136","kcedil":"\u0137","Kcy":"\u041A","kcy":"\u043A","Kfr":"\uD835\uDD0E","kfr":"\uD835\uDD28","kgreen":"\u0138","KHcy":"\u0425","khcy":"\u0445","KJcy":"\u040C","kjcy":"\u045C","Kopf":"\uD835\uDD42","kopf":"\uD835\uDD5C","Kscr":"\uD835\uDCA6","kscr":"\uD835\uDCC0","lAarr":"\u21DA","Lacute":"\u0139","lacute":"\u013A","laemptyv":"\u29B4","lagran":"\u2112","Lambda":"\u039B","lambda":"\u03BB","lang":"\u27E8","Lang":"\u27EA","langd":"\u2991","langle":"\u27E8","lap":"\u2A85","Laplacetrf":"\u2112","laquo":"\u00AB","larrb":"\u21E4","larrbfs":"\u291F","larr":"\u2190","Larr":"\u219E","lArr":"\u21D0","larrfs":"\u291D","larrhk":"\u21A9","larrlp":"\u21AB","larrpl":"\u2939","larrsim":"\u2973","larrtl":"\u21A2","latail":"\u2919","lAtail":"\u291B","lat":"\u2AAB","late":"\u2AAD","lates":"\u2AAD\uFE00","lbarr":"\u290C","lBarr":"\u290E","lbbrk":"\u2772","lbrace":"{","lbrack":"[","lbrke":"\u298B","lbrksld":"\u298F","lbrkslu":"\u298D","Lcaron":"\u013D","lcaron":"\u013E","Lcedil":"\u013B","lcedil":"\u013C","lceil":"\u2308","lcub":"{","Lcy":"\u041B","lcy":"\u043B","ldca":"\u2936","ldquo":"\u201C","ldquor":"\u201E","ldrdhar":"\u2967","ldrushar":"\u294B","ldsh":"\u21B2","le":"\u2264","lE":"\u2266","LeftAngleBracket":"\u27E8","LeftArrowBar":"\u21E4","leftarrow":"\u2190","LeftArrow":"\u2190","Leftarrow":"\u21D0","LeftArrowRightArrow":"\u21C6","leftarrowtail":"\u21A2","LeftCeiling":"\u2308","LeftDoubleBracket":"\u27E6","LeftDownTeeVector":"\u2961","LeftDownVectorBar":"\u2959","LeftDownVector":"\u21C3","LeftFloor":"\u230A","leftharpoondown":"\u21BD","leftharpoonup":"\u21BC","leftleftarrows":"\u21C7","leftrightarrow":"\u2194","LeftRightArrow":"\u2194","Leftrightarrow":"\u21D4","leftrightarrows":"\u21C6","leftrightharpoons":"\u21CB","leftrightsquigarrow":"\u21AD","LeftRightVector":"\u294E","LeftTeeArrow":"\u21A4","LeftTee":"\u22A3","LeftTeeVector":"\u295A","leftthreetimes":"\u22CB","LeftTriangleBar":"\u29CF","LeftTriangle":"\u22B2","LeftTriangleEqual":"\u22B4","LeftUpDownVector":"\u2951","LeftUpTeeVector":"\u2960","LeftUpVectorBar":"\u2958","LeftUpVector":"\u21BF","LeftVectorBar":"\u2952","LeftVector":"\u21BC","lEg":"\u2A8B","leg":"\u22DA","leq":"\u2264","leqq":"\u2266","leqslant":"\u2A7D","lescc":"\u2AA8","les":"\u2A7D","lesdot":"\u2A7F","lesdoto":"\u2A81","lesdotor":"\u2A83","lesg":"\u22DA\uFE00","lesges":"\u2A93","lessapprox":"\u2A85","lessdot":"\u22D6","lesseqgtr":"\u22DA","lesseqqgtr":"\u2A8B","LessEqualGreater":"\u22DA","LessFullEqual":"\u2266","LessGreater":"\u2276","lessgtr":"\u2276","LessLess":"\u2AA1","lesssim":"\u2272","LessSlantEqual":"\u2A7D","LessTilde":"\u2272","lfisht":"\u297C","lfloor":"\u230A","Lfr":"\uD835\uDD0F","lfr":"\uD835\uDD29","lg":"\u2276","lgE":"\u2A91","lHar":"\u2962","lhard":"\u21BD","lharu":"\u21BC","lharul":"\u296A","lhblk":"\u2584","LJcy":"\u0409","ljcy":"\u0459","llarr":"\u21C7","ll":"\u226A","Ll":"\u22D8","llcorner":"\u231E","Lleftarrow":"\u21DA","llhard":"\u296B","lltri":"\u25FA","Lmidot":"\u013F","lmidot":"\u0140","lmoustache":"\u23B0","lmoust":"\u23B0","lnap":"\u2A89","lnapprox":"\u2A89","lne":"\u2A87","lnE":"\u2268","lneq":"\u2A87","lneqq":"\u2268","lnsim":"\u22E6","loang":"\u27EC","loarr":"\u21FD","lobrk":"\u27E6","longleftarrow":"\u27F5","LongLeftArrow":"\u27F5","Longleftarrow":"\u27F8","longleftrightarrow":"\u27F7","LongLeftRightArrow":"\u27F7","Longleftrightarrow":"\u27FA","longmapsto":"\u27FC","longrightarrow":"\u27F6","LongRightArrow":"\u27F6","Longrightarrow":"\u27F9","looparrowleft":"\u21AB","looparrowright":"\u21AC","lopar":"\u2985","Lopf":"\uD835\uDD43","lopf":"\uD835\uDD5D","loplus":"\u2A2D","lotimes":"\u2A34","lowast":"\u2217","lowbar":"_","LowerLeftArrow":"\u2199","LowerRightArrow":"\u2198","loz":"\u25CA","lozenge":"\u25CA","lozf":"\u29EB","lpar":"(","lparlt":"\u2993","lrarr":"\u21C6","lrcorner":"\u231F","lrhar":"\u21CB","lrhard":"\u296D","lrm":"\u200E","lrtri":"\u22BF","lsaquo":"\u2039","lscr":"\uD835\uDCC1","Lscr":"\u2112","lsh":"\u21B0","Lsh":"\u21B0","lsim":"\u2272","lsime":"\u2A8D","lsimg":"\u2A8F","lsqb":"[","lsquo":"\u2018","lsquor":"\u201A","Lstrok":"\u0141","lstrok":"\u0142","ltcc":"\u2AA6","ltcir":"\u2A79","lt":"<","LT":"<","Lt":"\u226A","ltdot":"\u22D6","lthree":"\u22CB","ltimes":"\u22C9","ltlarr":"\u2976","ltquest":"\u2A7B","ltri":"\u25C3","ltrie":"\u22B4","ltrif":"\u25C2","ltrPar":"\u2996","lurdshar":"\u294A","luruhar":"\u2966","lvertneqq":"\u2268\uFE00","lvnE":"\u2268\uFE00","macr":"\u00AF","male":"\u2642","malt":"\u2720","maltese":"\u2720","Map":"\u2905","map":"\u21A6","mapsto":"\u21A6","mapstodown":"\u21A7","mapstoleft":"\u21A4","mapstoup":"\u21A5","marker":"\u25AE","mcomma":"\u2A29","Mcy":"\u041C","mcy":"\u043C","mdash":"\u2014","mDDot":"\u223A","measuredangle":"\u2221","MediumSpace":"\u205F","Mellintrf":"\u2133","Mfr":"\uD835\uDD10","mfr":"\uD835\uDD2A","mho":"\u2127","micro":"\u00B5","midast":"*","midcir":"\u2AF0","mid":"\u2223","middot":"\u00B7","minusb":"\u229F","minus":"\u2212","minusd":"\u2238","minusdu":"\u2A2A","MinusPlus":"\u2213","mlcp":"\u2ADB","mldr":"\u2026","mnplus":"\u2213","models":"\u22A7","Mopf":"\uD835\uDD44","mopf":"\uD835\uDD5E","mp":"\u2213","mscr":"\uD835\uDCC2","Mscr":"\u2133","mstpos":"\u223E","Mu":"\u039C","mu":"\u03BC","multimap":"\u22B8","mumap":"\u22B8","nabla":"\u2207","Nacute":"\u0143","nacute":"\u0144","nang":"\u2220\u20D2","nap":"\u2249","napE":"\u2A70\u0338","napid":"\u224B\u0338","napos":"\u0149","napprox":"\u2249","natural":"\u266E","naturals":"\u2115","natur":"\u266E","nbsp":"\u00A0","nbump":"\u224E\u0338","nbumpe":"\u224F\u0338","ncap":"\u2A43","Ncaron":"\u0147","ncaron":"\u0148","Ncedil":"\u0145","ncedil":"\u0146","ncong":"\u2247","ncongdot":"\u2A6D\u0338","ncup":"\u2A42","Ncy":"\u041D","ncy":"\u043D","ndash":"\u2013","nearhk":"\u2924","nearr":"\u2197","neArr":"\u21D7","nearrow":"\u2197","ne":"\u2260","nedot":"\u2250\u0338","NegativeMediumSpace":"\u200B","NegativeThickSpace":"\u200B","NegativeThinSpace":"\u200B","NegativeVeryThinSpace":"\u200B","nequiv":"\u2262","nesear":"\u2928","nesim":"\u2242\u0338","NestedGreaterGreater":"\u226B","NestedLessLess":"\u226A","NewLine":"\n","nexist":"\u2204","nexists":"\u2204","Nfr":"\uD835\uDD11","nfr":"\uD835\uDD2B","ngE":"\u2267\u0338","nge":"\u2271","ngeq":"\u2271","ngeqq":"\u2267\u0338","ngeqslant":"\u2A7E\u0338","nges":"\u2A7E\u0338","nGg":"\u22D9\u0338","ngsim":"\u2275","nGt":"\u226B\u20D2","ngt":"\u226F","ngtr":"\u226F","nGtv":"\u226B\u0338","nharr":"\u21AE","nhArr":"\u21CE","nhpar":"\u2AF2","ni":"\u220B","nis":"\u22FC","nisd":"\u22FA","niv":"\u220B","NJcy":"\u040A","njcy":"\u045A","nlarr":"\u219A","nlArr":"\u21CD","nldr":"\u2025","nlE":"\u2266\u0338","nle":"\u2270","nleftarrow":"\u219A","nLeftarrow":"\u21CD","nleftrightarrow":"\u21AE","nLeftrightarrow":"\u21CE","nleq":"\u2270","nleqq":"\u2266\u0338","nleqslant":"\u2A7D\u0338","nles":"\u2A7D\u0338","nless":"\u226E","nLl":"\u22D8\u0338","nlsim":"\u2274","nLt":"\u226A\u20D2","nlt":"\u226E","nltri":"\u22EA","nltrie":"\u22EC","nLtv":"\u226A\u0338","nmid":"\u2224","NoBreak":"\u2060","NonBreakingSpace":"\u00A0","nopf":"\uD835\uDD5F","Nopf":"\u2115","Not":"\u2AEC","not":"\u00AC","NotCongruent":"\u2262","NotCupCap":"\u226D","NotDoubleVerticalBar":"\u2226","NotElement":"\u2209","NotEqual":"\u2260","NotEqualTilde":"\u2242\u0338","NotExists":"\u2204","NotGreater":"\u226F","NotGreaterEqual":"\u2271","NotGreaterFullEqual":"\u2267\u0338","NotGreaterGreater":"\u226B\u0338","NotGreaterLess":"\u2279","NotGreaterSlantEqual":"\u2A7E\u0338","NotGreaterTilde":"\u2275","NotHumpDownHump":"\u224E\u0338","NotHumpEqual":"\u224F\u0338","notin":"\u2209","notindot":"\u22F5\u0338","notinE":"\u22F9\u0338","notinva":"\u2209","notinvb":"\u22F7","notinvc":"\u22F6","NotLeftTriangleBar":"\u29CF\u0338","NotLeftTriangle":"\u22EA","NotLeftTriangleEqual":"\u22EC","NotLess":"\u226E","NotLessEqual":"\u2270","NotLessGreater":"\u2278","NotLessLess":"\u226A\u0338","NotLessSlantEqual":"\u2A7D\u0338","NotLessTilde":"\u2274","NotNestedGreaterGreater":"\u2AA2\u0338","NotNestedLessLess":"\u2AA1\u0338","notni":"\u220C","notniva":"\u220C","notnivb":"\u22FE","notnivc":"\u22FD","NotPrecedes":"\u2280","NotPrecedesEqual":"\u2AAF\u0338","NotPrecedesSlantEqual":"\u22E0","NotReverseElement":"\u220C","NotRightTriangleBar":"\u29D0\u0338","NotRightTriangle":"\u22EB","NotRightTriangleEqual":"\u22ED","NotSquareSubset":"\u228F\u0338","NotSquareSubsetEqual":"\u22E2","NotSquareSuperset":"\u2290\u0338","NotSquareSupersetEqual":"\u22E3","NotSubset":"\u2282\u20D2","NotSubsetEqual":"\u2288","NotSucceeds":"\u2281","NotSucceedsEqual":"\u2AB0\u0338","NotSucceedsSlantEqual":"\u22E1","NotSucceedsTilde":"\u227F\u0338","NotSuperset":"\u2283\u20D2","NotSupersetEqual":"\u2289","NotTilde":"\u2241","NotTildeEqual":"\u2244","NotTildeFullEqual":"\u2247","NotTildeTilde":"\u2249","NotVerticalBar":"\u2224","nparallel":"\u2226","npar":"\u2226","nparsl":"\u2AFD\u20E5","npart":"\u2202\u0338","npolint":"\u2A14","npr":"\u2280","nprcue":"\u22E0","nprec":"\u2280","npreceq":"\u2AAF\u0338","npre":"\u2AAF\u0338","nrarrc":"\u2933\u0338","nrarr":"\u219B","nrArr":"\u21CF","nrarrw":"\u219D\u0338","nrightarrow":"\u219B","nRightarrow":"\u21CF","nrtri":"\u22EB","nrtrie":"\u22ED","nsc":"\u2281","nsccue":"\u22E1","nsce":"\u2AB0\u0338","Nscr":"\uD835\uDCA9","nscr":"\uD835\uDCC3","nshortmid":"\u2224","nshortparallel":"\u2226","nsim":"\u2241","nsime":"\u2244","nsimeq":"\u2244","nsmid":"\u2224","nspar":"\u2226","nsqsube":"\u22E2","nsqsupe":"\u22E3","nsub":"\u2284","nsubE":"\u2AC5\u0338","nsube":"\u2288","nsubset":"\u2282\u20D2","nsubseteq":"\u2288","nsubseteqq":"\u2AC5\u0338","nsucc":"\u2281","nsucceq":"\u2AB0\u0338","nsup":"\u2285","nsupE":"\u2AC6\u0338","nsupe":"\u2289","nsupset":"\u2283\u20D2","nsupseteq":"\u2289","nsupseteqq":"\u2AC6\u0338","ntgl":"\u2279","Ntilde":"\u00D1","ntilde":"\u00F1","ntlg":"\u2278","ntriangleleft":"\u22EA","ntrianglelefteq":"\u22EC","ntriangleright":"\u22EB","ntrianglerighteq":"\u22ED","Nu":"\u039D","nu":"\u03BD","num":"#","numero":"\u2116","numsp":"\u2007","nvap":"\u224D\u20D2","nvdash":"\u22AC","nvDash":"\u22AD","nVdash":"\u22AE","nVDash":"\u22AF","nvge":"\u2265\u20D2","nvgt":">\u20D2","nvHarr":"\u2904","nvinfin":"\u29DE","nvlArr":"\u2902","nvle":"\u2264\u20D2","nvlt":"<\u20D2","nvltrie":"\u22B4\u20D2","nvrArr":"\u2903","nvrtrie":"\u22B5\u20D2","nvsim":"\u223C\u20D2","nwarhk":"\u2923","nwarr":"\u2196","nwArr":"\u21D6","nwarrow":"\u2196","nwnear":"\u2927","Oacute":"\u00D3","oacute":"\u00F3","oast":"\u229B","Ocirc":"\u00D4","ocirc":"\u00F4","ocir":"\u229A","Ocy":"\u041E","ocy":"\u043E","odash":"\u229D","Odblac":"\u0150","odblac":"\u0151","odiv":"\u2A38","odot":"\u2299","odsold":"\u29BC","OElig":"\u0152","oelig":"\u0153","ofcir":"\u29BF","Ofr":"\uD835\uDD12","ofr":"\uD835\uDD2C","ogon":"\u02DB","Ograve":"\u00D2","ograve":"\u00F2","ogt":"\u29C1","ohbar":"\u29B5","ohm":"\u03A9","oint":"\u222E","olarr":"\u21BA","olcir":"\u29BE","olcross":"\u29BB","oline":"\u203E","olt":"\u29C0","Omacr":"\u014C","omacr":"\u014D","Omega":"\u03A9","omega":"\u03C9","Omicron":"\u039F","omicron":"\u03BF","omid":"\u29B6","ominus":"\u2296","Oopf":"\uD835\uDD46","oopf":"\uD835\uDD60","opar":"\u29B7","OpenCurlyDoubleQuote":"\u201C","OpenCurlyQuote":"\u2018","operp":"\u29B9","oplus":"\u2295","orarr":"\u21BB","Or":"\u2A54","or":"\u2228","ord":"\u2A5D","order":"\u2134","orderof":"\u2134","ordf":"\u00AA","ordm":"\u00BA","origof":"\u22B6","oror":"\u2A56","orslope":"\u2A57","orv":"\u2A5B","oS":"\u24C8","Oscr":"\uD835\uDCAA","oscr":"\u2134","Oslash":"\u00D8","oslash":"\u00F8","osol":"\u2298","Otilde":"\u00D5","otilde":"\u00F5","otimesas":"\u2A36","Otimes":"\u2A37","otimes":"\u2297","Ouml":"\u00D6","ouml":"\u00F6","ovbar":"\u233D","OverBar":"\u203E","OverBrace":"\u23DE","OverBracket":"\u23B4","OverParenthesis":"\u23DC","para":"\u00B6","parallel":"\u2225","par":"\u2225","parsim":"\u2AF3","parsl":"\u2AFD","part":"\u2202","PartialD":"\u2202","Pcy":"\u041F","pcy":"\u043F","percnt":"%","period":".","permil":"\u2030","perp":"\u22A5","pertenk":"\u2031","Pfr":"\uD835\uDD13","pfr":"\uD835\uDD2D","Phi":"\u03A6","phi":"\u03C6","phiv":"\u03D5","phmmat":"\u2133","phone":"\u260E","Pi":"\u03A0","pi":"\u03C0","pitchfork":"\u22D4","piv":"\u03D6","planck":"\u210F","planckh":"\u210E","plankv":"\u210F","plusacir":"\u2A23","plusb":"\u229E","pluscir":"\u2A22","plus":"+","plusdo":"\u2214","plusdu":"\u2A25","pluse":"\u2A72","PlusMinus":"\u00B1","plusmn":"\u00B1","plussim":"\u2A26","plustwo":"\u2A27","pm":"\u00B1","Poincareplane":"\u210C","pointint":"\u2A15","popf":"\uD835\uDD61","Popf":"\u2119","pound":"\u00A3","prap":"\u2AB7","Pr":"\u2ABB","pr":"\u227A","prcue":"\u227C","precapprox":"\u2AB7","prec":"\u227A","preccurlyeq":"\u227C","Precedes":"\u227A","PrecedesEqual":"\u2AAF","PrecedesSlantEqual":"\u227C","PrecedesTilde":"\u227E","preceq":"\u2AAF","precnapprox":"\u2AB9","precneqq":"\u2AB5","precnsim":"\u22E8","pre":"\u2AAF","prE":"\u2AB3","precsim":"\u227E","prime":"\u2032","Prime":"\u2033","primes":"\u2119","prnap":"\u2AB9","prnE":"\u2AB5","prnsim":"\u22E8","prod":"\u220F","Product":"\u220F","profalar":"\u232E","profline":"\u2312","profsurf":"\u2313","prop":"\u221D","Proportional":"\u221D","Proportion":"\u2237","propto":"\u221D","prsim":"\u227E","prurel":"\u22B0","Pscr":"\uD835\uDCAB","pscr":"\uD835\uDCC5","Psi":"\u03A8","psi":"\u03C8","puncsp":"\u2008","Qfr":"\uD835\uDD14","qfr":"\uD835\uDD2E","qint":"\u2A0C","qopf":"\uD835\uDD62","Qopf":"\u211A","qprime":"\u2057","Qscr":"\uD835\uDCAC","qscr":"\uD835\uDCC6","quaternions":"\u210D","quatint":"\u2A16","quest":"?","questeq":"\u225F","quot":"\"","QUOT":"\"","rAarr":"\u21DB","race":"\u223D\u0331","Racute":"\u0154","racute":"\u0155","radic":"\u221A","raemptyv":"\u29B3","rang":"\u27E9","Rang":"\u27EB","rangd":"\u2992","range":"\u29A5","rangle":"\u27E9","raquo":"\u00BB","rarrap":"\u2975","rarrb":"\u21E5","rarrbfs":"\u2920","rarrc":"\u2933","rarr":"\u2192","Rarr":"\u21A0","rArr":"\u21D2","rarrfs":"\u291E","rarrhk":"\u21AA","rarrlp":"\u21AC","rarrpl":"\u2945","rarrsim":"\u2974","Rarrtl":"\u2916","rarrtl":"\u21A3","rarrw":"\u219D","ratail":"\u291A","rAtail":"\u291C","ratio":"\u2236","rationals":"\u211A","rbarr":"\u290D","rBarr":"\u290F","RBarr":"\u2910","rbbrk":"\u2773","rbrace":"}","rbrack":"]","rbrke":"\u298C","rbrksld":"\u298E","rbrkslu":"\u2990","Rcaron":"\u0158","rcaron":"\u0159","Rcedil":"\u0156","rcedil":"\u0157","rceil":"\u2309","rcub":"}","Rcy":"\u0420","rcy":"\u0440","rdca":"\u2937","rdldhar":"\u2969","rdquo":"\u201D","rdquor":"\u201D","rdsh":"\u21B3","real":"\u211C","realine":"\u211B","realpart":"\u211C","reals":"\u211D","Re":"\u211C","rect":"\u25AD","reg":"\u00AE","REG":"\u00AE","ReverseElement":"\u220B","ReverseEquilibrium":"\u21CB","ReverseUpEquilibrium":"\u296F","rfisht":"\u297D","rfloor":"\u230B","rfr":"\uD835\uDD2F","Rfr":"\u211C","rHar":"\u2964","rhard":"\u21C1","rharu":"\u21C0","rharul":"\u296C","Rho":"\u03A1","rho":"\u03C1","rhov":"\u03F1","RightAngleBracket":"\u27E9","RightArrowBar":"\u21E5","rightarrow":"\u2192","RightArrow":"\u2192","Rightarrow":"\u21D2","RightArrowLeftArrow":"\u21C4","rightarrowtail":"\u21A3","RightCeiling":"\u2309","RightDoubleBracket":"\u27E7","RightDownTeeVector":"\u295D","RightDownVectorBar":"\u2955","RightDownVector":"\u21C2","RightFloor":"\u230B","rightharpoondown":"\u21C1","rightharpoonup":"\u21C0","rightleftarrows":"\u21C4","rightleftharpoons":"\u21CC","rightrightarrows":"\u21C9","rightsquigarrow":"\u219D","RightTeeArrow":"\u21A6","RightTee":"\u22A2","RightTeeVector":"\u295B","rightthreetimes":"\u22CC","RightTriangleBar":"\u29D0","RightTriangle":"\u22B3","RightTriangleEqual":"\u22B5","RightUpDownVector":"\u294F","RightUpTeeVector":"\u295C","RightUpVectorBar":"\u2954","RightUpVector":"\u21BE","RightVectorBar":"\u2953","RightVector":"\u21C0","ring":"\u02DA","risingdotseq":"\u2253","rlarr":"\u21C4","rlhar":"\u21CC","rlm":"\u200F","rmoustache":"\u23B1","rmoust":"\u23B1","rnmid":"\u2AEE","roang":"\u27ED","roarr":"\u21FE","robrk":"\u27E7","ropar":"\u2986","ropf":"\uD835\uDD63","Ropf":"\u211D","roplus":"\u2A2E","rotimes":"\u2A35","RoundImplies":"\u2970","rpar":")","rpargt":"\u2994","rppolint":"\u2A12","rrarr":"\u21C9","Rrightarrow":"\u21DB","rsaquo":"\u203A","rscr":"\uD835\uDCC7","Rscr":"\u211B","rsh":"\u21B1","Rsh":"\u21B1","rsqb":"]","rsquo":"\u2019","rsquor":"\u2019","rthree":"\u22CC","rtimes":"\u22CA","rtri":"\u25B9","rtrie":"\u22B5","rtrif":"\u25B8","rtriltri":"\u29CE","RuleDelayed":"\u29F4","ruluhar":"\u2968","rx":"\u211E","Sacute":"\u015A","sacute":"\u015B","sbquo":"\u201A","scap":"\u2AB8","Scaron":"\u0160","scaron":"\u0161","Sc":"\u2ABC","sc":"\u227B","sccue":"\u227D","sce":"\u2AB0","scE":"\u2AB4","Scedil":"\u015E","scedil":"\u015F","Scirc":"\u015C","scirc":"\u015D","scnap":"\u2ABA","scnE":"\u2AB6","scnsim":"\u22E9","scpolint":"\u2A13","scsim":"\u227F","Scy":"\u0421","scy":"\u0441","sdotb":"\u22A1","sdot":"\u22C5","sdote":"\u2A66","searhk":"\u2925","searr":"\u2198","seArr":"\u21D8","searrow":"\u2198","sect":"\u00A7","semi":";","seswar":"\u2929","setminus":"\u2216","setmn":"\u2216","sext":"\u2736","Sfr":"\uD835\uDD16","sfr":"\uD835\uDD30","sfrown":"\u2322","sharp":"\u266F","SHCHcy":"\u0429","shchcy":"\u0449","SHcy":"\u0428","shcy":"\u0448","ShortDownArrow":"\u2193","ShortLeftArrow":"\u2190","shortmid":"\u2223","shortparallel":"\u2225","ShortRightArrow":"\u2192","ShortUpArrow":"\u2191","shy":"\u00AD","Sigma":"\u03A3","sigma":"\u03C3","sigmaf":"\u03C2","sigmav":"\u03C2","sim":"\u223C","simdot":"\u2A6A","sime":"\u2243","simeq":"\u2243","simg":"\u2A9E","simgE":"\u2AA0","siml":"\u2A9D","simlE":"\u2A9F","simne":"\u2246","simplus":"\u2A24","simrarr":"\u2972","slarr":"\u2190","SmallCircle":"\u2218","smallsetminus":"\u2216","smashp":"\u2A33","smeparsl":"\u29E4","smid":"\u2223","smile":"\u2323","smt":"\u2AAA","smte":"\u2AAC","smtes":"\u2AAC\uFE00","SOFTcy":"\u042C","softcy":"\u044C","solbar":"\u233F","solb":"\u29C4","sol":"/","Sopf":"\uD835\uDD4A","sopf":"\uD835\uDD64","spades":"\u2660","spadesuit":"\u2660","spar":"\u2225","sqcap":"\u2293","sqcaps":"\u2293\uFE00","sqcup":"\u2294","sqcups":"\u2294\uFE00","Sqrt":"\u221A","sqsub":"\u228F","sqsube":"\u2291","sqsubset":"\u228F","sqsubseteq":"\u2291","sqsup":"\u2290","sqsupe":"\u2292","sqsupset":"\u2290","sqsupseteq":"\u2292","square":"\u25A1","Square":"\u25A1","SquareIntersection":"\u2293","SquareSubset":"\u228F","SquareSubsetEqual":"\u2291","SquareSuperset":"\u2290","SquareSupersetEqual":"\u2292","SquareUnion":"\u2294","squarf":"\u25AA","squ":"\u25A1","squf":"\u25AA","srarr":"\u2192","Sscr":"\uD835\uDCAE","sscr":"\uD835\uDCC8","ssetmn":"\u2216","ssmile":"\u2323","sstarf":"\u22C6","Star":"\u22C6","star":"\u2606","starf":"\u2605","straightepsilon":"\u03F5","straightphi":"\u03D5","strns":"\u00AF","sub":"\u2282","Sub":"\u22D0","subdot":"\u2ABD","subE":"\u2AC5","sube":"\u2286","subedot":"\u2AC3","submult":"\u2AC1","subnE":"\u2ACB","subne":"\u228A","subplus":"\u2ABF","subrarr":"\u2979","subset":"\u2282","Subset":"\u22D0","subseteq":"\u2286","subseteqq":"\u2AC5","SubsetEqual":"\u2286","subsetneq":"\u228A","subsetneqq":"\u2ACB","subsim":"\u2AC7","subsub":"\u2AD5","subsup":"\u2AD3","succapprox":"\u2AB8","succ":"\u227B","succcurlyeq":"\u227D","Succeeds":"\u227B","SucceedsEqual":"\u2AB0","SucceedsSlantEqual":"\u227D","SucceedsTilde":"\u227F","succeq":"\u2AB0","succnapprox":"\u2ABA","succneqq":"\u2AB6","succnsim":"\u22E9","succsim":"\u227F","SuchThat":"\u220B","sum":"\u2211","Sum":"\u2211","sung":"\u266A","sup1":"\u00B9","sup2":"\u00B2","sup3":"\u00B3","sup":"\u2283","Sup":"\u22D1","supdot":"\u2ABE","supdsub":"\u2AD8","supE":"\u2AC6","supe":"\u2287","supedot":"\u2AC4","Superset":"\u2283","SupersetEqual":"\u2287","suphsol":"\u27C9","suphsub":"\u2AD7","suplarr":"\u297B","supmult":"\u2AC2","supnE":"\u2ACC","supne":"\u228B","supplus":"\u2AC0","supset":"\u2283","Supset":"\u22D1","supseteq":"\u2287","supseteqq":"\u2AC6","supsetneq":"\u228B","supsetneqq":"\u2ACC","supsim":"\u2AC8","supsub":"\u2AD4","supsup":"\u2AD6","swarhk":"\u2926","swarr":"\u2199","swArr":"\u21D9","swarrow":"\u2199","swnwar":"\u292A","szlig":"\u00DF","Tab":"\t","target":"\u2316","Tau":"\u03A4","tau":"\u03C4","tbrk":"\u23B4","Tcaron":"\u0164","tcaron":"\u0165","Tcedil":"\u0162","tcedil":"\u0163","Tcy":"\u0422","tcy":"\u0442","tdot":"\u20DB","telrec":"\u2315","Tfr":"\uD835\uDD17","tfr":"\uD835\uDD31","there4":"\u2234","therefore":"\u2234","Therefore":"\u2234","Theta":"\u0398","theta":"\u03B8","thetasym":"\u03D1","thetav":"\u03D1","thickapprox":"\u2248","thicksim":"\u223C","ThickSpace":"\u205F\u200A","ThinSpace":"\u2009","thinsp":"\u2009","thkap":"\u2248","thksim":"\u223C","THORN":"\u00DE","thorn":"\u00FE","tilde":"\u02DC","Tilde":"\u223C","TildeEqual":"\u2243","TildeFullEqual":"\u2245","TildeTilde":"\u2248","timesbar":"\u2A31","timesb":"\u22A0","times":"\u00D7","timesd":"\u2A30","tint":"\u222D","toea":"\u2928","topbot":"\u2336","topcir":"\u2AF1","top":"\u22A4","Topf":"\uD835\uDD4B","topf":"\uD835\uDD65","topfork":"\u2ADA","tosa":"\u2929","tprime":"\u2034","trade":"\u2122","TRADE":"\u2122","triangle":"\u25B5","triangledown":"\u25BF","triangleleft":"\u25C3","trianglelefteq":"\u22B4","triangleq":"\u225C","triangleright":"\u25B9","trianglerighteq":"\u22B5","tridot":"\u25EC","trie":"\u225C","triminus":"\u2A3A","TripleDot":"\u20DB","triplus":"\u2A39","trisb":"\u29CD","tritime":"\u2A3B","trpezium":"\u23E2","Tscr":"\uD835\uDCAF","tscr":"\uD835\uDCC9","TScy":"\u0426","tscy":"\u0446","TSHcy":"\u040B","tshcy":"\u045B","Tstrok":"\u0166","tstrok":"\u0167","twixt":"\u226C","twoheadleftarrow":"\u219E","twoheadrightarrow":"\u21A0","Uacute":"\u00DA","uacute":"\u00FA","uarr":"\u2191","Uarr":"\u219F","uArr":"\u21D1","Uarrocir":"\u2949","Ubrcy":"\u040E","ubrcy":"\u045E","Ubreve":"\u016C","ubreve":"\u016D","Ucirc":"\u00DB","ucirc":"\u00FB","Ucy":"\u0423","ucy":"\u0443","udarr":"\u21C5","Udblac":"\u0170","udblac":"\u0171","udhar":"\u296E","ufisht":"\u297E","Ufr":"\uD835\uDD18","ufr":"\uD835\uDD32","Ugrave":"\u00D9","ugrave":"\u00F9","uHar":"\u2963","uharl":"\u21BF","uharr":"\u21BE","uhblk":"\u2580","ulcorn":"\u231C","ulcorner":"\u231C","ulcrop":"\u230F","ultri":"\u25F8","Umacr":"\u016A","umacr":"\u016B","uml":"\u00A8","UnderBar":"_","UnderBrace":"\u23DF","UnderBracket":"\u23B5","UnderParenthesis":"\u23DD","Union":"\u22C3","UnionPlus":"\u228E","Uogon":"\u0172","uogon":"\u0173","Uopf":"\uD835\uDD4C","uopf":"\uD835\uDD66","UpArrowBar":"\u2912","uparrow":"\u2191","UpArrow":"\u2191","Uparrow":"\u21D1","UpArrowDownArrow":"\u21C5","updownarrow":"\u2195","UpDownArrow":"\u2195","Updownarrow":"\u21D5","UpEquilibrium":"\u296E","upharpoonleft":"\u21BF","upharpoonright":"\u21BE","uplus":"\u228E","UpperLeftArrow":"\u2196","UpperRightArrow":"\u2197","upsi":"\u03C5","Upsi":"\u03D2","upsih":"\u03D2","Upsilon":"\u03A5","upsilon":"\u03C5","UpTeeArrow":"\u21A5","UpTee":"\u22A5","upuparrows":"\u21C8","urcorn":"\u231D","urcorner":"\u231D","urcrop":"\u230E","Uring":"\u016E","uring":"\u016F","urtri":"\u25F9","Uscr":"\uD835\uDCB0","uscr":"\uD835\uDCCA","utdot":"\u22F0","Utilde":"\u0168","utilde":"\u0169","utri":"\u25B5","utrif":"\u25B4","uuarr":"\u21C8","Uuml":"\u00DC","uuml":"\u00FC","uwangle":"\u29A7","vangrt":"\u299C","varepsilon":"\u03F5","varkappa":"\u03F0","varnothing":"\u2205","varphi":"\u03D5","varpi":"\u03D6","varpropto":"\u221D","varr":"\u2195","vArr":"\u21D5","varrho":"\u03F1","varsigma":"\u03C2","varsubsetneq":"\u228A\uFE00","varsubsetneqq":"\u2ACB\uFE00","varsupsetneq":"\u228B\uFE00","varsupsetneqq":"\u2ACC\uFE00","vartheta":"\u03D1","vartriangleleft":"\u22B2","vartriangleright":"\u22B3","vBar":"\u2AE8","Vbar":"\u2AEB","vBarv":"\u2AE9","Vcy":"\u0412","vcy":"\u0432","vdash":"\u22A2","vDash":"\u22A8","Vdash":"\u22A9","VDash":"\u22AB","Vdashl":"\u2AE6","veebar":"\u22BB","vee":"\u2228","Vee":"\u22C1","veeeq":"\u225A","vellip":"\u22EE","verbar":"|","Verbar":"\u2016","vert":"|","Vert":"\u2016","VerticalBar":"\u2223","VerticalLine":"|","VerticalSeparator":"\u2758","VerticalTilde":"\u2240","VeryThinSpace":"\u200A","Vfr":"\uD835\uDD19","vfr":"\uD835\uDD33","vltri":"\u22B2","vnsub":"\u2282\u20D2","vnsup":"\u2283\u20D2","Vopf":"\uD835\uDD4D","vopf":"\uD835\uDD67","vprop":"\u221D","vrtri":"\u22B3","Vscr":"\uD835\uDCB1","vscr":"\uD835\uDCCB","vsubnE":"\u2ACB\uFE00","vsubne":"\u228A\uFE00","vsupnE":"\u2ACC\uFE00","vsupne":"\u228B\uFE00","Vvdash":"\u22AA","vzigzag":"\u299A","Wcirc":"\u0174","wcirc":"\u0175","wedbar":"\u2A5F","wedge":"\u2227","Wedge":"\u22C0","wedgeq":"\u2259","weierp":"\u2118","Wfr":"\uD835\uDD1A","wfr":"\uD835\uDD34","Wopf":"\uD835\uDD4E","wopf":"\uD835\uDD68","wp":"\u2118","wr":"\u2240","wreath":"\u2240","Wscr":"\uD835\uDCB2","wscr":"\uD835\uDCCC","xcap":"\u22C2","xcirc":"\u25EF","xcup":"\u22C3","xdtri":"\u25BD","Xfr":"\uD835\uDD1B","xfr":"\uD835\uDD35","xharr":"\u27F7","xhArr":"\u27FA","Xi":"\u039E","xi":"\u03BE","xlarr":"\u27F5","xlArr":"\u27F8","xmap":"\u27FC","xnis":"\u22FB","xodot":"\u2A00","Xopf":"\uD835\uDD4F","xopf":"\uD835\uDD69","xoplus":"\u2A01","xotime":"\u2A02","xrarr":"\u27F6","xrArr":"\u27F9","Xscr":"\uD835\uDCB3","xscr":"\uD835\uDCCD","xsqcup":"\u2A06","xuplus":"\u2A04","xutri":"\u25B3","xvee":"\u22C1","xwedge":"\u22C0","Yacute":"\u00DD","yacute":"\u00FD","YAcy":"\u042F","yacy":"\u044F","Ycirc":"\u0176","ycirc":"\u0177","Ycy":"\u042B","ycy":"\u044B","yen":"\u00A5","Yfr":"\uD835\uDD1C","yfr":"\uD835\uDD36","YIcy":"\u0407","yicy":"\u0457","Yopf":"\uD835\uDD50","yopf":"\uD835\uDD6A","Yscr":"\uD835\uDCB4","yscr":"\uD835\uDCCE","YUcy":"\u042E","yucy":"\u044E","yuml":"\u00FF","Yuml":"\u0178","Zacute":"\u0179","zacute":"\u017A","Zcaron":"\u017D","zcaron":"\u017E","Zcy":"\u0417","zcy":"\u0437","Zdot":"\u017B","zdot":"\u017C","zeetrf":"\u2128","ZeroWidthSpace":"\u200B","Zeta":"\u0396","zeta":"\u03B6","zfr":"\uD835\uDD37","Zfr":"\u2128","ZHcy":"\u0416","zhcy":"\u0436","zigrarr":"\u21DD","zopf":"\uD835\uDD6B","Zopf":"\u2124","Zscr":"\uD835\uDCB5","zscr":"\uD835\uDCCF","zwj":"\u200D","zwnj":"\u200C"}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/entities/legacy.json b/node_modules/htmlparser2/lib/entities/legacy.json
new file mode 100644
index 000000000..f0e82a478
--- /dev/null
+++ b/node_modules/htmlparser2/lib/entities/legacy.json
@@ -0,0 +1 @@
+{"Aacute":"\u00C1","aacute":"\u00E1","Acirc":"\u00C2","acirc":"\u00E2","acute":"\u00B4","AElig":"\u00C6","aelig":"\u00E6","Agrave":"\u00C0","agrave":"\u00E0","amp":"&","AMP":"&","Aring":"\u00C5","aring":"\u00E5","Atilde":"\u00C3","atilde":"\u00E3","Auml":"\u00C4","auml":"\u00E4","brvbar":"\u00A6","Ccedil":"\u00C7","ccedil":"\u00E7","cedil":"\u00B8","cent":"\u00A2","copy":"\u00A9","COPY":"\u00A9","curren":"\u00A4","deg":"\u00B0","divide":"\u00F7","Eacute":"\u00C9","eacute":"\u00E9","Ecirc":"\u00CA","ecirc":"\u00EA","Egrave":"\u00C8","egrave":"\u00E8","ETH":"\u00D0","eth":"\u00F0","Euml":"\u00CB","euml":"\u00EB","frac12":"\u00BD","frac14":"\u00BC","frac34":"\u00BE","gt":">","GT":">","Iacute":"\u00CD","iacute":"\u00ED","Icirc":"\u00CE","icirc":"\u00EE","iexcl":"\u00A1","Igrave":"\u00CC","igrave":"\u00EC","iquest":"\u00BF","Iuml":"\u00CF","iuml":"\u00EF","laquo":"\u00AB","lt":"<","LT":"<","macr":"\u00AF","micro":"\u00B5","middot":"\u00B7","nbsp":"\u00A0","not":"\u00AC","Ntilde":"\u00D1","ntilde":"\u00F1","Oacute":"\u00D3","oacute":"\u00F3","Ocirc":"\u00D4","ocirc":"\u00F4","Ograve":"\u00D2","ograve":"\u00F2","ordf":"\u00AA","ordm":"\u00BA","Oslash":"\u00D8","oslash":"\u00F8","Otilde":"\u00D5","otilde":"\u00F5","Ouml":"\u00D6","ouml":"\u00F6","para":"\u00B6","plusmn":"\u00B1","pound":"\u00A3","quot":"\"","QUOT":"\"","raquo":"\u00BB","reg":"\u00AE","REG":"\u00AE","sect":"\u00A7","shy":"\u00AD","sup1":"\u00B9","sup2":"\u00B2","sup3":"\u00B3","szlig":"\u00DF","THORN":"\u00DE","thorn":"\u00FE","times":"\u00D7","Uacute":"\u00DA","uacute":"\u00FA","Ucirc":"\u00DB","ucirc":"\u00FB","Ugrave":"\u00D9","ugrave":"\u00F9","uml":"\u00A8","Uuml":"\u00DC","uuml":"\u00FC","Yacute":"\u00DD","yacute":"\u00FD","yen":"\u00A5","yuml":"\u00FF"}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/lib/entities/xml.json b/node_modules/htmlparser2/lib/entities/xml.json
new file mode 100644
index 000000000..de8db10d0
--- /dev/null
+++ b/node_modules/htmlparser2/lib/entities/xml.json
@@ -0,0 +1 @@
+{"amp":"&","apos":"'","gt":">","lt":"<","quot":"\""}
diff --git a/node_modules/htmlparser2/lib/index.js b/node_modules/htmlparser2/lib/index.js
new file mode 100644
index 000000000..7f6f649ca
--- /dev/null
+++ b/node_modules/htmlparser2/lib/index.js
@@ -0,0 +1,70 @@
+var Parser = require("./Parser.js"),
+    DomHandler = require("domhandler");
+
+function defineProp(name, value){
+	delete module.exports[name];
+	module.exports[name] = value;
+	return value;
+}
+
+module.exports = {
+	Parser: Parser,
+	Tokenizer: require("./Tokenizer.js"),
+	ElementType: require("domelementtype"),
+	DomHandler: DomHandler,
+	get FeedHandler(){
+		return defineProp("FeedHandler", require("./FeedHandler.js"));
+	},
+	get Stream(){
+		return defineProp("Stream", require("./Stream.js"));
+	},
+	get WritableStream(){
+		return defineProp("WritableStream", require("./WritableStream.js"));
+	},
+	get ProxyHandler(){
+		return defineProp("ProxyHandler", require("./ProxyHandler.js"));
+	},
+	get DomUtils(){
+		return defineProp("DomUtils", require("domutils"));
+	},
+	get CollectingHandler(){
+		return defineProp("CollectingHandler", require("./CollectingHandler.js"));
+	},
+	// For legacy support
+	DefaultHandler: DomHandler,
+	get RssHandler(){
+		return defineProp("RssHandler", this.FeedHandler);
+	},
+	//helper methods
+	parseDOM: function(data, options) {
+		var handler = new DomHandler(options);
+		var parser = new Parser(handler, options);
+		parser.end(data);
+		return handler.dom;
+	},
+	parseFeed: function(feed, options){
+		var handler = new module.exports.FeedHandler();
+		var parser = new Parser(handler);
+		parser.end(feed);
+		return handler.dom;
+	},
+	createDomStream: function(cb, options, elementCb){
+		var handler = new DomHandler(cb, options, elementCb);
+		return new Parser(handler, options);
+	},
+	// List of all events that the parser emits
+	EVENTS: { /* Format: eventname: number of arguments */
+		attribute: 2,
+		cdatastart: 0,
+		cdataend: 0,
+		text: 1,
+		processinginstruction: 2,
+		comment: 1,
+		commentend: 0,
+		closetag: 1,
+		opentag: 2,
+		opentagname: 1,
+		error: 1,
+		end: 0
+	}
+};
diff --git a/node_modules/htmlparser2/node_modules/isarray/README.md b/node_modules/htmlparser2/node_modules/isarray/README.md
new file mode 100644
index 000000000..052a62b8d
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/isarray/README.md
@@ -0,0 +1,54 @@
+
+# isarray
+
+`Array#isArray` for older browsers.
+
+## Usage
+
+```js
+var isArray = require('isarray');
+
+console.log(isArray([])); // => true
+console.log(isArray({})); // => false
+```
+
+## Installation
+
+With [npm](http://npmjs.org) do
+
+```bash
+$ npm install isarray
+```
+
+Then bundle for the browser with
+[browserify](https://github.com/substack/browserify).
+
+With [component](http://component.io) do
+
+```bash
+$ component install juliangruber/isarray
+```
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/htmlparser2/node_modules/isarray/build/build.js b/node_modules/htmlparser2/node_modules/isarray/build/build.js
new file mode 100644
index 000000000..ec58596ae
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/isarray/build/build.js
@@ -0,0 +1,209 @@
+
+/**
+ * Require the given path.
+ *
+ * @param {String} path
+ * @return {Object} exports
+ * @api public
+ */
+
+function require(path, parent, orig) {
+  var resolved = require.resolve(path);
+
+  // lookup failed
+  if (null == resolved) {
+    orig = orig || path;
+    parent = parent || 'root';
+    var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
+    err.path = orig;
+    err.parent = parent;
+    err.require = true;
+    throw err;
+  }
+
+  var module = require.modules[resolved];
+
+  // perform real require()
+  // by invoking the module's
+  // registered function
+  if (!module.exports) {
+    module.exports = {};
+    module.client = module.component = true;
+    module.call(this, module.exports, require.relative(resolved), module);
+  }
+
+  return module.exports;
+}
+
+/**
+ * Registered modules.
+ */
+
+require.modules = {};
+
+/**
+ * Registered aliases.
+ */
+
+require.aliases = {};
+
+/**
+ * Resolve `path`.
+ *
+ * Lookup:
+ *
+ *   - PATH/index.js
+ *   - PATH.js
+ *   - PATH
+ *
+ * @param {String} path
+ * @return {String} path or null
+ * @api private
+ */
+
+require.resolve = function(path) {
+  if (path.charAt(0) === '/') path = path.slice(1);
+  var index = path + '/index.js';
+
+  var paths = [
+    path,
+    path + '.js',
+    path + '.json',
+    path + '/index.js',
+    path + '/index.json'
+  ];
+
+  for (var i = 0; i < paths.length; i++) {
+    var path = paths[i];
+    if (require.modules.hasOwnProperty(path)) return path;
+  }
+
+  if (require.aliases.hasOwnProperty(index)) {
+    return require.aliases[index];
+  }
+};
+
+/**
+ * Normalize `path` relative to the current path.
+ *
+ * @param {String} curr
+ * @param {String} path
+ * @return {String}
+ * @api private
+ */
+
+require.normalize = function(curr, path) {
+  var segs = [];
+
+  if ('.' != path.charAt(0)) return path;
+
+  curr = curr.split('/');
+  path = path.split('/');
+
+  for (var i = 0; i < path.length; ++i) {
+    if ('..' == path[i]) {
+      curr.pop();
+    } else if ('.' != path[i] && '' != path[i]) {
+      segs.push(path[i]);
+    }
+  }
+
+  return curr.concat(segs).join('/');
+};
+
+/**
+ * Register module at `path` with callback `definition`.
+ *
+ * @param {String} path
+ * @param {Function} definition
+ * @api private
+ */
+
+require.register = function(path, definition) {
+  require.modules[path] = definition;
+};
+
+/**
+ * Alias a module definition.
+ *
+ * @param {String} from
+ * @param {String} to
+ * @api private
+ */
+
+require.alias = function(from, to) {
+  if (!require.modules.hasOwnProperty(from)) {
+    throw new Error('Failed to alias "' + from + '", it does not exist');
+  }
+  require.aliases[to] = from;
+};
+
+/**
+ * Return a require function relative to the `parent` path.
+ *
+ * @param {String} parent
+ * @return {Function}
+ * @api private
+ */
+
+require.relative = function(parent) {
+  var p = require.normalize(parent, '..');
+
+  /**
+   * lastIndexOf helper.
+   */
+
+  function lastIndexOf(arr, obj) {
+    var i = arr.length;
+    while (i--) {
+      if (arr[i] === obj) return i;
+    }
+    return -1;
+  }
+
+  /**
+   * The relative require() itself.
+   */
+
+  function localRequire(path) {
+    var resolved = localRequire.resolve(path);
+    return require(resolved, parent, path);
+  }
+
+  /**
+   * Resolve relative to the parent.
+   */
+
+  localRequire.resolve = function(path) {
+    var c = path.charAt(0);
+    if ('/' == c) return path.slice(1);
+    if ('.' == c) return require.normalize(p, path);
+
+    // resolve deps by returning
+    // the dep in the nearest "deps"
+    // directory
+    var segs = parent.split('/');
+    var i = lastIndexOf(segs, 'deps') + 1;
+    if (!i) i = 0;
+    path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
+    return path;
+  };
+
+  /**
+   * Check if module is defined at `path`.
+   */
+
+  localRequire.exists = function(path) {
+    return require.modules.hasOwnProperty(localRequire.resolve(path));
+  };
+
+  return localRequire;
+};
+require.register("isarray/index.js", function(exports, require, module){
+module.exports = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]';
+};
+
+});
+require.alias("isarray/index.js", "isarray/index.js");
+
diff --git a/node_modules/htmlparser2/node_modules/isarray/component.json b/node_modules/htmlparser2/node_modules/isarray/component.json
new file mode 100644
index 000000000..9e31b6838
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/isarray/component.json
@@ -0,0 +1,19 @@
+{
+  "name" : "isarray",
+  "description" : "Array#isArray for older browsers",
+  "version" : "0.0.1",
+  "repository" : "juliangruber/isarray",
+  "homepage": "https://github.com/juliangruber/isarray",
+  "main" : "index.js",
+  "scripts" : [
+    "index.js"
+  ],
+  "dependencies" : {},
+  "keywords": ["browser","isarray","array"],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT"
+}
diff --git a/node_modules/htmlparser2/node_modules/isarray/index.js b/node_modules/htmlparser2/node_modules/isarray/index.js
new file mode 100644
index 000000000..5f5ad45d4
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/isarray/index.js
@@ -0,0 +1,3 @@
+module.exports = Array.isArray || function (arr) {
+  return Object.prototype.toString.call(arr) == '[object Array]';
+};
diff --git a/node_modules/htmlparser2/node_modules/isarray/package.json b/node_modules/htmlparser2/node_modules/isarray/package.json
new file mode 100644
index 000000000..5a1e9c109
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/isarray/package.json
@@ -0,0 +1,25 @@
+{
+  "name" : "isarray",
+  "description" : "Array#isArray for older browsers",
+  "version" : "0.0.1",
+  "repository" : {
+    "type" : "git",
+    "url" : "git://github.com/juliangruber/isarray.git"
+  },
+  "homepage": "https://github.com/juliangruber/isarray",
+  "main" : "index.js",
+  "scripts" : {
+    "test" : "tap test/*.js"
+  },
+  "dependencies" : {},
+  "devDependencies" : {
+    "tap" : "*"
+  },
+  "keywords": ["browser","isarray","array"],
+  "author": {
+    "name": "Julian Gruber",
+    "email": "mail@juliangruber.com",
+    "url": "http://juliangruber.com"
+  },
+  "license": "MIT"
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/.npmignore b/node_modules/htmlparser2/node_modules/readable-stream/.npmignore
new file mode 100644
index 000000000..38344f87a
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/.npmignore
@@ -0,0 +1,5 @@
+build/
+test/
+examples/
+fs.js
+zlib.js
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/LICENSE b/node_modules/htmlparser2/node_modules/readable-stream/LICENSE
new file mode 100644
index 000000000..e3d4e695a
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/LICENSE
@@ -0,0 +1,18 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/README.md b/node_modules/htmlparser2/node_modules/readable-stream/README.md
new file mode 100644
index 000000000..3fb3e8023
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/README.md
@@ -0,0 +1,15 @@
+# readable-stream
+
+***Node-core streams for userland***
+
+[![NPM](https://nodei.co/npm/readable-stream.png?downloads=true&downloadRank=true)](https://nodei.co/npm/readable-stream/)
+[![NPM](https://nodei.co/npm-dl/readable-stream.png?&months=6&height=3)](https://nodei.co/npm/readable-stream/)
+
+This package is a mirror of the Streams2 and Streams3 implementations in Node-core.
+
+If you want to guarantee a stable streams base, regardless of what version of Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core.
+
+**readable-stream** comes in two major versions, v1.0.x and v1.1.x. The former tracks the Streams2 implementation in Node 0.10, including bug-fixes and minor improvements as they are added. The latter tracks Streams3 as it develops in Node 0.11; we will likely see a v1.2.x branch for Node 0.12.
+
+**readable-stream** uses proper patch-level versioning so if you pin to `"~1.0.0"` you’ll get the latest Node 0.10 Streams2 implementation, including any fixes and minor non-breaking improvements. The patch-level versions of 1.0.x and 1.1.x should mirror the patch-level versions of Node-core releases. You should prefer the **1.0.x** releases for now and when you’re ready to start using Streams3, pin to `"~1.1.0"`
+
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/duplex.js b/node_modules/htmlparser2/node_modules/readable-stream/duplex.js
new file mode 100644
index 000000000..ca807af87
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/duplex.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_duplex.js")
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_duplex.js b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_duplex.js
new file mode 100644
index 000000000..b513d61a9
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_duplex.js
@@ -0,0 +1,89 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+  var keys = [];
+  for (var key in obj) keys.push(key);
+  return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+  if (!Duplex.prototype[method])
+    Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+  if (!(this instanceof Duplex))
+    return new Duplex(options);
+
+  Readable.call(this, options);
+  Writable.call(this, options);
+
+  if (options && options.readable === false)
+    this.readable = false;
+
+  if (options && options.writable === false)
+    this.writable = false;
+
+  this.allowHalfOpen = true;
+  if (options && options.allowHalfOpen === false)
+    this.allowHalfOpen = false;
+
+  this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+  // if we allow half-open state, or if the writable side ended,
+  // then we're ok.
+  if (this.allowHalfOpen || this._writableState.ended)
+    return;
+
+  // no more data can be written.
+  // But allow more writes to happen in this tick.
+  process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_passthrough.js b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_passthrough.js
new file mode 100644
index 000000000..895ca50a1
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_passthrough.js
@@ -0,0 +1,46 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+  if (!(this instanceof PassThrough))
+    return new PassThrough(options);
+
+  Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+  cb(null, chunk);
+};
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_readable.js b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_readable.js
new file mode 100644
index 000000000..630722099
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_readable.js
@@ -0,0 +1,982 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+
+/*<replacement>*/
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+  return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+var Stream = require('stream');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+  options = options || {};
+
+  // the point at which it stops calling _read() to fill the buffer
+  // Note: 0 is a valid value, means "don't call _read preemptively ever"
+  var hwm = options.highWaterMark;
+  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  this.buffer = [];
+  this.length = 0;
+  this.pipes = null;
+  this.pipesCount = 0;
+  this.flowing = false;
+  this.ended = false;
+  this.endEmitted = false;
+  this.reading = false;
+
+  // In streams that never have any data, and do push(null) right away,
+  // the consumer can miss the 'end' event if they do some I/O before
+  // consuming the stream.  So, we don't emit('end') until some reading
+  // happens.
+  this.calledRead = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, becuase any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // whenever we return null, then we set a flag to say
+  // that we're awaiting a 'readable' event emission.
+  this.needReadable = false;
+  this.emittedReadable = false;
+  this.readableListening = false;
+
+
+  // object stream flag. Used to make read(n) ignore n and to
+  // make all the buffer merging and length checks go away
+  this.objectMode = !!options.objectMode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // when piping, we only care about 'readable' events that happen
+  // after read()ing all the bytes and not getting any pushback.
+  this.ranOut = false;
+
+  // the number of writers that are awaiting a drain event in .pipe()s
+  this.awaitDrain = 0;
+
+  // if true, a maybeReadMore has been scheduled
+  this.readingMore = false;
+
+  this.decoder = null;
+  this.encoding = null;
+  if (options.encoding) {
+    if (!StringDecoder)
+      StringDecoder = require('string_decoder/').StringDecoder;
+    this.decoder = new StringDecoder(options.encoding);
+    this.encoding = options.encoding;
+  }
+}
+
+function Readable(options) {
+  if (!(this instanceof Readable))
+    return new Readable(options);
+
+  this._readableState = new ReadableState(options, this);
+
+  // legacy
+  this.readable = true;
+
+  Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+  var state = this._readableState;
+
+  if (typeof chunk === 'string' && !state.objectMode) {
+    encoding = encoding || state.defaultEncoding;
+    if (encoding !== state.encoding) {
+      chunk = new Buffer(chunk, encoding);
+      encoding = '';
+    }
+  }
+
+  return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+  var state = this._readableState;
+  return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+  var er = chunkInvalid(state, chunk);
+  if (er) {
+    stream.emit('error', er);
+  } else if (chunk === null || chunk === undefined) {
+    state.reading = false;
+    if (!state.ended)
+      onEofChunk(stream, state);
+  } else if (state.objectMode || chunk && chunk.length > 0) {
+    if (state.ended && !addToFront) {
+      var e = new Error('stream.push() after EOF');
+      stream.emit('error', e);
+    } else if (state.endEmitted && addToFront) {
+      var e = new Error('stream.unshift() after end event');
+      stream.emit('error', e);
+    } else {
+      if (state.decoder && !addToFront && !encoding)
+        chunk = state.decoder.write(chunk);
+
+      // update the buffer info.
+      state.length += state.objectMode ? 1 : chunk.length;
+      if (addToFront) {
+        state.buffer.unshift(chunk);
+      } else {
+        state.reading = false;
+        state.buffer.push(chunk);
+      }
+
+      if (state.needReadable)
+        emitReadable(stream);
+
+      maybeReadMore(stream, state);
+    }
+  } else if (!addToFront) {
+    state.reading = false;
+  }
+
+  return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes.  This is to work around cases where hwm=0,
+// such as the repl.  Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+  return !state.ended &&
+         (state.needReadable ||
+          state.length < state.highWaterMark ||
+          state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+  if (!StringDecoder)
+    StringDecoder = require('string_decoder/').StringDecoder;
+  this._readableState.decoder = new StringDecoder(enc);
+  this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+  if (n >= MAX_HWM) {
+    n = MAX_HWM;
+  } else {
+    // Get the next highest power of 2
+    n--;
+    for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+    n++;
+  }
+  return n;
+}
+
+function howMuchToRead(n, state) {
+  if (state.length === 0 && state.ended)
+    return 0;
+
+  if (state.objectMode)
+    return n === 0 ? 0 : 1;
+
+  if (n === null || isNaN(n)) {
+    // only flow one buffer at a time
+    if (state.flowing && state.buffer.length)
+      return state.buffer[0].length;
+    else
+      return state.length;
+  }
+
+  if (n <= 0)
+    return 0;
+
+  // If we're asking for more than the target buffer level,
+  // then raise the water mark.  Bump up to the next highest
+  // power of 2, to prevent increasing it excessively in tiny
+  // amounts.
+  if (n > state.highWaterMark)
+    state.highWaterMark = roundUpToNextPowerOf2(n);
+
+  // don't have that much.  return null, unless we've ended.
+  if (n > state.length) {
+    if (!state.ended) {
+      state.needReadable = true;
+      return 0;
+    } else
+      return state.length;
+  }
+
+  return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+  var state = this._readableState;
+  state.calledRead = true;
+  var nOrig = n;
+  var ret;
+
+  if (typeof n !== 'number' || n > 0)
+    state.emittedReadable = false;
+
+  // if we're doing read(0) to trigger a readable event, but we
+  // already have a bunch of data in the buffer, then just trigger
+  // the 'readable' event and move on.
+  if (n === 0 &&
+      state.needReadable &&
+      (state.length >= state.highWaterMark || state.ended)) {
+    emitReadable(this);
+    return null;
+  }
+
+  n = howMuchToRead(n, state);
+
+  // if we've ended, and we're now clear, then finish it up.
+  if (n === 0 && state.ended) {
+    ret = null;
+
+    // In cases where the decoder did not receive enough data
+    // to produce a full chunk, then immediately received an
+    // EOF, state.buffer will contain [<Buffer >, <Buffer 00 ...>].
+    // howMuchToRead will see this and coerce the amount to
+    // read to zero (because it's looking at the length of the
+    // first <Buffer > in state.buffer), and we'll end up here.
+    //
+    // This can only happen via state.decoder -- no other venue
+    // exists for pushing a zero-length chunk into state.buffer
+    // and triggering this behavior. In this case, we return our
+    // remaining data and end the stream, if appropriate.
+    if (state.length > 0 && state.decoder) {
+      ret = fromList(n, state);
+      state.length -= ret.length;
+    }
+
+    if (state.length === 0)
+      endReadable(this);
+
+    return ret;
+  }
+
+  // All the actual chunk generation logic needs to be
+  // *below* the call to _read.  The reason is that in certain
+  // synthetic stream cases, such as passthrough streams, _read
+  // may be a completely synchronous operation which may change
+  // the state of the read buffer, providing enough data when
+  // before there was *not* enough.
+  //
+  // So, the steps are:
+  // 1. Figure out what the state of things will be after we do
+  // a read from the buffer.
+  //
+  // 2. If that resulting state will trigger a _read, then call _read.
+  // Note that this may be asynchronous, or synchronous.  Yes, it is
+  // deeply ugly to write APIs this way, but that still doesn't mean
+  // that the Readable class should behave improperly, as streams are
+  // designed to be sync/async agnostic.
+  // Take note if the _read call is sync or async (ie, if the read call
+  // has returned yet), so that we know whether or not it's safe to emit
+  // 'readable' etc.
+  //
+  // 3. Actually pull the requested chunks out of the buffer and return.
+
+  // if we need a readable event, then we need to do some reading.
+  var doRead = state.needReadable;
+
+  // if we currently have less than the highWaterMark, then also read some
+  if (state.length - n <= state.highWaterMark)
+    doRead = true;
+
+  // however, if we've ended, then there's no point, and if we're already
+  // reading, then it's unnecessary.
+  if (state.ended || state.reading)
+    doRead = false;
+
+  if (doRead) {
+    state.reading = true;
+    state.sync = true;
+    // if the length is currently zero, then we *need* a readable event.
+    if (state.length === 0)
+      state.needReadable = true;
+    // call internal read method
+    this._read(state.highWaterMark);
+    state.sync = false;
+  }
+
+  // If _read called its callback synchronously, then `reading`
+  // will be false, and we need to re-evaluate how much data we
+  // can return to the user.
+  if (doRead && !state.reading)
+    n = howMuchToRead(nOrig, state);
+
+  if (n > 0)
+    ret = fromList(n, state);
+  else
+    ret = null;
+
+  if (ret === null) {
+    state.needReadable = true;
+    n = 0;
+  }
+
+  state.length -= n;
+
+  // If we have nothing in the buffer, then we want to know
+  // as soon as we *do* get something into the buffer.
+  if (state.length === 0 && !state.ended)
+    state.needReadable = true;
+
+  // If we happened to read() exactly the remaining amount in the
+  // buffer, and the EOF has been seen at this point, then make sure
+  // that we emit 'end' on the very next tick.
+  if (state.ended && !state.endEmitted && state.length === 0)
+    endReadable(this);
+
+  return ret;
+};
+
+function chunkInvalid(state, chunk) {
+  var er = null;
+  if (!Buffer.isBuffer(chunk) &&
+      'string' !== typeof chunk &&
+      chunk !== null &&
+      chunk !== undefined &&
+      !state.objectMode) {
+    er = new TypeError('Invalid non-string/buffer chunk');
+  }
+  return er;
+}
+
+
+function onEofChunk(stream, state) {
+  if (state.decoder && !state.ended) {
+    var chunk = state.decoder.end();
+    if (chunk && chunk.length) {
+      state.buffer.push(chunk);
+      state.length += state.objectMode ? 1 : chunk.length;
+    }
+  }
+  state.ended = true;
+
+  // if we've ended and we have some data left, then emit
+  // 'readable' now to make sure it gets picked up.
+  if (state.length > 0)
+    emitReadable(stream);
+  else
+    endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+  var state = stream._readableState;
+  state.needReadable = false;
+  if (state.emittedReadable)
+    return;
+
+  state.emittedReadable = true;
+  if (state.sync)
+    process.nextTick(function() {
+      emitReadable_(stream);
+    });
+  else
+    emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+  stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data.  that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+  if (!state.readingMore) {
+    state.readingMore = true;
+    process.nextTick(function() {
+      maybeReadMore_(stream, state);
+    });
+  }
+}
+
+function maybeReadMore_(stream, state) {
+  var len = state.length;
+  while (!state.reading && !state.flowing && !state.ended &&
+         state.length < state.highWaterMark) {
+    stream.read(0);
+    if (len === state.length)
+      // didn't get any data, stop spinning.
+      break;
+    else
+      len = state.length;
+  }
+  state.readingMore = false;
+}
+
+// abstract method.  to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+  this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+  var src = this;
+  var state = this._readableState;
+
+  switch (state.pipesCount) {
+    case 0:
+      state.pipes = dest;
+      break;
+    case 1:
+      state.pipes = [state.pipes, dest];
+      break;
+    default:
+      state.pipes.push(dest);
+      break;
+  }
+  state.pipesCount += 1;
+
+  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+              dest !== process.stdout &&
+              dest !== process.stderr;
+
+  var endFn = doEnd ? onend : cleanup;
+  if (state.endEmitted)
+    process.nextTick(endFn);
+  else
+    src.once('end', endFn);
+
+  dest.on('unpipe', onunpipe);
+  function onunpipe(readable) {
+    if (readable !== src) return;
+    cleanup();
+  }
+
+  function onend() {
+    dest.end();
+  }
+
+  // when the dest drains, it reduces the awaitDrain counter
+  // on the source.  This would be more elegant with a .once()
+  // handler in flow(), but adding and removing repeatedly is
+  // too slow.
+  var ondrain = pipeOnDrain(src);
+  dest.on('drain', ondrain);
+
+  function cleanup() {
+    // cleanup event handlers once the pipe is broken
+    dest.removeListener('close', onclose);
+    dest.removeListener('finish', onfinish);
+    dest.removeListener('drain', ondrain);
+    dest.removeListener('error', onerror);
+    dest.removeListener('unpipe', onunpipe);
+    src.removeListener('end', onend);
+    src.removeListener('end', cleanup);
+
+    // if the reader is waiting for a drain event from this
+    // specific writer, then it would cause it to never start
+    // flowing again.
+    // So, if this is awaiting a drain, then we just call it now.
+    // If we don't know, then assume that we are waiting for one.
+    if (!dest._writableState || dest._writableState.needDrain)
+      ondrain();
+  }
+
+  // if the dest has an error, then stop piping into it.
+  // however, don't suppress the throwing behavior for this.
+  function onerror(er) {
+    unpipe();
+    dest.removeListener('error', onerror);
+    if (EE.listenerCount(dest, 'error') === 0)
+      dest.emit('error', er);
+  }
+  // This is a brutally ugly hack to make sure that our error handler
+  // is attached before any userland ones.  NEVER DO THIS.
+  if (!dest._events || !dest._events.error)
+    dest.on('error', onerror);
+  else if (isArray(dest._events.error))
+    dest._events.error.unshift(onerror);
+  else
+    dest._events.error = [onerror, dest._events.error];
+
+
+
+  // Both close and finish should trigger unpipe, but only once.
+  function onclose() {
+    dest.removeListener('finish', onfinish);
+    unpipe();
+  }
+  dest.once('close', onclose);
+  function onfinish() {
+    dest.removeListener('close', onclose);
+    unpipe();
+  }
+  dest.once('finish', onfinish);
+
+  function unpipe() {
+    src.unpipe(dest);
+  }
+
+  // tell the dest that it's being piped to
+  dest.emit('pipe', src);
+
+  // start the flow if it hasn't been started already.
+  if (!state.flowing) {
+    // the handler that waits for readable events after all
+    // the data gets sucked out in flow.
+    // This would be easier to follow with a .once() handler
+    // in flow(), but that is too slow.
+    this.on('readable', pipeOnReadable);
+
+    state.flowing = true;
+    process.nextTick(function() {
+      flow(src);
+    });
+  }
+
+  return dest;
+};
+
+function pipeOnDrain(src) {
+  return function() {
+    var dest = this;
+    var state = src._readableState;
+    state.awaitDrain--;
+    if (state.awaitDrain === 0)
+      flow(src);
+  };
+}
+
+function flow(src) {
+  var state = src._readableState;
+  var chunk;
+  state.awaitDrain = 0;
+
+  function write(dest, i, list) {
+    var written = dest.write(chunk);
+    if (false === written) {
+      state.awaitDrain++;
+    }
+  }
+
+  while (state.pipesCount && null !== (chunk = src.read())) {
+
+    if (state.pipesCount === 1)
+      write(state.pipes, 0, null);
+    else
+      forEach(state.pipes, write);
+
+    src.emit('data', chunk);
+
+    // if anyone needs a drain, then we have to wait for that.
+    if (state.awaitDrain > 0)
+      return;
+  }
+
+  // if every destination was unpiped, either before entering this
+  // function, or in the while loop, then stop flowing.
+  //
+  // NB: This is a pretty rare edge case.
+  if (state.pipesCount === 0) {
+    state.flowing = false;
+
+    // if there were data event listeners added, then switch to old mode.
+    if (EE.listenerCount(src, 'data') > 0)
+      emitDataEvents(src);
+    return;
+  }
+
+  // at this point, no one needed a drain, so we just ran out of data
+  // on the next readable event, start it over again.
+  state.ranOut = true;
+}
+
+function pipeOnReadable() {
+  if (this._readableState.ranOut) {
+    this._readableState.ranOut = false;
+    flow(this);
+  }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+  var state = this._readableState;
+
+  // if we're not piping anywhere, then do nothing.
+  if (state.pipesCount === 0)
+    return this;
+
+  // just one destination.  most common case.
+  if (state.pipesCount === 1) {
+    // passed in one, but it's not the right one.
+    if (dest && dest !== state.pipes)
+      return this;
+
+    if (!dest)
+      dest = state.pipes;
+
+    // got a match.
+    state.pipes = null;
+    state.pipesCount = 0;
+    this.removeListener('readable', pipeOnReadable);
+    state.flowing = false;
+    if (dest)
+      dest.emit('unpipe', this);
+    return this;
+  }
+
+  // slow case. multiple pipe destinations.
+
+  if (!dest) {
+    // remove all.
+    var dests = state.pipes;
+    var len = state.pipesCount;
+    state.pipes = null;
+    state.pipesCount = 0;
+    this.removeListener('readable', pipeOnReadable);
+    state.flowing = false;
+
+    for (var i = 0; i < len; i++)
+      dests[i].emit('unpipe', this);
+    return this;
+  }
+
+  // try to find the right one.
+  var i = indexOf(state.pipes, dest);
+  if (i === -1)
+    return this;
+
+  state.pipes.splice(i, 1);
+  state.pipesCount -= 1;
+  if (state.pipesCount === 1)
+    state.pipes = state.pipes[0];
+
+  dest.emit('unpipe', this);
+
+  return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+  var res = Stream.prototype.on.call(this, ev, fn);
+
+  if (ev === 'data' && !this._readableState.flowing)
+    emitDataEvents(this);
+
+  if (ev === 'readable' && this.readable) {
+    var state = this._readableState;
+    if (!state.readableListening) {
+      state.readableListening = true;
+      state.emittedReadable = false;
+      state.needReadable = true;
+      if (!state.reading) {
+        this.read(0);
+      } else if (state.length) {
+        emitReadable(this, state);
+      }
+    }
+  }
+
+  return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+  emitDataEvents(this);
+  this.read(0);
+  this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+  emitDataEvents(this, true);
+  this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+  var state = stream._readableState;
+
+  if (state.flowing) {
+    // https://github.com/isaacs/readable-stream/issues/16
+    throw new Error('Cannot switch to old mode now.');
+  }
+
+  var paused = startPaused || false;
+  var readable = false;
+
+  // convert to an old-style stream.
+  stream.readable = true;
+  stream.pipe = Stream.prototype.pipe;
+  stream.on = stream.addListener = Stream.prototype.on;
+
+  stream.on('readable', function() {
+    readable = true;
+
+    var c;
+    while (!paused && (null !== (c = stream.read())))
+      stream.emit('data', c);
+
+    if (c === null) {
+      readable = false;
+      stream._readableState.needReadable = true;
+    }
+  });
+
+  stream.pause = function() {
+    paused = true;
+    this.emit('pause');
+  };
+
+  stream.resume = function() {
+    paused = false;
+    if (readable)
+      process.nextTick(function() {
+        stream.emit('readable');
+      });
+    else
+      this.read(0);
+    this.emit('resume');
+  };
+
+  // now make it start, just in case it hadn't already.
+  stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+  var state = this._readableState;
+  var paused = false;
+
+  var self = this;
+  stream.on('end', function() {
+    if (state.decoder && !state.ended) {
+      var chunk = state.decoder.end();
+      if (chunk && chunk.length)
+        self.push(chunk);
+    }
+
+    self.push(null);
+  });
+
+  stream.on('data', function(chunk) {
+    if (state.decoder)
+      chunk = state.decoder.write(chunk);
+
+    // don't skip over falsy values in objectMode
+    //if (state.objectMode && util.isNullOrUndefined(chunk))
+    if (state.objectMode && (chunk === null || chunk === undefined))
+      return;
+    else if (!state.objectMode && (!chunk || !chunk.length))
+      return;
+
+    var ret = self.push(chunk);
+    if (!ret) {
+      paused = true;
+      stream.pause();
+    }
+  });
+
+  // proxy all the other methods.
+  // important when wrapping filters and duplexes.
+  for (var i in stream) {
+    if (typeof stream[i] === 'function' &&
+        typeof this[i] === 'undefined') {
+      this[i] = function(method) { return function() {
+        return stream[method].apply(stream, arguments);
+      }}(i);
+    }
+  }
+
+  // proxy certain important events.
+  var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+  forEach(events, function(ev) {
+    stream.on(ev, self.emit.bind(self, ev));
+  });
+
+  // when we try to consume some more bytes, simply unpause the
+  // underlying stream.
+  self._read = function(n) {
+    if (paused) {
+      paused = false;
+      stream.resume();
+    }
+  };
+
+  return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+  var list = state.buffer;
+  var length = state.length;
+  var stringMode = !!state.decoder;
+  var objectMode = !!state.objectMode;
+  var ret;
+
+  // nothing in the list, definitely empty.
+  if (list.length === 0)
+    return null;
+
+  if (length === 0)
+    ret = null;
+  else if (objectMode)
+    ret = list.shift();
+  else if (!n || n >= length) {
+    // read it all, truncate the array.
+    if (stringMode)
+      ret = list.join('');
+    else
+      ret = Buffer.concat(list, length);
+    list.length = 0;
+  } else {
+    // read just some of it.
+    if (n < list[0].length) {
+      // just take a part of the first list item.
+      // slice is the same for buffers and strings.
+      var buf = list[0];
+      ret = buf.slice(0, n);
+      list[0] = buf.slice(n);
+    } else if (n === list[0].length) {
+      // first list is a perfect match
+      ret = list.shift();
+    } else {
+      // complex case.
+      // we have enough to cover it, but it spans past the first buffer.
+      if (stringMode)
+        ret = '';
+      else
+        ret = new Buffer(n);
+
+      var c = 0;
+      for (var i = 0, l = list.length; i < l && c < n; i++) {
+        var buf = list[0];
+        var cpy = Math.min(n - c, buf.length);
+
+        if (stringMode)
+          ret += buf.slice(0, cpy);
+        else
+          buf.copy(ret, c, 0, cpy);
+
+        if (cpy < buf.length)
+          list[0] = buf.slice(cpy);
+        else
+          list.shift();
+
+        c += cpy;
+      }
+    }
+  }
+
+  return ret;
+}
+
+function endReadable(stream) {
+  var state = stream._readableState;
+
+  // If we get here before consuming all the bytes, then that is a
+  // bug in node.  Should never happen.
+  if (state.length > 0)
+    throw new Error('endReadable called on non-empty stream');
+
+  if (!state.endEmitted && state.calledRead) {
+    state.ended = true;
+    process.nextTick(function() {
+      // Check that we didn't get one last unshift.
+      if (!state.endEmitted && state.length === 0) {
+        state.endEmitted = true;
+        stream.readable = false;
+        stream.emit('end');
+      }
+    });
+  }
+}
+
+function forEach (xs, f) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    f(xs[i], i);
+  }
+}
+
+function indexOf (xs, x) {
+  for (var i = 0, l = xs.length; i < l; i++) {
+    if (xs[i] === x) return i;
+  }
+  return -1;
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_transform.js b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_transform.js
new file mode 100644
index 000000000..eb188df3e
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_transform.js
@@ -0,0 +1,210 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+  this.afterTransform = function(er, data) {
+    return afterTransform(stream, er, data);
+  };
+
+  this.needTransform = false;
+  this.transforming = false;
+  this.writecb = null;
+  this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+  var ts = stream._transformState;
+  ts.transforming = false;
+
+  var cb = ts.writecb;
+
+  if (!cb)
+    return stream.emit('error', new Error('no writecb in Transform class'));
+
+  ts.writechunk = null;
+  ts.writecb = null;
+
+  if (data !== null && data !== undefined)
+    stream.push(data);
+
+  if (cb)
+    cb(er);
+
+  var rs = stream._readableState;
+  rs.reading = false;
+  if (rs.needReadable || rs.length < rs.highWaterMark) {
+    stream._read(rs.highWaterMark);
+  }
+}
+
+
+function Transform(options) {
+  if (!(this instanceof Transform))
+    return new Transform(options);
+
+  Duplex.call(this, options);
+
+  var ts = this._transformState = new TransformState(options, this);
+
+  // when the writable side finishes, then flush out anything remaining.
+  var stream = this;
+
+  // start out asking for a readable event once data is transformed.
+  this._readableState.needReadable = true;
+
+  // we have implemented the _read method, and done the other things
+  // that Readable wants before the first _read call, so unset the
+  // sync guard flag.
+  this._readableState.sync = false;
+
+  this.once('finish', function() {
+    if ('function' === typeof this._flush)
+      this._flush(function(er) {
+        done(stream, er);
+      });
+    else
+      done(stream);
+  });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+  this._transformState.needTransform = false;
+  return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side.  You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk.  If you pass
+// an error, then that'll put the hurt on the whole operation.  If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+  throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+  var ts = this._transformState;
+  ts.writecb = cb;
+  ts.writechunk = chunk;
+  ts.writeencoding = encoding;
+  if (!ts.transforming) {
+    var rs = this._readableState;
+    if (ts.needTransform ||
+        rs.needReadable ||
+        rs.length < rs.highWaterMark)
+      this._read(rs.highWaterMark);
+  }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+  var ts = this._transformState;
+
+  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+    ts.transforming = true;
+    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+  } else {
+    // mark that we need a transform, so that any data that comes in
+    // will get processed, now that we've asked for it.
+    ts.needTransform = true;
+  }
+};
+
+
+function done(stream, er) {
+  if (er)
+    return stream.emit('error', er);
+
+  // if there's nothing in the write buffer, then that means
+  // that nothing more will ever be provided
+  var ws = stream._writableState;
+  var rs = stream._readableState;
+  var ts = stream._transformState;
+
+  if (ws.length)
+    throw new Error('calling transform done when ws.length != 0');
+
+  if (ts.transforming)
+    throw new Error('calling transform done when still transforming');
+
+  return stream.push(null);
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_writable.js b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_writable.js
new file mode 100644
index 000000000..4bdaa4fa4
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/lib/_stream_writable.js
@@ -0,0 +1,386 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+  this.chunk = chunk;
+  this.encoding = encoding;
+  this.callback = cb;
+}
+
+function WritableState(options, stream) {
+  options = options || {};
+
+  // the point at which write() starts returning false
+  // Note: 0 is a valid value, means that we always return false if
+  // the entire buffer is not flushed immediately on write()
+  var hwm = options.highWaterMark;
+  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+  // object stream flag to indicate whether or not this stream
+  // contains buffers or objects.
+  this.objectMode = !!options.objectMode;
+
+  // cast to ints.
+  this.highWaterMark = ~~this.highWaterMark;
+
+  this.needDrain = false;
+  // at the start of calling end()
+  this.ending = false;
+  // when end() has been called, and returned
+  this.ended = false;
+  // when 'finish' is emitted
+  this.finished = false;
+
+  // should we decode strings into buffers before passing to _write?
+  // this is here so that some node-core streams can optimize string
+  // handling at a lower level.
+  var noDecode = options.decodeStrings === false;
+  this.decodeStrings = !noDecode;
+
+  // Crypto is kind of old and crusty.  Historically, its default string
+  // encoding is 'binary' so we have to make this configurable.
+  // Everything else in the universe uses 'utf8', though.
+  this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+  // not an actual buffer we keep track of, but a measurement
+  // of how much we're waiting to get pushed to some underlying
+  // socket or file.
+  this.length = 0;
+
+  // a flag to see when we're in the middle of a write.
+  this.writing = false;
+
+  // a flag to be able to tell if the onwrite cb is called immediately,
+  // or on a later tick.  We set this to true at first, becuase any
+  // actions that shouldn't happen until "later" should generally also
+  // not happen before the first write call.
+  this.sync = true;
+
+  // a flag to know if we're processing previously buffered items, which
+  // may call the _write() callback in the same tick, so that we don't
+  // end up in an overlapped onwrite situation.
+  this.bufferProcessing = false;
+
+  // the callback that's passed to _write(chunk,cb)
+  this.onwrite = function(er) {
+    onwrite(stream, er);
+  };
+
+  // the callback that the user supplies to write(chunk,encoding,cb)
+  this.writecb = null;
+
+  // the amount that is being written when _write is called.
+  this.writelen = 0;
+
+  this.buffer = [];
+
+  // True if the error was already emitted and should not be thrown again
+  this.errorEmitted = false;
+}
+
+function Writable(options) {
+  var Duplex = require('./_stream_duplex');
+
+  // Writable ctor is applied to Duplexes, though they're not
+  // instanceof Writable, they're instanceof Readable.
+  if (!(this instanceof Writable) && !(this instanceof Duplex))
+    return new Writable(options);
+
+  this._writableState = new WritableState(options, this);
+
+  // legacy.
+  this.writable = true;
+
+  Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+  this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+  var er = new Error('write after end');
+  // TODO: defer error events consistently everywhere, not just the cb
+  stream.emit('error', er);
+  process.nextTick(function() {
+    cb(er);
+  });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+  var valid = true;
+  if (!Buffer.isBuffer(chunk) &&
+      'string' !== typeof chunk &&
+      chunk !== null &&
+      chunk !== undefined &&
+      !state.objectMode) {
+    var er = new TypeError('Invalid non-string/buffer chunk');
+    stream.emit('error', er);
+    process.nextTick(function() {
+      cb(er);
+    });
+    valid = false;
+  }
+  return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+  var state = this._writableState;
+  var ret = false;
+
+  if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (Buffer.isBuffer(chunk))
+    encoding = 'buffer';
+  else if (!encoding)
+    encoding = state.defaultEncoding;
+
+  if (typeof cb !== 'function')
+    cb = function() {};
+
+  if (state.ended)
+    writeAfterEnd(this, state, cb);
+  else if (validChunk(this, state, chunk, cb))
+    ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+  return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+  if (!state.objectMode &&
+      state.decodeStrings !== false &&
+      typeof chunk === 'string') {
+    chunk = new Buffer(chunk, encoding);
+  }
+  return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn.  Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+  chunk = decodeChunk(state, chunk, encoding);
+  if (Buffer.isBuffer(chunk))
+    encoding = 'buffer';
+  var len = state.objectMode ? 1 : chunk.length;
+
+  state.length += len;
+
+  var ret = state.length < state.highWaterMark;
+  // we must ensure that previous needDrain will not be reset to false.
+  if (!ret)
+    state.needDrain = true;
+
+  if (state.writing)
+    state.buffer.push(new WriteReq(chunk, encoding, cb));
+  else
+    doWrite(stream, state, len, chunk, encoding, cb);
+
+  return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+  state.writelen = len;
+  state.writecb = cb;
+  state.writing = true;
+  state.sync = true;
+  stream._write(chunk, encoding, state.onwrite);
+  state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+  if (sync)
+    process.nextTick(function() {
+      cb(er);
+    });
+  else
+    cb(er);
+
+  stream._writableState.errorEmitted = true;
+  stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+  state.writing = false;
+  state.writecb = null;
+  state.length -= state.writelen;
+  state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+  var state = stream._writableState;
+  var sync = state.sync;
+  var cb = state.writecb;
+
+  onwriteStateUpdate(state);
+
+  if (er)
+    onwriteError(stream, state, sync, er, cb);
+  else {
+    // Check if we're actually ready to finish, but don't emit yet
+    var finished = needFinish(stream, state);
+
+    if (!finished && !state.bufferProcessing && state.buffer.length)
+      clearBuffer(stream, state);
+
+    if (sync) {
+      process.nextTick(function() {
+        afterWrite(stream, state, finished, cb);
+      });
+    } else {
+      afterWrite(stream, state, finished, cb);
+    }
+  }
+}
+
+function afterWrite(stream, state, finished, cb) {
+  if (!finished)
+    onwriteDrain(stream, state);
+  cb();
+  if (finished)
+    finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+  if (state.length === 0 && state.needDrain) {
+    state.needDrain = false;
+    stream.emit('drain');
+  }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+  state.bufferProcessing = true;
+
+  for (var c = 0; c < state.buffer.length; c++) {
+    var entry = state.buffer[c];
+    var chunk = entry.chunk;
+    var encoding = entry.encoding;
+    var cb = entry.callback;
+    var len = state.objectMode ? 1 : chunk.length;
+
+    doWrite(stream, state, len, chunk, encoding, cb);
+
+    // if we didn't call the onwrite immediately, then
+    // it means that we need to wait until it does.
+    // also, that means that the chunk and cb are currently
+    // being processed, so move the buffer counter past them.
+    if (state.writing) {
+      c++;
+      break;
+    }
+  }
+
+  state.bufferProcessing = false;
+  if (c < state.buffer.length)
+    state.buffer = state.buffer.slice(c);
+  else
+    state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+  cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+  var state = this._writableState;
+
+  if (typeof chunk === 'function') {
+    cb = chunk;
+    chunk = null;
+    encoding = null;
+  } else if (typeof encoding === 'function') {
+    cb = encoding;
+    encoding = null;
+  }
+
+  if (typeof chunk !== 'undefined' && chunk !== null)
+    this.write(chunk, encoding);
+
+  // ignore unnecessary end() calls.
+  if (!state.ending && !state.finished)
+    endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+  return (state.ending &&
+          state.length === 0 &&
+          !state.finished &&
+          !state.writing);
+}
+
+function finishMaybe(stream, state) {
+  var need = needFinish(stream, state);
+  if (need) {
+    state.finished = true;
+    stream.emit('finish');
+  }
+  return need;
+}
+
+function endWritable(stream, state, cb) {
+  state.ending = true;
+  finishMaybe(stream, state);
+  if (cb) {
+    if (state.finished)
+      process.nextTick(cb);
+    else
+      stream.once('finish', cb);
+  }
+  state.ended = true;
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/package.json b/node_modules/htmlparser2/node_modules/readable-stream/package.json
new file mode 100644
index 000000000..b550f6ce4
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "readable-stream",
+  "version": "1.0.34",
+  "description": "Streams2, a user-land copy of the stream library from Node.js v0.10.x",
+  "main": "readable.js",
+  "dependencies": {
+    "core-util-is": "~1.0.0",
+    "isarray": "0.0.1",
+    "string_decoder": "~0.10.x",
+    "inherits": "~2.0.1"
+  },
+  "devDependencies": {
+    "tap": "~0.2.6"
+  },
+  "scripts": {
+    "test": "tap test/simple/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/readable-stream"
+  },
+  "keywords": [
+    "readable",
+    "stream",
+    "pipe"
+  ],
+  "browser": {
+    "util": false
+  },
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "MIT"
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/passthrough.js b/node_modules/htmlparser2/node_modules/readable-stream/passthrough.js
new file mode 100644
index 000000000..27e8d8a55
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/passthrough.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_passthrough.js")
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/readable.js b/node_modules/htmlparser2/node_modules/readable-stream/readable.js
new file mode 100644
index 000000000..26511e87b
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/readable.js
@@ -0,0 +1,11 @@
+var Stream = require('stream'); // hack to fix a circular dependency issue when used with browserify
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = Stream;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+if (!process.browser && process.env.READABLE_STREAM === 'disable') {
+  module.exports = require('stream');
+}
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/transform.js b/node_modules/htmlparser2/node_modules/readable-stream/transform.js
new file mode 100644
index 000000000..5d482f078
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/transform.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_transform.js")
diff --git a/node_modules/htmlparser2/node_modules/readable-stream/writable.js b/node_modules/htmlparser2/node_modules/readable-stream/writable.js
new file mode 100644
index 000000000..e1e9efdf3
--- /dev/null
+++ b/node_modules/htmlparser2/node_modules/readable-stream/writable.js
@@ -0,0 +1 @@
+module.exports = require("./lib/_stream_writable.js")
diff --git a/node_modules/htmlparser2/package.json b/node_modules/htmlparser2/package.json
new file mode 100644
index 000000000..8de5bf81d
--- /dev/null
+++ b/node_modules/htmlparser2/package.json
@@ -0,0 +1,36 @@
+{
+	"name": "htmlparser2",
+	"description": "Fast & forgiving HTML/XML/RSS parser",
+	"version": "3.3.0",
+	"author": "Felix Boehm <me@feedic.com>",
+	"keywords": ["html", "parser", "streams", "xml", "dom", "rss", "feed", "atom"],
+	"contributors": ["Chris Winberry <chris@winberry.net>"],
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/fb55/htmlparser2.git"
+	},
+	"bugs": {
+		"mail": "me@feedic.com",
+		"url": "http://github.com/fb55/htmlparser2/issues"
+	},
+	"directories": {
+		"lib": "lib/"
+	},
+	"main": "lib/index.js",
+	"scripts": {
+		"test": "mocha -R spec"
+	},
+	"dependencies": {
+		"domhandler": "2.1",
+		"domutils": "1.1",
+		"domelementtype": "1",
+		"readable-stream": "1.0"
+	},
+	"devDependencies": {
+		"mocha": "1"
+	},
+	"licenses": [{
+		"type": "MIT",
+		"url": "http://github.com/fb55/htmlparser2/raw/master/LICENSE"
+	}]
+}
diff --git a/node_modules/htmlparser2/test/01-events.js b/node_modules/htmlparser2/test/01-events.js
new file mode 100644
index 000000000..a3c7cf329
--- /dev/null
+++ b/node_modules/htmlparser2/test/01-events.js
@@ -0,0 +1,9 @@
+var helper = require("./test-helper.js");
+
+helper.mochaTest("Events", __dirname, function(test, cb){
+	helper.writeToParser(
+		helper.getEventCollector(cb),
+		test.options.parser,
+		test.html
+	);
+});
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/02-stream.js b/node_modules/htmlparser2/test/02-stream.js
new file mode 100644
index 000000000..340398067
--- /dev/null
+++ b/node_modules/htmlparser2/test/02-stream.js
@@ -0,0 +1,23 @@
+var helper = require("./test-helper.js"),
+	Stream = require("..").WritableStream,
+	fs = require("fs"),
+	path = require("path");
+
+helper.mochaTest("Stream", __dirname, function(test, cb){
+	var filePath = path.join(__dirname, "Documents", test.file);
+	fs.createReadStream(filePath).pipe(
+		new Stream(
+			helper.getEventCollector(function(err, events){
+				cb(err, events);
+
+				var handler = helper.getEventCollector(cb),
+				    stream = new Stream(handler, test.options);
+
+				fs.readFile(filePath, function(err, data){
+					if(err) throw err;
+					else stream.end(data);
+				});
+			}
+		), test.options)
+	).on("error", cb);
+});
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/03-feed.js b/node_modules/htmlparser2/test/03-feed.js
new file mode 100644
index 000000000..8e78eb8e4
--- /dev/null
+++ b/node_modules/htmlparser2/test/03-feed.js
@@ -0,0 +1,19 @@
+//Runs tests for feeds
+
+var helper = require("./test-helper.js"),
+	FeedHandler = require("../lib/FeedHandler.js"),
+	fs = require("fs"),
+	path = require("path");
+
+helper.mochaTest("Feeds", __dirname, function(test, cb){
+	fs.readFile(
+		path.join(__dirname, "Documents", test.file),
+		function(err, file){
+			helper.writeToParser(
+				new FeedHandler(cb),
+				{ xmlMode: true },
+				file.toString()
+			);
+		}
+	);
+});
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Documents/Atom_Example.xml b/node_modules/htmlparser2/test/Documents/Atom_Example.xml
new file mode 100644
index 000000000..734974539
--- /dev/null
+++ b/node_modules/htmlparser2/test/Documents/Atom_Example.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- http://en.wikipedia.org/wiki/Atom_%28standard%29 -->
+<feed xmlns="http://www.w3.org/2005/Atom">
+	<title>Example Feed</title>
+	<subtitle>A subtitle.</subtitle>
+	<link href="http://example.org/feed/" rel="self" />
+	<link href="http://example.org/" />
+	<id>urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6</id>
+	<updated>2003-12-13T18:30:02Z</updated>
+	<author>
+		<name>John Doe</name>
+		<email>johndoe@example.com</email>
+	</author>
+
+	<entry>
+		<title>Atom-Powered Robots Run Amok</title>
+		<link href="http://example.org/2003/12/13/atom03" />
+		<link rel="alternate" type="text/html" href="http://example.org/2003/12/13/atom03.html"/>
+		<link rel="edit" href="http://example.org/2003/12/13/atom03/edit"/>
+		<id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
+		<updated>2003-12-13T18:30:02Z</updated>
+		<summary>Some text.</summary>
+	</entry>
+
+</feed>
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Documents/Attributes.html b/node_modules/htmlparser2/test/Documents/Attributes.html
new file mode 100644
index 000000000..f3bfa09c1
--- /dev/null
+++ b/node_modules/htmlparser2/test/Documents/Attributes.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html>
+<head>
+	<title>Attributes test</title>
+</head>
+<body>
+	<!-- Normal attributes -->
+	<button id="test0" class="value0" title="value1">class="value0" title="value1"</button>
+
+	<!-- Attributes with no quotes or value -->
+	<button id="test1" class=value2 disabled>class=value2 disabled</button>
+
+	<!-- Attributes with no space between them. No valid, but accepted by the browser -->
+	<button id="test2" class="value4"title="value5">class="value4"title="value5"</button>
+</body>
+</html>
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Documents/Basic.html b/node_modules/htmlparser2/test/Documents/Basic.html
new file mode 100644
index 000000000..65957a2f1
--- /dev/null
+++ b/node_modules/htmlparser2/test/Documents/Basic.html
@@ -0,0 +1 @@
+<!DOCTYPE html><html><title>The Title</title><body>Hello world</body></html>
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Documents/RDF_Example.xml b/node_modules/htmlparser2/test/Documents/RDF_Example.xml
new file mode 100644
index 000000000..068da173c
--- /dev/null
+++ b/node_modules/htmlparser2/test/Documents/RDF_Example.xml
@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:ev="http://purl.org/rss/1.0/modules/event/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:admin="http://webns.net/mvcb/">
+	<channel rdf:about="http://sfbay.craigslist.org/ccc/">
+		<title>craigslist | all community in SF bay area</title>
+		<link>http://sfbay.craigslist.org/ccc/</link>
+		<description/>
+		<dc:language>en-us</dc:language>
+		<dc:rights>Copyright 2011 craigslist, inc.</dc:rights>
+		<dc:publisher>webmaster@craigslist.org</dc:publisher>
+		<dc:creator>webmaster@craigslist.org</dc:creator>
+		<dc:source>http://sfbay.craigslist.org/ccc//</dc:source>
+		<dc:title>craigslist | all community in SF bay area</dc:title>
+		<dc:type>Collection</dc:type>
+		<syn:updateBase>2011-11-04T09:39:10-07:00</syn:updateBase>
+		<syn:updateFrequency>4</syn:updateFrequency>
+		<syn:updatePeriod>hourly</syn:updatePeriod>
+		<items>
+			<rdf:Seq>
+				<rdf:li rdf:resource="http://sfbay.craigslist.org/sby/muc/2681301534.html"/>
+			</rdf:Seq>
+		</items>
+	</channel>
+	<item rdf:about="http://sfbay.craigslist.org/sby/muc/2681301534.html">
+		<title><![CDATA[ Music Equipment Repair and Consignment ]]></title>
+		<link>
+http://sfbay.craigslist.org/sby/muc/2681301534.html
+</link>
+		<description><![CDATA[
+San Jose Rock Shop offers musical instrument repair and consignment! (408) 215-2065<br> <br> We are pleased to announce our NEW LOCATION: 1199 N 5th st. San Jose, ca 95112. Please call ahead, by appointment only.<br> <br> Recently featured by Metro Newspaper in their 2011 Best of the Silicon Valley edition see it online here:<br> <a href="http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html" rel="nofollow">http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html</a><br> <br> Guitar Set up (acoustic and electronic) $40!<!-- END CLTAGS -->
+]]></description>
+		<dc:date>2011-11-04T09:35:17-07:00</dc:date>
+		<dc:language>en-us</dc:language>
+		<dc:rights>Copyright 2011 craigslist, inc.</dc:rights>
+		<dc:source>
+http://sfbay.craigslist.org/sby/muc/2681301534.html
+</dc:source>
+		<dc:title><![CDATA[ Music Equipment Repair and Consignment ]]></dc:title>
+		<dc:type>text</dc:type>
+		<dcterms:issued>2011-11-04T09:35:17-07:00</dcterms:issued>
+	</item>
+	<item rdf:about="http://sfbay.craigslist.org/eby/rid/2685010755.html">
+		<title><![CDATA[
+Ride Offered - Oakland/BART to LA/SFV - TODAY 3PM 11/04 (oakland north / temescal)
+]]></title>
+		<link>
+http://sfbay.craigslist.org/eby/rid/2685010755.html
+</link>
+		<description><![CDATA[
+Im offering a lift for up to two people from Oakland (or near any BART station in the East Bay/580/880 Corridor, or San Jose/Morgan Hill, Gilroy) to the San Fernando Valley / Los Angeles area. Specifically, Im leaving from Oakland between 2:30 and 3:00pm (this is flexible, but if I leave too late my girlfriend will kill me), and heading to Woodland Hills via the 580, I-5, 405, and 101.<!-- END CLTAGS -->
+]]></description>
+		<dc:date>2011-11-04T09:34:54-07:00</dc:date>
+		<dc:language>en-us</dc:language>
+		<dc:rights>Copyright 2011 craigslist, inc.</dc:rights>
+		<dc:source>
+http://sfbay.craigslist.org/eby/rid/2685010755.html
+</dc:source>
+		<dc:title><![CDATA[
+Ride Offered - Oakland/BART to LA/SFV - TODAY 3PM 11/04 (oakland north / temescal)
+]]></dc:title>
+		<dc:type>text</dc:type>
+		<dcterms:issued>2011-11-04T09:34:54-07:00</dcterms:issued>
+	</item>
+</rdf:RDF>
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Documents/RSS_Example.xml b/node_modules/htmlparser2/test/Documents/RSS_Example.xml
new file mode 100644
index 000000000..0d1fde875
--- /dev/null
+++ b/node_modules/htmlparser2/test/Documents/RSS_Example.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0"?>
+<!-- http://cyber.law.harvard.edu/rss/examples/rss2sample.xml -->
+<rss version="2.0">
+   <channel>
+      <title>Liftoff News</title>
+      <link>http://liftoff.msfc.nasa.gov/</link>
+      <description>Liftoff to Space Exploration.</description>
+      <language>en-us</language>
+      <pubDate>Tue, 10 Jun 2003 04:00:00 GMT</pubDate>
+
+      <lastBuildDate>Tue, 10 Jun 2003 09:41:01 GMT</lastBuildDate>
+      <docs>http://blogs.law.harvard.edu/tech/rss</docs>
+      <generator>Weblog Editor 2.0</generator>
+      <managingEditor>editor@example.com</managingEditor>
+      <webMaster>webmaster@example.com</webMaster>
+      <item>
+
+         <title>Star City</title>
+         <link>http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp</link>
+         <description>How do Americans get ready to work with Russians aboard the International Space Station? They take a crash course in culture, language and protocol at Russia's &lt;a href="http://howe.iki.rssi.ru/GCTC/gctc_e.htm"&gt;Star City&lt;/a&gt;.</description>
+         <pubDate>Tue, 03 Jun 2003 09:39:21 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/06/03.html#item573</guid>
+
+      </item>
+      <item>
+         <description>Sky watchers in Europe, Asia, and parts of Alaska and Canada will experience a &lt;a href="http://science.nasa.gov/headlines/y2003/30may_solareclipse.htm"&gt;partial eclipse of the Sun&lt;/a&gt; on Saturday, May 31st.</description>
+         <pubDate>Fri, 30 May 2003 11:06:42 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/05/30.html#item572</guid>
+
+      </item>
+      <item>
+         <title>The Engine That Does More</title>
+         <link>http://liftoff.msfc.nasa.gov/news/2003/news-VASIMR.asp</link>
+         <description>Before man travels to Mars, NASA hopes to design new engines that will let us fly through the Solar System more quickly.  The proposed VASIMR engine would do that.</description>
+         <pubDate>Tue, 27 May 2003 08:37:32 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/05/27.html#item571</guid>
+
+      </item>
+      <item>
+         <title>Astronauts' Dirty Laundry</title>
+         <link>http://liftoff.msfc.nasa.gov/news/2003/news-laundry.asp</link>
+         <description>Compared to earlier spacecraft, the International Space Station has many luxuries, but laundry facilities are not one of them.  Instead, astronauts have other options.</description>
+         <pubDate>Tue, 20 May 2003 08:56:02 GMT</pubDate>
+         <guid>http://liftoff.msfc.nasa.gov/2003/05/20.html#item570</guid>
+
+      </item>
+   </channel>
+</rss>
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/01-simple.json b/node_modules/htmlparser2/test/Events/01-simple.json
new file mode 100644
index 000000000..ab3076ac5
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/01-simple.json
@@ -0,0 +1,44 @@
+{
+  "name": "simple",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<h1 class=test>adsf</h1>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "h1"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "test"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "h1",
+        {
+          "class": "test"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "adsf"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "h1"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/02-template.json b/node_modules/htmlparser2/test/Events/02-template.json
new file mode 100644
index 000000000..df344b6a2
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/02-template.json
@@ -0,0 +1,63 @@
+{
+  "name": "Template script tags",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<p><script type=\"text/template\"><h1>Heading1</h1></script></p>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "p"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "p",
+        {}
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "script"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "type",
+        "text/template"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "script",
+        {
+          "type": "text/template"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "<h1>Heading1</h1>"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "script"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "p"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/03-lowercase_tags.json b/node_modules/htmlparser2/test/Events/03-lowercase_tags.json
new file mode 100644
index 000000000..9b58c5999
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/03-lowercase_tags.json
@@ -0,0 +1,46 @@
+{
+  "name": "Lowercase tags",
+  "options": {
+    "handler": {},
+    "parser": {
+      "lowerCaseTags": true
+    }
+  },
+  "html": "<H1 class=test>adsf</H1>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "h1"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "test"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "h1",
+        {
+          "class": "test"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "adsf"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "h1"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/04-cdata.json b/node_modules/htmlparser2/test/Events/04-cdata.json
new file mode 100644
index 000000000..71d4860c9
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/04-cdata.json
@@ -0,0 +1,43 @@
+{
+  "name": "CDATA",
+  "options": {
+    "handler": {},
+    "parser": {"xmlMode": true}
+  },
+  "html": "<tag><![CDATA[ asdf ><asdf></adsf><> fo]]></tag>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "tag"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "tag",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        " asdf ><asdf></adsf><> fo"
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "tag"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/05-cdata-special.json b/node_modules/htmlparser2/test/Events/05-cdata-special.json
new file mode 100644
index 000000000..686cb1a2f
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/05-cdata-special.json
@@ -0,0 +1,35 @@
+{
+  "name": "CDATA (inside special)",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<script>/*<![CDATA[*/ asdf ><asdf></adsf><> fo/*]]>*/</script>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "script"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "script",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "/*<![CDATA[*/ asdf ><asdf></adsf><> fo/*]]>*/"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "script"
+      ]
+    }
+  ]
+}
diff --git a/node_modules/htmlparser2/test/Events/06-leading-lt.json b/node_modules/htmlparser2/test/Events/06-leading-lt.json
new file mode 100644
index 000000000..fcec85289
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/06-leading-lt.json
@@ -0,0 +1,16 @@
+{
+  "name": "leading lt",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": ">a>",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        ">a>"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/07-self-closing.json b/node_modules/htmlparser2/test/Events/07-self-closing.json
new file mode 100644
index 000000000..f8903aa69
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/07-self-closing.json
@@ -0,0 +1,67 @@
+{
+    "name": "Self-closing tags",
+    "options": {
+        "handler": {
+
+            },
+        "parser": {
+
+            }
+    },
+    "html": "<a href=http://test.com/>Foo</a><hr />",
+    "expected": [
+		{
+			"event": "opentagname",
+			"data": [
+				"a"
+			]
+		},
+		{
+			"event": "attribute",
+			"data": [
+				"href",
+				"http://test.com/"
+			]
+		},
+		{
+			"event": "opentag",
+			"data": [
+				"a",
+				{
+					"href": "http://test.com/"
+				}
+			]
+		},
+		{
+			"event": "text",
+			"data": [
+				"Foo"
+			]
+		},
+		{
+			"event": "closetag",
+			"data": [
+				"a"
+			]
+		},
+		{
+			"event": "opentagname",
+			"data": [
+				"hr"
+			]
+		},
+		{
+			"event": "opentag",
+			"data": [
+				"hr",
+				{}
+			]
+		},
+		{
+			"event": "closetag",
+			"data": [
+				"hr"
+			]
+		}
+	]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/08-implicit-close-tags.json b/node_modules/htmlparser2/test/Events/08-implicit-close-tags.json
new file mode 100644
index 000000000..3441f2088
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/08-implicit-close-tags.json
@@ -0,0 +1,59 @@
+{
+  "name": "Implicit close tags",
+  "options": {},
+  "html": "<ol><li class=test><div><table style=width:100%><tr><td colspan=2><h3>Heading</h3><tr><td><div>Div</div><td><div>Div2</div></table></div><li><div><h3>Heading 2</h3></div></li></ol>",
+  "expected": [
+    { "event": "opentagname", "data": [ "ol" ] },
+    { "event": "opentag", "data": [ "ol", {} ] },
+    { "event": "opentagname", "data": [ "li" ] },
+    { "event": "attribute", "data": [ "class", "test" ] },
+    { "event": "opentag", "data": [ "li", { "class": "test" } ] },
+    { "event": "opentagname", "data": [ "div" ] },
+    { "event": "opentag", "data": [ "div", {} ] },
+    { "event": "opentagname", "data": [ "table" ] },
+    { "event": "attribute", "data": [ "style", "width:100%" ] },
+    { "event": "opentag", "data": [ "table", { "style": "width:100%" } ] },
+    { "event": "opentagname", "data": [ "tr" ] },
+    { "event": "opentag", "data": [ "tr", {} ] },
+    { "event": "opentagname", "data": [ "td" ] },
+    { "event": "attribute", "data": [ "colspan", "2" ] },
+    { "event": "opentag", "data": [ "td", { "colspan": "2" } ] },
+    { "event": "opentagname", "data": [ "h3" ] },
+    { "event": "opentag", "data": [ "h3", {} ] },
+    { "event": "text", "data": [ "Heading" ] },
+    { "event": "closetag", "data": [ "h3" ] },
+    { "event": "closetag", "data": [ "td" ] },
+    { "event": "closetag", "data": [ "tr" ] },
+    { "event": "opentagname", "data": [ "tr" ] },
+    { "event": "opentag", "data": [ "tr", {} ] },
+    { "event": "opentagname", "data": [ "td" ] },
+    { "event": "opentag", "data": [ "td", {} ] },
+    { "event": "opentagname", "data": [ "div" ] },
+    { "event": "opentag", "data": [ "div", {} ] },
+    { "event": "text", "data": [ "Div" ] },
+    { "event": "closetag", "data": [ "div" ] },
+    { "event": "closetag", "data": [ "td" ] },
+    { "event": "opentagname", "data": [ "td" ] },
+    { "event": "opentag", "data": [ "td", {} ] },
+    { "event": "opentagname", "data": [ "div" ] },
+    { "event": "opentag", "data": [ "div", {} ] },
+    { "event": "text", "data": [ "Div2" ] },
+    { "event": "closetag", "data": [ "div" ] },
+    { "event": "closetag", "data": [ "td" ] },
+    { "event": "closetag", "data": [ "tr" ] },
+    { "event": "closetag", "data": [ "table" ] },
+    { "event": "closetag", "data": [ "div" ] },
+    { "event": "closetag", "data": [ "li" ] },
+    { "event": "opentagname", "data": [ "li" ] },
+    { "event": "opentag", "data": [ "li", {} ] },
+    { "event": "opentagname", "data": [ "div" ] },
+    { "event": "opentag", "data": [ "div", {} ] },
+    { "event": "opentagname", "data": [ "h3" ] },
+    { "event": "opentag", "data": [ "h3", {} ] },
+    { "event": "text", "data": [ "Heading 2" ] },
+    { "event": "closetag", "data": [ "h3" ] },
+    { "event": "closetag", "data": [ "div" ] },
+    { "event": "closetag", "data": [ "li" ] },
+    { "event": "closetag", "data": [ "ol" ] }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/09-attributes.json b/node_modules/htmlparser2/test/Events/09-attributes.json
new file mode 100644
index 000000000..afa6e4a96
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/09-attributes.json
@@ -0,0 +1,68 @@
+{
+  "name": "attributes (no white space, no value, no quotes)",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<button class=\"test0\"title=\"test1\" disabled value=test2>adsf</button>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "test0"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "title",
+        "test1"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "disabled",
+        ""
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "value",
+        "test2"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "button",
+        {
+          "class": "test0",
+          "title": "test1",
+          "disabled": "",
+          "value": "test2"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "adsf"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "button"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/10-crazy-attrib.json b/node_modules/htmlparser2/test/Events/10-crazy-attrib.json
new file mode 100644
index 000000000..baf319f43
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/10-crazy-attrib.json
@@ -0,0 +1,52 @@
+{
+  "name": "crazy attribute",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<p <='' FAIL>stuff</p>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "p"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "<",
+        ""
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "fail",
+        ""
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "p",
+        {
+          "<": "",
+          "fail": ""
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "stuff"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "p"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/11-script_in_script.json b/node_modules/htmlparser2/test/Events/11-script_in_script.json
new file mode 100644
index 000000000..ddbb87c87
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/11-script_in_script.json
@@ -0,0 +1,54 @@
+{
+  "name": "Scripts creating other scripts",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<p><script>var str = '<script></'+'script>';</script></p>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "p"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "p",
+        {}
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "script"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "script",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "var str = '<script></'+'script>';"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "script"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "p"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/12-long-comment-end.json b/node_modules/htmlparser2/test/Events/12-long-comment-end.json
new file mode 100644
index 000000000..e81f30774
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/12-long-comment-end.json
@@ -0,0 +1,20 @@
+{
+  "name": "Long comment ending",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<meta id='before'><!-- text ---><meta id='after'>",
+  "expected": [
+  { "event": "opentagname", "data": [ "meta" ] },
+  { "event": "attribute",   "data": [ "id", "before" ] },
+  { "event": "opentag",     "data": [ "meta", {"id": "before"} ] },
+  { "event": "closetag",    "data": [ "meta" ] },
+  { "event": "comment",     "data": [ " text -" ] },
+  { "event": "commentend",  "data": [] },
+  { "event": "opentagname", "data": [ "meta" ] },
+  { "event": "attribute",   "data": [ "id", "after" ] },
+  { "event": "opentag",     "data": [ "meta", {"id": "after"} ] },
+  { "event": "closetag",    "data": [ "meta" ] }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/13-long-cdata-end.json b/node_modules/htmlparser2/test/Events/13-long-cdata-end.json
new file mode 100644
index 000000000..34b7b4105
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/13-long-cdata-end.json
@@ -0,0 +1,22 @@
+{
+  "name": "Long CDATA ending",
+  "options": {
+    "handler": {},
+    "parser": {"xmlMode": true}
+  },
+  "html": "<before /><tag><![CDATA[ text ]]]></tag><after />",
+  "expected": [
+  { "event": "opentagname", "data": [ "before" ] },
+  { "event": "opentag",     "data": [ "before", {} ] },
+  { "event": "closetag",    "data": [ "before" ] },
+  { "event": "opentagname", "data": [ "tag" ] },
+  { "event": "opentag",     "data": [ "tag", {} ] },
+  { "event": "cdatastart",  "data": [] },
+  { "event": "text",        "data": [ " text ]" ] },
+  { "event": "cdataend",    "data": [] },
+  { "event": "closetag",    "data": [ "tag" ] },
+  { "event": "opentagname", "data": [ "after" ] },
+  { "event": "opentag",     "data": [ "after", {} ] },
+  { "event": "closetag",    "data": [ "after" ] }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/14-implicit-open-tags.json b/node_modules/htmlparser2/test/Events/14-implicit-open-tags.json
new file mode 100644
index 000000000..096925ae9
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/14-implicit-open-tags.json
@@ -0,0 +1,24 @@
+{
+  "name": "Implicit open p and br tags",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<div>Hallo</p>World</br></div></p>",
+  "expected": [
+  	{ "event": "opentagname", "data": [ "div" ] },
+  	{ "event": "opentag",     "data": [ "div", {} ] },
+  	{ "event": "text",        "data": [ "Hallo" ] },
+  	{ "event": "opentagname", "data": [ "p" ] },
+  	{ "event": "opentag",     "data": [ "p", {} ] },
+  	{ "event": "closetag",    "data": [ "p" ] },
+  	{ "event": "text",        "data": [ "World" ] },
+  	{ "event": "opentagname", "data": [ "br" ] },
+  	{ "event": "opentag",     "data": [ "br", {} ] },
+  	{ "event": "closetag",    "data": [ "br" ] },
+  	{ "event": "closetag",    "data": [ "div" ] },
+  	{ "event": "opentagname", "data": [ "p" ] },
+  	{ "event": "opentag",     "data": [ "p", {} ] },
+  	{ "event": "closetag",    "data": [ "p" ] }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/15-lt-whitespace.json b/node_modules/htmlparser2/test/Events/15-lt-whitespace.json
new file mode 100644
index 000000000..aae6eb097
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/15-lt-whitespace.json
@@ -0,0 +1,16 @@
+{
+  "name": "lt followed by whitespace",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "a < b",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "a < b"
+      ]
+    }
+  ]
+}
diff --git a/node_modules/htmlparser2/test/Events/16-double_attribs.json b/node_modules/htmlparser2/test/Events/16-double_attribs.json
new file mode 100644
index 000000000..bed1d8f22
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/16-double_attribs.json
@@ -0,0 +1,45 @@
+{
+  "name": "double attribute",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<h1 class=test class=boo></h1>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "h1"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "test"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "boo"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "h1",
+        {
+          "class": "test"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "h1"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/17-numeric_entities.json b/node_modules/htmlparser2/test/Events/17-numeric_entities.json
new file mode 100644
index 000000000..c76221c0e
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/17-numeric_entities.json
@@ -0,0 +1,16 @@
+{
+  "name": "numeric entities",
+  "options": {
+    "handler": {},
+    "parser": {"decodeEntities": true}
+  },
+  "html": "&#x61;&#x62&#99;&#100",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "abcd"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/18-legacy_entities.json b/node_modules/htmlparser2/test/Events/18-legacy_entities.json
new file mode 100644
index 000000000..e0be6990b
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/18-legacy_entities.json
@@ -0,0 +1,16 @@
+{
+  "name": "legacy entities",
+  "options": {
+    "handler": {},
+    "parser": {"decodeEntities": true}
+  },
+  "html": "&AMPel&iacutees&lter",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "&el\u00EDes<er"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/19-named_entities.json b/node_modules/htmlparser2/test/Events/19-named_entities.json
new file mode 100644
index 000000000..33db898e0
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/19-named_entities.json
@@ -0,0 +1,16 @@
+{
+  "name": "named entities",
+  "options": {
+    "handler": {},
+    "parser": {"decodeEntities": true}
+  },
+  "html": "&amp;el&lt;er&CounterClockwiseContourIntegral;foo",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "&el<er\u2233foo"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/20-xml_entities.json b/node_modules/htmlparser2/test/Events/20-xml_entities.json
new file mode 100644
index 000000000..0f7dece27
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/20-xml_entities.json
@@ -0,0 +1,16 @@
+{
+  "name": "xml entities",
+  "options": {
+    "handler": {},
+    "parser": {"decodeEntities": true, "xmlMode": true}
+  },
+  "html": "&amp;&gt;&amp&lt;&uuml;&#x61;&#x62&#99;&#100",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "&>&amp<&uuml;a&#x62c&#100"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/21-entity_in_attribute.json b/node_modules/htmlparser2/test/Events/21-entity_in_attribute.json
new file mode 100644
index 000000000..77eb4f363
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/21-entity_in_attribute.json
@@ -0,0 +1,38 @@
+{
+  "name": "entity in attribute",
+  "options": {
+    "handler": {},
+    "parser": {"decodeEntities": true}
+  },
+  "html": "<a href='http://example.com/p&#x61;ge?param=value&param2=&lt;val'>",
+  "expected": [
+    {
+      "event": "opentagname",
+      "data": [
+        "a"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.com/page?param=value&param2=<val"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "a",
+        {
+          "href": "http://example.com/page?param=value&param2=<val"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "a"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Events/22-double_brackets.json b/node_modules/htmlparser2/test/Events/22-double_brackets.json
new file mode 100644
index 000000000..38a513b77
--- /dev/null
+++ b/node_modules/htmlparser2/test/Events/22-double_brackets.json
@@ -0,0 +1,41 @@
+{
+  "name": "double brackets",
+  "options": {
+    "handler": {},
+    "parser": {}
+  },
+  "html": "<<princess-purpose>>testing</princess-purpose>",
+  "expected": [
+    {
+      "event": "text",
+      "data": [
+        "<"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "princess-purpose"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "princess-purpose",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        ">testing"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "princess-purpose"
+      ]
+    }
+  ]
+}
diff --git a/node_modules/htmlparser2/test/Feeds/01-rss.js b/node_modules/htmlparser2/test/Feeds/01-rss.js
new file mode 100644
index 000000000..a3aae479b
--- /dev/null
+++ b/node_modules/htmlparser2/test/Feeds/01-rss.js
@@ -0,0 +1,34 @@
+exports.name = "RSS (2.0)";
+exports.file = "/RSS_Example.xml";
+exports.expected = {
+	type: "rss",
+	id: "",
+	title: "Liftoff News",
+	link: "http://liftoff.msfc.nasa.gov/",
+	description: "Liftoff to Space Exploration.",
+	updated: new Date("Tue, 10 Jun 2003 09:41:01 GMT"),
+	author: "editor@example.com",
+	items: [{
+		id: "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573",
+		title: "Star City",
+		link: "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp",
+		description: "How do Americans get ready to work with Russians aboard the International Space Station? They take a crash course in culture, language and protocol at Russia's &lt;a href=\"http://howe.iki.rssi.ru/GCTC/gctc_e.htm\"&gt;Star City&lt;/a&gt;.",
+		pubDate: new Date("Tue, 03 Jun 2003 09:39:21 GMT")
+	}, {
+		id: "http://liftoff.msfc.nasa.gov/2003/05/30.html#item572",
+		description: "Sky watchers in Europe, Asia, and parts of Alaska and Canada will experience a &lt;a href=\"http://science.nasa.gov/headlines/y2003/30may_solareclipse.htm\"&gt;partial eclipse of the Sun&lt;/a&gt; on Saturday, May 31st.",
+		pubDate: new Date("Fri, 30 May 2003 11:06:42 GMT")
+	}, {
+		id: "http://liftoff.msfc.nasa.gov/2003/05/27.html#item571",
+		title: "The Engine That Does More",
+		link: "http://liftoff.msfc.nasa.gov/news/2003/news-VASIMR.asp",
+		description: "Before man travels to Mars, NASA hopes to design new engines that will let us fly through the Solar System more quickly.  The proposed VASIMR engine would do that.",
+		pubDate: new Date("Tue, 27 May 2003 08:37:32 GMT")
+	}, {
+		id: "http://liftoff.msfc.nasa.gov/2003/05/20.html#item570",
+		title: "Astronauts' Dirty Laundry",
+		link: "http://liftoff.msfc.nasa.gov/news/2003/news-laundry.asp",
+		description: "Compared to earlier spacecraft, the International Space Station has many luxuries, but laundry facilities are not one of them.  Instead, astronauts have other options.",
+		pubDate: new Date("Tue, 20 May 2003 08:56:02 GMT")
+	}]
+};
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Feeds/02-atom.js b/node_modules/htmlparser2/test/Feeds/02-atom.js
new file mode 100644
index 000000000..92b6de336
--- /dev/null
+++ b/node_modules/htmlparser2/test/Feeds/02-atom.js
@@ -0,0 +1,18 @@
+exports.name = "Atom (1.0)";
+exports.file = "/Atom_Example.xml";
+exports.expected = {
+	type: "atom",
+	id: "urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6",
+	title: "Example Feed",
+	link: "http://example.org/feed/",
+	description: "A subtitle.",
+	updated: new Date("2003-12-13T18:30:02Z"),
+	author: "johndoe@example.com",
+	items: [{
+		id: "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
+		title: "Atom-Powered Robots Run Amok",
+		link: "http://example.org/2003/12/13/atom03",
+		description: "Some text.",
+		pubDate: new Date("2003-12-13T18:30:02Z")
+	}]
+};
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Feeds/03-rdf.js b/node_modules/htmlparser2/test/Feeds/03-rdf.js
new file mode 100644
index 000000000..0f1cbc41c
--- /dev/null
+++ b/node_modules/htmlparser2/test/Feeds/03-rdf.js
@@ -0,0 +1,20 @@
+exports.name = "RDF test";
+exports.file = "/RDF_Example.xml";
+exports.expected = {
+  "type": "rdf",
+  "id": "",
+  "title": "craigslist | all community in SF bay area",
+  "link": "http://sfbay.craigslist.org/ccc/",
+  "items": [
+    {
+      "title": "Music Equipment Repair and Consignment",
+      "link": "http://sfbay.craigslist.org/sby/muc/2681301534.html",
+      "description": "San Jose Rock Shop offers musical instrument repair and consignment! (408) 215-2065<br> <br> We are pleased to announce our NEW LOCATION: 1199 N 5th st. San Jose, ca 95112. Please call ahead, by appointment only.<br> <br> Recently featured by Metro Newspaper in their 2011 Best of the Silicon Valley edition see it online here:<br> <a href=\"http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html\" rel=\"nofollow\">http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html</a><br> <br> Guitar Set up (acoustic and electronic) $40!<!-- END CLTAGS -->"
+    },
+    {
+      "title": "Ride Offered - Oakland/BART to LA/SFV - TODAY 3PM 11/04 (oakland north / temescal)",
+      "link": "http://sfbay.craigslist.org/eby/rid/2685010755.html",
+      "description": "Im offering a lift for up to two people from Oakland (or near any BART station in the East Bay/580/880 Corridor, or San Jose/Morgan Hill, Gilroy) to the San Fernando Valley / Los Angeles area. Specifically, Im leaving from Oakland between 2:30 and 3:00pm (this is flexible, but if I leave too late my girlfriend will kill me), and heading to Woodland Hills via the 580, I-5, 405, and 101.<!-- END CLTAGS -->"
+    }
+  ]
+};
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Stream/01-basic.json b/node_modules/htmlparser2/test/Stream/01-basic.json
new file mode 100644
index 000000000..e0766e791
--- /dev/null
+++ b/node_modules/htmlparser2/test/Stream/01-basic.json
@@ -0,0 +1,83 @@
+{
+  "name": "Basic html",
+  "options": {},
+  "file": "Basic.html",
+  "expected": [
+    {
+      "event": "processinginstruction",
+      "data": [
+        "!doctype",
+        "!DOCTYPE html"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "html",
+        {}
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "The Title"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "body"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "body",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Hello world"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "body"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "html"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Stream/02-RSS.json b/node_modules/htmlparser2/test/Stream/02-RSS.json
new file mode 100644
index 000000000..0d5921cec
--- /dev/null
+++ b/node_modules/htmlparser2/test/Stream/02-RSS.json
@@ -0,0 +1,1093 @@
+{
+  "name": "RSS feed",
+  "options": {"xmlMode": true},
+  "file": "RSS_Example.xml",
+  "expected": [
+    {
+      "event": "processinginstruction",
+      "data": [
+        "?xml",
+        "?xml version=\"1.0\"?"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "comment",
+      "data": [
+        " http://cyber.law.harvard.edu/rss/examples/rss2sample.xml "
+      ]
+    },
+    {
+      "event": "commentend",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "rss"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "version",
+        "2.0"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "rss",
+        {
+          "version": "2.0"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n   "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "channel"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "channel",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Liftoff News"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Liftoff to Space Exploration."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "language"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "language",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "en-us"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "language"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "pubDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Tue, 10 Jun 2003 04:00:00 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "lastBuildDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "lastBuildDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Tue, 10 Jun 2003 09:41:01 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "lastBuildDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "docs"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "docs",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://blogs.law.harvard.edu/tech/rss"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "docs"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "generator"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "generator",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Weblog Editor 2.0"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "generator"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "managingEditor"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "managingEditor",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "editor@example.com"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "managingEditor"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "webMaster"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "webMaster",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "webmaster@example.com"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "webMaster"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Star City"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "How do Americans get ready to work with Russians aboard the International Space Station? They take a crash course in culture, language and protocol at Russia's &lt;a href=\"http://howe.iki.rssi.ru/GCTC/gctc_e.htm\"&gt;Star City&lt;/a&gt;."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "pubDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Tue, 03 Jun 2003 09:39:21 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "guid",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n      "
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Sky watchers in Europe, Asia, and parts of Alaska and Canada will experience a &lt;a href=\"http://science.nasa.gov/headlines/y2003/30may_solareclipse.htm\"&gt;partial eclipse of the Sun&lt;/a&gt; on Saturday, May 31st."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "pubDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Fri, 30 May 2003 11:06:42 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "guid",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/2003/05/30.html#item572"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n      "
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "The Engine That Does More"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/news/2003/news-VASIMR.asp"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Before man travels to Mars, NASA hopes to design new engines that will let us fly through the Solar System more quickly.  The proposed VASIMR engine would do that."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "pubDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Tue, 27 May 2003 08:37:32 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "guid",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/2003/05/27.html#item571"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n      "
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n      "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Astronauts' Dirty Laundry"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/news/2003/news-laundry.asp"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Compared to earlier spacecraft, the International Space Station has many luxuries, but laundry facilities are not one of them.  Instead, astronauts have other options."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "pubDate",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Tue, 20 May 2003 08:56:02 GMT"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "pubDate"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n         "
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "guid",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://liftoff.msfc.nasa.gov/2003/05/20.html#item570"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "guid"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n      "
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n   "
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "channel"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "rss"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Stream/03-Atom.json b/node_modules/htmlparser2/test/Stream/03-Atom.json
new file mode 100644
index 000000000..4c81b24fe
--- /dev/null
+++ b/node_modules/htmlparser2/test/Stream/03-Atom.json
@@ -0,0 +1,644 @@
+{
+  "name": "Atom feed",
+  "options": {"xmlMode": true},
+  "file": "Atom_Example.xml",
+  "expected": [
+    {
+      "event": "processinginstruction",
+      "data": [
+        "?xml",
+        "?xml version=\"1.0\" encoding=\"utf-8\"?"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "comment",
+      "data": [
+        " http://en.wikipedia.org/wiki/Atom_%28standard%29 "
+      ]
+    },
+    {
+      "event": "commentend",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "feed"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns",
+        "http://www.w3.org/2005/Atom"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "feed",
+        {
+          "xmlns": "http://www.w3.org/2005/Atom"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Example Feed"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "subtitle"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "subtitle",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "A subtitle."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "subtitle"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.org/feed/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rel",
+        "self"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {
+          "href": "http://example.org/feed/",
+          "rel": "self"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.org/"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {
+          "href": "http://example.org/"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "id"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "id",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "urn:uuid:60a76c80-d399-11d9-b91C-0003939e0af6"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "id"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "updated"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "updated",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2003-12-13T18:30:02Z"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "updated"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "author"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "author",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "name"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "name",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "John Doe"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "name"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "email"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "email",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "johndoe@example.com"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "email"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "author"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "entry"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "entry",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Atom-Powered Robots Run Amok"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.org/2003/12/13/atom03"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {
+          "href": "http://example.org/2003/12/13/atom03"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rel",
+        "alternate"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "type",
+        "text/html"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.org/2003/12/13/atom03.html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {
+          "rel": "alternate",
+          "type": "text/html",
+          "href": "http://example.org/2003/12/13/atom03.html"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rel",
+        "edit"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "href",
+        "http://example.org/2003/12/13/atom03/edit"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {
+          "rel": "edit",
+          "href": "http://example.org/2003/12/13/atom03/edit"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "id"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "id",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "id"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "updated"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "updated",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2003-12-13T18:30:02Z"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "updated"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "summary"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "summary",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Some text."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "summary"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "entry"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "feed"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Stream/04-RDF.json b/node_modules/htmlparser2/test/Stream/04-RDF.json
new file mode 100644
index 000000000..7ebf5161f
--- /dev/null
+++ b/node_modules/htmlparser2/test/Stream/04-RDF.json
@@ -0,0 +1,1399 @@
+{
+  "name": "RDF feed",
+  "options": {"xmlMode": true},
+  "file": "RDF_Example.xml",
+  "expected": [
+    {
+      "event": "processinginstruction",
+      "data": [
+        "?xml",
+        "?xml version=\"1.0\" encoding=\"UTF-8\"?"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "rdf:RDF"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:rdf",
+        "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns",
+        "http://purl.org/rss/1.0/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:ev",
+        "http://purl.org/rss/1.0/modules/event/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:content",
+        "http://purl.org/rss/1.0/modules/content/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:taxo",
+        "http://purl.org/rss/1.0/modules/taxonomy/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:dc",
+        "http://purl.org/dc/elements/1.1/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:syn",
+        "http://purl.org/rss/1.0/modules/syndication/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:dcterms",
+        "http://purl.org/dc/terms/"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "xmlns:admin",
+        "http://webns.net/mvcb/"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "rdf:RDF",
+        {
+          "xmlns:rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+          "xmlns": "http://purl.org/rss/1.0/",
+          "xmlns:ev": "http://purl.org/rss/1.0/modules/event/",
+          "xmlns:content": "http://purl.org/rss/1.0/modules/content/",
+          "xmlns:taxo": "http://purl.org/rss/1.0/modules/taxonomy/",
+          "xmlns:dc": "http://purl.org/dc/elements/1.1/",
+          "xmlns:syn": "http://purl.org/rss/1.0/modules/syndication/",
+          "xmlns:dcterms": "http://purl.org/dc/terms/",
+          "xmlns:admin": "http://webns.net/mvcb/"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "channel"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rdf:about",
+        "http://sfbay.craigslist.org/ccc/"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "channel",
+        {
+          "rdf:about": "http://sfbay.craigslist.org/ccc/"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "craigslist | all community in SF bay area"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://sfbay.craigslist.org/ccc/"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:language",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "en-us"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:rights",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Copyright 2011 craigslist, inc."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:publisher"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:publisher",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "webmaster@craigslist.org"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:publisher"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:creator"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:creator",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "webmaster@craigslist.org"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:creator"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:source",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "http://sfbay.craigslist.org/ccc//"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "craigslist | all community in SF bay area"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:type",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Collection"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "syn:updateBase"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "syn:updateBase",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2011-11-04T09:39:10-07:00"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "syn:updateBase"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "syn:updateFrequency"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "syn:updateFrequency",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "4"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "syn:updateFrequency"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "syn:updatePeriod"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "syn:updatePeriod",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "hourly"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "syn:updatePeriod"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "items"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "items",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "rdf:Seq"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "rdf:Seq",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "rdf:li"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rdf:resource",
+        "http://sfbay.craigslist.org/sby/muc/2681301534.html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "rdf:li",
+        {
+          "rdf:resource": "http://sfbay.craigslist.org/sby/muc/2681301534.html"
+        }
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "rdf:li"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "rdf:Seq"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "items"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "channel"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rdf:about",
+        "http://sfbay.craigslist.org/sby/muc/2681301534.html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {
+          "rdf:about": "http://sfbay.craigslist.org/sby/muc/2681301534.html"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        " Music Equipment Repair and Consignment "
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nhttp://sfbay.craigslist.org/sby/muc/2681301534.html\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nSan Jose Rock Shop offers musical instrument repair and consignment! (408) 215-2065<br> <br> We are pleased to announce our NEW LOCATION: 1199 N 5th st. San Jose, ca 95112. Please call ahead, by appointment only.<br> <br> Recently featured by Metro Newspaper in their 2011 Best of the Silicon Valley edition see it online here:<br> <a href=\"http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html\" rel=\"nofollow\">http://www.metroactive.com/best-of-silicon-valley/2011/music-nightlife/editor-picks.html</a><br> <br> Guitar Set up (acoustic and electronic) $40!<!-- END CLTAGS -->\n"
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:date"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:date",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2011-11-04T09:35:17-07:00"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:date"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:language",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "en-us"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:rights",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Copyright 2011 craigslist, inc."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:source",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nhttp://sfbay.craigslist.org/sby/muc/2681301534.html\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:title",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        " Music Equipment Repair and Consignment "
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:type",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "text"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dcterms:issued"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dcterms:issued",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2011-11-04T09:35:17-07:00"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dcterms:issued"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "rdf:about",
+        "http://sfbay.craigslist.org/eby/rid/2685010755.html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "item",
+        {
+          "rdf:about": "http://sfbay.craigslist.org/eby/rid/2685010755.html"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nRide Offered - Oakland/BART to LA/SFV - TODAY 3PM 11/04 (oakland north / temescal)\n"
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "link",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nhttp://sfbay.craigslist.org/eby/rid/2685010755.html\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "link"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "description",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nIm offering a lift for up to two people from Oakland (or near any BART station in the East Bay/580/880 Corridor, or San Jose/Morgan Hill, Gilroy) to the San Fernando Valley / Los Angeles area. Specifically, Im leaving from Oakland between 2:30 and 3:00pm (this is flexible, but if I leave too late my girlfriend will kill me), and heading to Woodland Hills via the 580, I-5, 405, and 101.<!-- END CLTAGS -->\n"
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "description"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:date"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:date",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2011-11-04T09:34:54-07:00"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:date"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:language",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "en-us"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:language"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:rights",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Copyright 2011 craigslist, inc."
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:rights"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:source",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nhttp://sfbay.craigslist.org/eby/rid/2685010755.html\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:source"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:title",
+        {}
+      ]
+    },
+    {
+      "event": "cdatastart",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\nRide Offered - Oakland/BART to LA/SFV - TODAY 3PM 11/04 (oakland north / temescal)\n"
+      ]
+    },
+    {
+      "event": "cdataend",
+      "data": []
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dc:type",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "text"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dc:type"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "dcterms:issued"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "dcterms:issued",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "2011-11-04T09:34:54-07:00"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "dcterms:issued"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "item"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "rdf:RDF"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/Stream/05-Attributes.json b/node_modules/htmlparser2/test/Stream/05-Attributes.json
new file mode 100644
index 000000000..ad364c048
--- /dev/null
+++ b/node_modules/htmlparser2/test/Stream/05-Attributes.json
@@ -0,0 +1,354 @@
+{
+  "name": "Attributes",
+  "options": {},
+  "file": "Attributes.html",
+  "expected": [
+    {
+      "event": "processinginstruction",
+      "data": [
+        "!doctype",
+        "!doctype html"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "html"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "html",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "head"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "head",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "title",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "Attributes test"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "title"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "head"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "body"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "body",
+        {}
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "comment",
+      "data": [
+        " Normal attributes "
+      ]
+    },
+    {
+      "event": "commentend",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "id",
+        "test0"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "value0"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "title",
+        "value1"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "button",
+        {
+          "id": "test0",
+          "class": "value0",
+          "title": "value1"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "class=\"value0\" title=\"value1\""
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n\t"
+      ]
+    },
+    {
+      "event": "comment",
+      "data": [
+        " Attributes with no quotes or value "
+      ]
+    },
+    {
+      "event": "commentend",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "id",
+        "test1"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "value2"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "disabled",
+        ""
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "button",
+        {
+          "id": "test1",
+          "class": "value2",
+          "disabled": ""
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "class=value2 disabled"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\n\t"
+      ]
+    },
+    {
+      "event": "comment",
+      "data": [
+        " Attributes with no space between them. No valid, but accepted by the browser "
+      ]
+    },
+    {
+      "event": "commentend",
+      "data": []
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n\t"
+      ]
+    },
+    {
+      "event": "opentagname",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "id",
+        "test2"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "class",
+        "value4"
+      ]
+    },
+    {
+      "event": "attribute",
+      "data": [
+        "title",
+        "value5"
+      ]
+    },
+    {
+      "event": "opentag",
+      "data": [
+        "button",
+        {
+          "id": "test2",
+          "class": "value4",
+          "title": "value5"
+        }
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "class=\"value4\"title=\"value5\""
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "button"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "body"
+      ]
+    },
+    {
+      "event": "text",
+      "data": [
+        "\n"
+      ]
+    },
+    {
+      "event": "closetag",
+      "data": [
+        "html"
+      ]
+    }
+  ]
+}
+\ No newline at end of file
diff --git a/node_modules/htmlparser2/test/test-helper.js b/node_modules/htmlparser2/test/test-helper.js
new file mode 100644
index 000000000..5111259b2
--- /dev/null
+++ b/node_modules/htmlparser2/test/test-helper.js
@@ -0,0 +1,81 @@
+var htmlparser2 = require(".."),
+    fs = require("fs"),
+    path = require("path"),
+    assert = require("assert"),
+	Parser = htmlparser2.Parser,
+	CollectingHandler = htmlparser2.CollectingHandler;
+
+exports.writeToParser = function(handler, options, data){
+	var parser = new Parser(handler, options);
+	//first, try to run the test via chunks
+	for(var i = 0; i < data.length; i++){
+		parser.write(data.charAt(i));
+	}
+	parser.end();
+	//then parse everything
+	parser.parseComplete(data);
+};
+
+//returns a tree structure
+exports.getEventCollector = function(cb){
+	var handler = new CollectingHandler({onerror: cb, onend: function(){
+		cb(null, handler.events.reduce(eventReducer, []));
+	}});
+
+	return handler;
+};
+
+function eventReducer(events, arr){
+	if(arr[0] === "onerror" || arr[0] === "onend");
+	else if(arr[0] === "ontext" && events.length && events[events.length-1].event === "text"){
+		events[events.length-1].data[0] += arr[1];
+	} else {
+		events.push({
+			event: arr[0].substr(2),
+			data: arr.slice(1)
+		});
+	}
+
+	return events;
+}
+
+function getCallback(expected, done){
+	var repeated = false;
+
+	return function(err, actual){
+		assert.ifError(err);
+		try {
+			assert.deepEqual(expected, actual, "didn't get expected output");
+		} catch(e){
+			e.expected = JSON.stringify(expected, null, 2);
+			e.actual = JSON.stringify(actual, null, 2);
+			throw e;
+		}
+
+		if(repeated) done();
+		else repeated = true;
+	};
+}
+
+exports.mochaTest = function(name, root, test){
+	describe(name, readDir);
+
+	function readDir(cb){
+		var dir = path.join(root, name);
+
+		fs
+		.readdirSync(dir)
+		.filter(RegExp.prototype.test, /^[^\._]/) //ignore all files with a leading dot or underscore
+		.map(function(name){
+			return path.join(dir, name);
+		})
+		.map(require)
+		.forEach(runTest);
+	}
+
+	function runTest(file){
+		it(file.name, function(done){
+			test(file, getCallback(file.expected, done));
+		});
+	}
+};
+\ No newline at end of file
author	Florian Dold <florian.dold@gmail.com>	2017-05-03 15:35:00 +0200
committer	Florian Dold <florian.dold@gmail.com>	2017-05-03 15:35:00 +0200
commit	de98e0b232509d5f40c135d540a70e415272ff85 (patch)
tree	a79222a5b58484ab3b80d18efcaaa7ccc4769b33 /node_modules/htmlparser2
parent	e0c9d480a73fa629c1e4a47d3e721f1d2d345406 (diff)