From 25a51d7cb2edac34eb28cd51c89ca7a181ba0041 Mon Sep 17 00:00:00 2001
From: Danny Hurlburt <dhurlburtusa@users.noreply.github.com>
Date: Mon, 25 Dec 2017 10:39:20 -0700
Subject: [PATCH 01/16] Add Missing serialize Documentation (#1111)

---
 Readme.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Readme.md b/Readme.md
index 2f347f9c9c..988a9c077f 100644
--- a/Readme.md
+++ b/Readme.md
@@ -149,6 +149,7 @@ Does your company use Cheerio in production? Please consider [sponsoring this pr
 <details>
   <summary>Forms</summary>
 
+  - [.serialize()](#serialize)
   - [.serializeArray()](#serializearray)
 </details>
 <details>
@@ -429,6 +430,15 @@ Checks the current list of elements and returns `true` if _any_ of the elements
 
 ### Forms
 
+#### .serialize()
+
+Encodes a set of form elements as a URL query string.
+
+```js
+$('<form><input name="foo" value="bar" checked /><input name="foo" value="qux" checked /></form>').serialize()
+//=> foo=bar&foo=qux
+```
+
 #### .serializeArray()
 
 Encode a set of form elements as an array of names and values.

From 7b6684ddab1c6d3bcdfee078db5c192f8e7e5361 Mon Sep 17 00:00:00 2001
From: Gary Katsevman <git@gkatsev.com>
Date: Tue, 27 Feb 2018 16:47:50 -0500
Subject: [PATCH 02/16] Add note about XML namespace to README (#1151)

---
 Readme.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Readme.md b/Readme.md
index 988a9c077f..273bd3cbe8 100644
--- a/Readme.md
+++ b/Readme.md
@@ -304,6 +304,13 @@ $('li[class=orange]').html()
 //=> Orange
 ```
 
+##### XML Namespaces
+You can select with XML Namespaces but [due to the CSS specification](https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#attribute-selectors), the colon (`:`) needs to be escaped for the selector to be valid.
+
+```js
+$('[xml\\:id="main"');
+```
+
 ### Attributes
 Methods for getting and modifying attributes.
 

From 021e3c214ed0fa692f4ab87da5ad566e1fe2a097 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <me@feedic.com>
Date: Mon, 5 Mar 2018 17:08:32 -0800
Subject: [PATCH 03/16] Create CNAME

---
 CNAME | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 CNAME

diff --git a/CNAME b/CNAME
new file mode 100644
index 0000000000..c9cd136f79
--- /dev/null
+++ b/CNAME
@@ -0,0 +1 @@
+cheerio.js.org
\ No newline at end of file

From d151d8008ddb8af11bc9f4c3dbf1c51ae0f52ff8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <me@feedic.com>
Date: Mon, 5 Mar 2018 17:08:54 -0800
Subject: [PATCH 04/16] Set theme jekyll-theme-cayman

---
 _config.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 _config.yml

diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000000..c4192631f2
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
\ No newline at end of file

From 89e7d1ca5cb9c4b8b0e9c968131516ef31bd11ca Mon Sep 17 00:00:00 2001
From: besteman <ellioy37@gmail.com>
Date: Fri, 9 Mar 2018 08:37:24 -0500
Subject: [PATCH 05/16] Fix spelling (#1157)

---
 Readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Readme.md b/Readme.md
index 273bd3cbe8..822353f919 100644
--- a/Readme.md
+++ b/Readme.md
@@ -978,7 +978,7 @@ $('li').wrap(healthy)
 //   </ul>
 ```
 
-#### .css( [propertName] ) <br /> .css( [ propertyNames] ) <br /> .css( [propertyName], [value] ) <br /> .css( [propertName], [function] ) <br /> .css( [properties] )
+#### .css( [propertyName] ) <br /> .css( [ propertyNames] ) <br /> .css( [propertyName], [value] ) <br /> .css( [propertyName], [function] ) <br /> .css( [properties] )
 
 Get the value of a style property for the first element in the set of matched elements or set one or more CSS properties for every matched element.
 

From 320847eba18e2e3249a71c470a24ef1ade49e51d Mon Sep 17 00:00:00 2001
From: Wahaj Dar <wahajdar@outlook.com>
Date: Thu, 29 Mar 2018 18:15:33 +0500
Subject: [PATCH 06/16] Added support for inherited props in .props(...)
 validation (#1146)

* added support for inherited props in .props(...) validation

* added test case for inherited props support
---
 lib/api/attributes.js  | 2 +-
 test/api/attributes.js | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/lib/api/attributes.js b/lib/api/attributes.js
index 01a1dc9dfe..6abbb2f7dc 100644
--- a/lib/api/attributes.js
+++ b/lib/api/attributes.js
@@ -93,7 +93,7 @@ exports.attr = function(name, value) {
 var getProp = function (el, name) {
   if (!el || !isTag(el)) return;
 
-  return el.hasOwnProperty(name)
+  return name in el
       ? el[name]
       : rboolean.test(name)
           ? getAttr(el, name) !== undefined
diff --git a/test/api/attributes.js b/test/api/attributes.js
index 1f99e66a8d..61072dd9b9 100644
--- a/test/api/attributes.js
+++ b/test/api/attributes.js
@@ -130,10 +130,11 @@ describe('$(...)', function() {
   });
 
   describe('.prop', function () {
-    var checkbox;
+    var checkbox, selectMenu;
 
     beforeEach(function () {
       $ = cheerio.load(inputs);
+      selectMenu = $('select');
       checkbox = $('input[name=checkbox_on]');
     });
 
@@ -186,6 +187,10 @@ describe('$(...)', function() {
       expect($(undefined).prop('prop')).to.be(undefined);
       expect($(null).prop('prop')).to.be(undefined);
     });
+    
+    it('(inherited properties) : prop should support inherited properties', function() {
+      expect(selectMenu.prop('childNodes')).to.equal(selectMenu[0].childNodes);
+    });
   });
 
   describe('.data', function() {

From 74be27115020fca7c08a1c177d3b6fc487b9194b Mon Sep 17 00:00:00 2001
From: Bartosz Sosnowski <bzoz@users.noreply.github.com>
Date: Mon, 20 Aug 2018 22:22:00 +0200
Subject: [PATCH 07/16] Fix running test on Windows (#1209)

Moves lint and test script call from Makefile to package.json. Makes the test run on all platforms.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index bc5a55ce73..91d4e0aa34 100644
--- a/package.json
+++ b/package.json
@@ -43,6 +43,6 @@
     "xyz": "~1.1.0"
   },
   "scripts": {
-    "test": "make test"
+    "test": "jshint lib/ test/ && mocha --recursive --reporter dot"
   }
 }

From ca6963c09a38eaf67fbe551634fdbbc6984d3da8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <me@feedic.com>
Date: Wed, 3 Oct 2018 17:55:28 +0100
Subject: [PATCH 08/16] v1.0.0 (#1145)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Use parse5 as a default parser (closes #863)

* Use documents via $.load

* Add test for #997

* Change options format

* Update unit test

Update test phrasing according to recent changes in parsing logic.

* 1.0.0-rc.1

* Improve release process

Limit responsibility of "pre-publish" script to simply validate the
project's `History.md` file (by verifying an entry for the current
release). Define a separate script for history generation. Separating
the workflow in this way allows for manual modification of the release
notes.

* Correct errors in Readme.md

* Document advanced usage with htmlparser2

* Update History.md (and include migration guide)

* Remove documentation for `xmlMode` option

Simply expose an option named `xml` that enables XML parsing via
htmlparser2 with the ability to specify additional options for that
parser.

* Rename `useHtmlParser2` option

This flag is used to control parsing behavior internally, but it is not
intended for use by consumers. Prefix the name with an underscore in
order to discourage users from relying on it.

* Re-write migration guide for version 1.0 (#1078)

Incorporate recent feedback from consumers who have experimented with
the version 1.0 release candidate.

* Pass locationInfo option to parse5 (#1155)

* Update css-select to the latest version 🚀 (#1158)

Breaking change: Invalid selectors now throw Errors, not SyntaxErrors.

* Use eslint & prettier, add precommit hook (#1152)

* chore(package): update mocha to version 5.0.4 (#1088)

* Ensure text nodes expose the DOM level 1 API

Since enabling the `withDomLvl1` parsing option, nodes cannot be created
with an object literal. Create new text nodes using the `evaluate`
function to ensure they expose the correct attributes.

* fixing missing prop(‘outerHTML’) implementation.
Added an ‘outerHTML’ case to the switch in the prop function, which wraps a clone of  in a container element, and sets  to that container's HTML (#945)

* Do not lint files excluded from version control (#1162)

This includes code coverage reports as generated by the command `make
test-cov`.

* Correct typo in git hook configuration (#1163)

* Correct typo in git hook configuration

* Reformat package manifest to satisfy linter

* Fix .text with a function as the argument

* Fix `.text` being called on a collection with size > 1 with a function

* chore(package): update coveralls to version 3.0.0 (#1086)

* Update jsdom to the latest version 🚀 (#1008)

* Throw a useful error on invalid input to cheerio.load() (#1087)

* Procedurally generate API documentation from source (#1165)

* Use parse5 to serialize the DOM, use lodash to clone dom

* Fix DoS/RCE vulnerability in lodash@4.15.0 (#1179)

fixes #1175

*  Add eslint-plugin-jsdoc, improve documentation (#1168)

* Improve variable names (#1183)

Promote consistency in variable names within the project's source and
unit tests. This helps to highlight the distinction between the object
exported by the module and the function produced by the `load` method.
The latter value is expected to mimic the jQuery API, while the former
value generally should only be used for a small set of methods specific
to Cheerio:

- `load`
- `html`
- `xml`
- `text`

Other usages of the exported object are discouraged, and a future patch
will update the unit tests to reflect the usages that are endorsed for
long-term stability.

* Formally test deprecated APIs (#1184)

Methods named `load`, `html`, `xml`, and `text` are defined in many
locations:

Today, Cheerio defines multiple versions of methods named `load`,
`html`, `xml`, `text`, and `parseHTML`. These alternate versions may be
defined in up to three distinct parts of the API:

- exported by the Cheerio module
- as static methods of the "loaded" Cheerio factory function
- as instance methods of the "loaded" Cheerio factory function

Some of these are surperfluous, and because some unecessarily conflict
with idiomatic jQuery coding patterns, they have been designated for
future removal [1].

Add tests for the deprecated methods in order to avoid regressions prior
to their removal. Insert comments to delineate the methods which are
endorsed and which have been deprecated. For the latter group of
methods, include recommendation for the preferred alternatives.

[1] https://github.com/cheeriojs/cheerio/issues/1122

* Implement for...of iterator via Symbol.iterator (#1197)

* Implement for...of iterator via Symbol.iterator

Similar to jQuery: https://github.com/jquery/jquery/blob/1ea092a54b00aa4d902f4e22ada3854d195d4a18/src/core.js#L371-L373

Fixes #1191

* Assert that the iterator ends

https://github.com/cheeriojs/cheerio/pull/1197#discussion_r187807553
---
 .eslintrc.json              |  31 ++
 .gitignore                  |   1 +
 .jshintrc                   |  11 -
 .travis.yml                 |   6 +-
 CONTRIBUTING.md             |  56 +--
 History.md                  |  95 ++++
 Makefile                    |  17 +-
 Readme.md                   | 850 ++-------------------------------
 benchmark/.eslintrc.json    |   5 +
 benchmark/benchmark.js      |  26 +-
 benchmark/suite.js          |  14 +-
 jsdoc-config.json           |  11 +
 lib/api/attributes.js       | 307 +++++++++---
 lib/api/css.js              |  89 ++--
 lib/api/forms.js            |  58 ++-
 lib/api/manipulation.js     | 463 +++++++++++++++---
 lib/api/traversing.js       | 678 +++++++++++++++++++++++----
 lib/cheerio.js              |  82 ++--
 lib/options.js              |  18 +
 lib/parse.js                |  36 +-
 lib/static.js               | 148 ++++--
 lib/utils.js                |  90 ++--
 package.json                |  50 +-
 scripts/generate_history.sh |  30 ++
 scripts/prepublish          |  26 +-
 test/.eslintrc.json         |   5 +
 test/.jshintrc              |   9 -
 test/api/attributes.js      | 160 ++++---
 test/api/css.js             |  25 +-
 test/api/forms.js           |  59 ++-
 test/api/manipulation.js    | 904 ++++++++++++++++++++++++++++--------
 test/api/traversing.js      | 281 ++++++-----
 test/api/utils.js           | 172 ++++---
 test/cheerio.js             | 404 ++++++++++------
 test/fixtures.js            |  30 +-
 test/parse.js               | 199 ++++++--
 test/xml.js                 |  37 +-
 37 files changed, 3424 insertions(+), 2059 deletions(-)
 create mode 100644 .eslintrc.json
 delete mode 100644 .jshintrc
 create mode 100644 benchmark/.eslintrc.json
 create mode 100644 jsdoc-config.json
 create mode 100644 lib/options.js
 create mode 100755 scripts/generate_history.sh
 create mode 100644 test/.eslintrc.json
 delete mode 100644 test/.jshintrc

diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000000..0db30f8ce8
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,31 @@
+{
+  "env": {
+    "node": true
+  },
+  "plugins": ["jsdoc"],
+  "extends": ["eslint:recommended", "prettier"],
+  "globals": {},
+  "rules": {
+    "indent": [
+      2,
+      2,
+      {
+        "SwitchCase": 1,
+        "VariableDeclarator": 2
+      }
+    ],
+    "no-eq-null": 0,
+    "no-proto": 2,
+
+    "jsdoc/check-param-names": 2,
+    "jsdoc/check-tag-names": 2,
+    "jsdoc/check-types": 2,
+    "jsdoc/newline-after-description": 2,
+    "jsdoc/require-description-complete-sentence": 2,
+    "jsdoc/require-hyphen-before-param-description": 2,
+    "jsdoc/require-param": 2,
+    "jsdoc/require-param-description": 2,
+    "jsdoc/require-param-name": 2,
+    "jsdoc/require-param-type": 2
+  }
+}
diff --git a/.gitignore b/.gitignore
index 2ae05e1c97..46b866b577 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ lib-cov
 cover_html
 .c9revisions
 coverage
+/docs/
diff --git a/.jshintrc b/.jshintrc
deleted file mode 100644
index 28a0ff23f0..0000000000
--- a/.jshintrc
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "indent": 2,
-  "eqnull": true,
-  "laxbreak": true,
-  "proto": true,
-  "undef": true,
-  "unused": true,
-  "node": true,
-  "quotmark": "single",
-  "shadow": "outer"
-}
diff --git a/.travis.yml b/.travis.yml
index b7d7df23f8..8db0083269 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,15 +1,11 @@
 language: node_js
 node_js:
   - "stable"
-  - "unstable"
+  - "8"
   - "6"
-  - "4"
-  - "0.12"
 script: make travis-test
 matrix:
   fast_finish: true
-  allow_failures:
-    - node_js: unstable
   include:
     - env: BENCHMARK=true
       script: "node benchmark/benchmark.js --regex '^(?!.*highmem)'"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index cc38bb8dd7..24f458fdee 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -3,16 +3,16 @@
 Thanks for your interest in contributing to the project! Here's a rundown of
 how we'd like to work with you:
 
-1. File an issue on GitHub describing the contribution you'd like to make. This
-   will help us to get you started on the right foot.
-2. Create a single commit that addresses the issue:
-    1. Follow the project's code style (see below)
-    2. Add enough unit tests to "prove" that your patch is correct
-    3. Update the project documentation as needed (see below)
-    4. Describe your approach with as much detail as necessary in the git
-       commit message
-3. Open a pull request, and reference the initial issue in the pull request
-   message.
+1.  File an issue on GitHub describing the contribution you'd like to make. This
+    will help us to get you started on the right foot.
+2.  Create a single commit that addresses the issue:
+    1.  Follow the project's code style (see below)
+    2.  Add enough unit tests to "prove" that your patch is correct
+    3.  Update the project documentation as needed (see below)
+    4.  Describe your approach with as much detail as necessary in the git
+        commit message
+3.  Open a pull request, and reference the initial issue in the pull request
+    message.
 
 # Documentation
 
@@ -22,26 +22,16 @@ care to note aspects that make Cheerio distinct.
 
 # Code Style
 
-This section is by no means complete. For undocumented stylistic choices,
-please try to maintain consistency with the code base.
-
-- Single quotes: `'`
-- Whitespace
-  - Two-space "soft" tabs
-  - Once space following control flow statements (`if (condition) {` rather
-    than `if(condition) {`)
-  - Remove trailing spaces
-  - [End each file with a newline
-    character.](https://github.com/editorconfig/editorconfig/wiki/Newline-at-End-of-File-Support)
-- Terminate every statement with a semicolon
-- Private functionality (for re-using functionality that isn't part of the
-  jQuery API)
-  - *Static methods*: If the functionality does not require a reference to a
-    Cheerio instance, simply define a named function within the module it is
-    needed.
-  - *Instance methods*: If the functionality requires a reference to a Cheerio
-    instance, informally define the method as "private" using the following
-    conventions:
-    - Define the method as a function on the Cheerio prototype
-    - Prefix the method name with an underscore (`_`) character
-    - Include `@api private` in the code comment the documents the method
+Please make sure commit hooks are run, which will enforce the code style.
+
+When implementing private functionality that isn't part of the jQuery API, please opt for:
+
+* _Static methods_: If the functionality does not require a reference to a
+  Cheerio instance, simply define a named function within the module it is
+  needed.
+* _Instance methods_: If the functionality requires a reference to a Cheerio
+  instance, informally define the method as "private" using the following
+  conventions:
+  * Define the method as a function on the Cheerio prototype
+  * Prefix the method name with an underscore (`_`) character
+  * Include `@api private` in the code comment the documents the method
diff --git a/History.md b/History.md
index c7e38e66a7..462ae0cf28 100644
--- a/History.md
+++ b/History.md
@@ -1,3 +1,98 @@
+1.0.0-rc.2 / 2017-07-02
+==================
+
+This release changes Cheerio's default parser to [the Parse5 HTML
+parser](https://github.com/inikulin/parse5). Parse5 is an excellent project
+that rigorously conforms to the HTML standard. It does not support XML, so
+Cheerio continues to use [`htmlparser2`](https://github.com/fb55/htmlparser2/)
+when working with XML documents.
+
+This switch addresses many long-standing bugs in Cheerio, but some users may
+experience slower behavior in performance-critical applications. In addition,
+`htmlparser2` is more forgiving of invalid markup which can be useful when
+input sourced from a third party and cannot be corrected. For these reasons,
+the `load` method also accepts a DOM structure as produced by the `htmlparser2`
+library. See the project's "readme" file for more details on this usage
+pattern.
+
+### Migrating from version 0.x
+
+`cheerio.load( html[, options ] )` This method continues to act as a "factory"
+function. It produces functions that define an API that is similar to the
+global `jQuery` function provided by the jQuery library. The generated function
+operates on a DOM structure based on the provided HTML.
+
+In releases prior to version 1.0, the provided HTML was interpreted as a
+document fragment. Following version 1.0, strings provided to the `load` method
+are interpreted as documents. The same example will produce a `$` function that
+operates on a full HTML document, including an `<html>` document element with
+nested `<head>` and `<body>` tags. This mimics web browser behavior much more
+closely, but may require alterations to existing code.
+
+For example, the following code will produce different results between 0.x and
+1.0 releases:
+
+    var $ = cheerio.load('<p>Hello, <b>world</b>!</p>');
+
+    $.root().html();
+
+    //=> In version 0.x: '<p>Hello, <b>world</b>!</p>'
+    //=> In version 1.0: '<html><head></head><body><p>Hello, <b>world</b>!</p></body></html>'
+
+Users wishing to parse, manipulate, and render full documents should not need
+to modify their code. Likewise, code that does not interact with the "root"
+element should not be effected by this change. (In the above example, the
+expression `$('p')` returns the same result across Cheerio versions--a Cheerio
+collection whose only member is a paragraph element.)
+
+However, users wishing to render document fragments should now explicitly
+create a "wrapper" element to contain their input.
+
+    // First, create a Cheerio function "bound" to an empty document (this is
+    // similar to loading an empty page in a web browser)
+    var $ = cheerio.load('');
+    // Next, create a "wrapper" element for the input fragment:
+    var $wrapper = $('<div/>');
+    // Finally, supply the input markup as the content for the wrapper:
+    $wrapper.append('<p>Hello, <b>world</b>!</p>');
+
+    $wrapper.html();
+    //=> '<p>Hello, <b>world</b>!</p>'
+
+---
+
+Change log:
+
+ * Update History.md (and include migration guide) (Mike Pennisi)
+ * Rename `useHtmlParser2` option (Mike Pennisi)
+ * Remove documentation for `xmlMode` option (Mike Pennisi)
+ * Document advanced usage with htmlparser2 (Mike Pennisi)
+ * Correct errors in Readme.md (Mike Pennisi)
+ * Improve release process (Mike Pennisi)
+ * 1.0.0-rc.1 (Mike Pennisi)
+ * Update unit test (Mike Pennisi)
+ * Normalize code style (Mike Pennisi)
+ * Added support for nested wrapping. (Diane Looney)
+ * Add nested wrapping test (Toni Helenius)
+ * Added $.merge following the specification at https://api.jquery.com/jquery.merge/ Added test cases for $.merge (Diane Looney)
+ * Clarify project scope in README file (Mike Pennisi)
+ * .text() ignores script and style tags (#1018) (Haleem Assal)
+ * Test suite housekeeping (#1016) (DianeLooney)
+ * experiment with a job board (Matthew)
+ * Change options format (inikulin)
+ * Add test for #997 (inikulin)
+ * Update .filter function docs. (Konstantin)
+ * Standardise readme on ES6 variable declarations (Dekatron)
+ * Use documents via $.load (inikulin)
+ * Use parse5 as a default parser (closes #863) (inikulin)
+ * Fix small typo in Readme (Darren Scerri)
+ * Report test failures in CI (Mike Pennisi)
+ * serializeArray should not ignore input elements without value attributes (Ricardo Gladwell)
+ * Disallow variable shadowing (Mike Pennisi)
+ * Update hasClass method (sufisaid)
+ * Added MIT License fixes #902 (Prasanth Vaaheeswaran)
+ * chore(package): update dependencies (greenkeeper[bot])
+ * Use modular lodash package (#913) (Billy Janitsch)
 
 0.22.0 / 2016-08-23
 ==================
diff --git a/Makefile b/Makefile
index 3617d89b23..52edbb40a9 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,9 @@
 REPORTER = dot
 XYZ = node_modules/.bin/xyz --message 'Release X.Y.Z' --tag X.Y.Z --repo git@github.com:cheeriojs/cheerio.git --script scripts/prepublish
+UPSTREAM = git@github.com:cheeriojs/cheerio.git
 
 lint:
-	@./node_modules/.bin/jshint lib/ test/
+	@./node_modules/.bin/eslint --ignore-path .gitignore .
 
 test: lint
 	@./node_modules/.bin/mocha --recursive --reporter $(REPORTER)
@@ -36,4 +37,16 @@ release-patch: LEVEL = patch
 release-major release-minor release-patch:
 	@$(XYZ) --increment $(LEVEL)
 
-.PHONY: test build setup subl
+docs:
+	@./node_modules/.bin/jsdoc --configure jsdoc-config.json
+
+publish-docs: docs
+	@cd docs; \
+		rm -rf .git && \
+		git init && \
+		git add --all . && \
+		git commit -m 'Generate documentation' && \
+		git remote add upstream $(UPSTREAM) && \
+		git push --force upstream master:gh-pages
+
+.PHONY: test build setup subl docs publish-docs
diff --git a/Readme.md b/Readme.md
index 822353f919..c351d8612d 100644
--- a/Readme.md
+++ b/Readme.md
@@ -30,7 +30,7 @@ $('h2.title').text('Hello there!')
 $('h2').addClass('welcome')
 
 $.html()
-//=> <h2 class="title welcome">Hello there!</h2>
+//=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>
 ```
 
 ## Installation
@@ -44,7 +44,7 @@ __&#991; Blazingly fast:__
 Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient. Preliminary end-to-end benchmarks suggest that cheerio is about __8x__ faster than JSDOM.
 
 __&#10049; Incredibly flexible:__
-Cheerio wraps around @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.
+Cheerio wraps around [parse5](https://github.com/inikulin/parse5) parser and can optionally use @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.
 
 ## Cheerio is not a web browser
 
@@ -122,107 +122,6 @@ Does your company use Cheerio in production? Please consider [sponsoring this pr
 
 ## API
 
-### Table of contents
-
-<details>
-  <summary>Selectors</summary>
-
-  - [$( selector, [context], [root] )](#-selector-context-root-)
-</details>
-<details>
-  <summary>Attributes</summary>
-
-  - [.attr( name, value )](#attr-name-value-)
-  - [.prop( name, value )](#prop-name-value-)
-  - [.data( name, value )](#data-name-value-)
-  - [.val( [value] )](#val-value-)
-  - [.removeAttr( name )](#removeattr-name-)
-  - [.hasClass( className )](#hasclass-classname-)
-  - [.addClass( className )](#addclass-classname-)
-  - [.removeClass( [className] )](#removeclass-classname-)
-  - [.toggleClass( className, [switch] )](#toggleclass-classname-switch-)
-  - [.is( selector )](#is-selector-)
-  - [.is( element )](#is-element-)
-  - [.is( selection )](#is-selection-)
-  - [.is( function(index) )](#is-functionindex-)
-</details>
-<details>
-  <summary>Forms</summary>
-
-  - [.serialize()](#serialize)
-  - [.serializeArray()](#serializearray)
-</details>
-<details>
-  <summary>Traversing</summary>
-
-  - [.find(selector)](#findselector)
-  - [.find(selection)](#findselection)
-  - [.find(node)](#findnode)
-  - [.parent([selector])](#parentselector)
-  - [.parents([selector])](#parentsselector)
-  - [.parentsUntil([selector][,filter])](#parentsuntilselectorfilter)
-  - [.closest(selector)](#closestselector)
-  - [.next([selector])](#nextselector)
-  - [.nextAll([selector])](#nextallselector)
-  - [.nextUntil([selector], [filter])](#nextuntilselector-filter)
-  - [.prev([selector])](#prevselector)
-  - [.prevAll([selector])](#prevallselector)
-  - [.prevUntil([selector], [filter])](#prevuntilselector-filter)
-  - [.slice( start, [end] )](#slice-start-end-)
-  - [.siblings([selector])](#siblingsselector)
-  - [.children([selector])](#childrenselector)
-  - [.contents()](#contents)
-  - [.each( function(index, element) )](#each-functionindex-element-)
-  - [.map( function(index, element) )](#map-functionindex-element-)
-  - [.filter( selector )<br>
-     .filter( selection )<br>
-     .filter( element )<br>
-     .filter( function(index, element) )](#filter-selector---filter-selection---filter-element---filter-functionindex-element-)
-  - [.not( selector )<br>
-     .not( selection )<br>
-     .not( element )<br>
-     .not( function(index, elem) )](#not-selector---not-selection---not-element---not-functionindex-elem-)
-  - [.has( selector )<br>
-     .has( element )](#has-selector---has-element-)
-  - [.first()](#first)
-  - [.last()](#last)
-  - [.eq( i )](#eq-i-)
-  - [.get( [i] )](#get-i-)
-  - [.index()](#index)
-  - [.index( selector )](#index-selector-)
-  - [.index( nodeOrSelection )](#index-nodeorselection-)
-  - [.end()](#end)
-  - [.add( selector [, context] )](#add-selector--context-)
-  - [.add( element )](#add-element-)
-  - [.add( elements )](#add-elements-)
-  - [.add( html )](#add-html-)
-  - [.add( selection )](#add-selection-)
-  - [.addBack( [filter] )](#addback-filter-)
-</details>
-<details>
-  <summary>Manipulation</summary>
-
-  - [.append( content, [content, ...] )](#append-content-content--)
-  - [.appendTo( target )](#appendto-target-)
-  - [.prepend( content, [content, ...] )](#prepend-content-content--)
-  - [.prependTo( target )](#prependto-target-)
-  - [.after( content, [content, ...] )](#after-content-content--)
-  - [.insertAfter( target )](#insertafter-target-)
-  - [.before( content, [content, ...] )](#before-content-content--)
-  - [.insertBefore( target )](#insertbefore-target-)
-  - [.remove( [selector] )](#remove-selector-)
-  - [.replaceWith( content )](#replacewith-content-)
-  - [.empty()](#empty)
-  - [.html( [htmlString] )](#html-htmlstring-)
-  - [.text( [textString] )](#text-textstring-)
-  - [.wrap( content )](#wrap-content-)
-  - [.css( [propertName] )<br>
-     .css( [ propertyNames] )<br>
-     .css( [propertyName], [value] )<br>
-     .css( [propertName], [function] )<br>
-     .css( [properties] )](#css-propertname---css--propertynames---css-propertyname-value---css-propertname-function---css-properties-)
-</details>
-
 ### Markup example we'll be using:
 
 ```html
@@ -259,31 +158,53 @@ const $ = require('cheerio');
 $('li', 'ul', '<ul id="fruits">...</ul>');
 ```
 
-You can also pass an extra object to `.load()` if you need to modify any
-of the default parsing options:
+If you need to modify parsing options for XML input, you may pass an extra
+object to `.load()`:
 
 ```js
 const $ = cheerio.load('<ul id="fruits">...</ul>', {
-    normalizeWhitespace: true,
-    xmlMode: true
+    xml: {
+      normalizeWhitespace: true,
+    }
 });
 ```
 
-These parsing options are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. The default options are:
+The options in the `xml` object are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. The default options are:
 
 ```js
 {
     withDomLvl1: true,
     normalizeWhitespace: false,
-    xmlMode: false,
+    xmlMode: true,
     decodeEntities: true
 }
-
 ```
 
 For a full list of options and their effects, see [this](https://github.com/fb55/DomHandler) and
 [htmlparser2's options](https://github.com/fb55/htmlparser2/wiki/Parser-options).
 
+Some users may wish to parse markup with the `htmlparser2` library, and
+traverse/manipulate the resulting structure with Cheerio. This may be the case
+for those upgrading from pre-1.0 releases of Cheerio (which relied on
+`htmlparser2`), for those dealing with invalid markup (because `htmlparser2` is
+more forgiving), or for those operating in performance-critical situations
+(because `htmlparser2` may be faster in some cases). Note that "more forgiving"
+means `htmlparser2` has error-correcting mechanisms that aren't always a match
+for the standards observed by web browsers. This behavior may be useful when
+parsing non-HTML content.
+
+To support these cases, `load` also accepts a `htmlparser2`-compatible data
+structure as its first argument. Users may install `htmlparser2`, use it to
+parse input, and pass the result to `load`:
+
+```js
+// Usage as of htmlparser2 version 3:
+const htmlparser2 = require('htmlparser2');
+const dom = htmlparser2.parseDOM(document, options);
+
+const $ = cheerio.load(dom);
+```
+
 ### Selectors
 
 Cheerio's selector implementation is nearly identical to jQuery's, so the API is very similar.
@@ -311,677 +232,6 @@ You can select with XML Namespaces but [due to the CSS specification](https://ww
 $('[xml\\:id="main"');
 ```
 
-### Attributes
-Methods for getting and modifying attributes.
-
-#### .attr( name, value )
-Method for getting and setting attributes. Gets the attribute value for only the first element in the matched set. If you set an attribute's value to `null`, you remove that attribute. You may also pass a `map` and `function` like jQuery.
-
-```js
-$('ul').attr('id')
-//=> fruits
-
-$('.apple').attr('id', 'favorite').html()
-//=> <li class="apple" id="favorite">Apple</li>
-```
-
-> See http://api.jquery.com/attr/ for more information
-
-#### .prop( name, value )
-Method for getting and setting properties. Gets the property value for only the first element in the matched set.
-
-```js
-$('input[type="checkbox"]').prop('checked')
-//=> false
-
-$('input[type="checkbox"]').prop('checked', true).val()
-//=> ok
-```
-
-> See http://api.jquery.com/prop/ for more information
-
-#### .data( name, value )
-Method for getting and setting data attributes. Gets or sets the data attribute value for only the first element in the matched set.
-
-```js
-$('<div data-apple-color="red"></div>').data()
-//=> { appleColor: 'red' }
-
-$('<div data-apple-color="red"></div>').data('apple-color')
-//=> 'red'
-
-const apple = $('.apple').data('kind', 'mac')
-apple.data('kind')
-//=> 'mac'
-```
-
-> See http://api.jquery.com/data/ for more information
-
-#### .val( [value] )
-Method for getting and setting the value of input, select, and textarea. Note: Support for `map`, and `function` has not been added yet.
-
-```js
-$('input[type="text"]').val()
-//=> input_text
-
-$('input[type="text"]').val('test').html()
-//=> <input type="text" value="test"/>
-```
-
-#### .removeAttr( name )
-Method for removing attributes by `name`.
-
-```js
-$('.pear').removeAttr('class').html()
-//=> <li>Pear</li>
-```
-
-#### .hasClass( className )
-Check to see if *any* of the matched elements have the given `className`.
-
-```js
-$('.pear').hasClass('pear')
-//=> true
-
-$('apple').hasClass('fruit')
-//=> false
-
-$('li').hasClass('pear')
-//=> true
-```
-
-#### .addClass( className )
-Adds class(es) to all of the matched elements. Also accepts a `function` like jQuery.
-
-```js
-$('.pear').addClass('fruit').html()
-//=> <li class="pear fruit">Pear</li>
-
-$('.apple').addClass('fruit red').html()
-//=> <li class="apple fruit red">Apple</li>
-```
-
-> See http://api.jquery.com/addClass/ for more information.
-
-#### .removeClass( [className] )
-Removes one or more space-separated classes from the selected elements. If no `className` is defined, all classes will be removed. Also accepts a `function` like jQuery.
-
-```js
-$('.pear').removeClass('pear').html()
-//=> <li class="">Pear</li>
-
-$('.apple').addClass('red').removeClass().html()
-//=> <li class="">Apple</li>
-```
-
-> See http://api.jquery.com/removeClass/ for more information.
-
-#### .toggleClass( className, [switch] )
-Add or remove class(es) from the matched elements, depending on either the class's presence or the value of the switch argument. Also accepts a `function` like jQuery.
-
-```js
-$('.apple.green').toggleClass('fruit green red').html()
-//=> <li class="apple fruit red">Apple</li>
-
-$('.apple.green').toggleClass('fruit green red', true).html()
-//=> <li class="apple green fruit red">Apple</li>
-```
-
-> See http://api.jquery.com/toggleClass/ for more information.
-
-#### .is( selector )
-#### .is( element )
-#### .is( selection )
-#### .is( function(index) )
-Checks the current list of elements and returns `true` if _any_ of the elements match the selector. If using an element or Cheerio selection, returns `true` if _any_ of the elements match. If using a predicate function, the function is executed in the context of the selected element, so `this` refers to the current element.
-
-### Forms
-
-#### .serialize()
-
-Encodes a set of form elements as a URL query string.
-
-```js
-$('<form><input name="foo" value="bar" checked /><input name="foo" value="qux" checked /></form>').serialize()
-//=> foo=bar&foo=qux
-```
-
-#### .serializeArray()
-
-Encode a set of form elements as an array of names and values.
-
-```js
-$('<form><input name="foo" value="bar" /></form>').serializeArray()
-//=> [ { name: 'foo', value: 'bar' } ]
-```
-
-### Traversing
-
-#### .find(selector)
-#### .find(selection)
-#### .find(node)
-Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
-
-```js
-$('#fruits').find('li').length
-//=> 3
-$('#fruits').find($('.apple')).length
-//=> 1
-```
-
-#### .parent([selector])
-Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
-
-```js
-$('.pear').parent().attr('id')
-//=> fruits
-```
-
-#### .parents([selector])
-Get a set of parents filtered by `selector` of each element in the current set of match elements.
-```js
-$('.orange').parents().length
-// => 2
-$('.orange').parents('#fruits').length
-// => 1
-```
-
-#### .parentsUntil([selector][,filter])
-Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or cheerio object.
-```js
-$('.orange').parentsUntil('#food').length
-// => 1
-```
-
-#### .closest(selector)
-For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
-
-```js
-$('.orange').closest()
-// => []
-$('.orange').closest('.apple')
-// => []
-$('.orange').closest('li')
-// => [<li class="orange">Orange</li>]
-$('.orange').closest('#fruits')
-// => [<ul id="fruits"> ... </ul>]
-```
-
-#### .next([selector])
-Gets the next sibling of the first selected element, optionally filtered by a selector.
-
-```js
-$('.apple').next().hasClass('orange')
-//=> true
-```
-
-#### .nextAll([selector])
-Gets all the following siblings of the first selected element, optionally filtered by a selector.
-
-```js
-$('.apple').nextAll()
-//=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
-$('.apple').nextAll('.orange')
-//=> [<li class="orange">Orange</li>]
-```
-
-#### .nextUntil([selector], [filter])
-Gets all the following siblings up to but not including the element matched by the selector, optionally filtered by another selector.
-
-```js
-$('.apple').nextUntil('.pear')
-//=> [<li class="orange">Orange</li>]
-```
-
-#### .prev([selector])
-Gets the previous sibling of the first selected element optionally filtered by a selector.
-
-```js
-$('.orange').prev().hasClass('apple')
-//=> true
-```
-
-#### .prevAll([selector])
-Gets all the preceding siblings of the first selected element, optionally filtered by a selector.
-
-```js
-$('.pear').prevAll()
-//=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
-$('.pear').prevAll('.orange')
-//=> [<li class="orange">Orange</li>]
-```
-
-#### .prevUntil([selector], [filter])
-Gets all the preceding siblings up to but not including the element matched by the selector, optionally filtered by another selector.
-
-```js
-$('.pear').prevUntil('.apple')
-//=> [<li class="orange">Orange</li>]
-```
-
-#### .slice( start, [end] )
-Gets the elements matching the specified range
-
-```js
-$('li').slice(1).eq(0).text()
-//=> 'Orange'
-
-$('li').slice(1, 2).length
-//=> 1
-```
-
-#### .siblings([selector])
-Gets the first selected element's siblings, excluding itself.
-
-```js
-$('.pear').siblings().length
-//=> 2
-
-$('.pear').siblings('.orange').length
-//=> 1
-
-```
-
-#### .children([selector])
-Gets the children of the first selected element.
-
-```js
-$('#fruits').children().length
-//=> 3
-
-$('#fruits').children('.pear').text()
-//=> Pear
-```
-
-#### .contents()
-Gets the children of each element in the set of matched elements, including text and comment nodes.
-
-```js
-$('#fruits').contents().length
-//=> 3
-```
-
-#### .each( function(index, element) )
-Iterates over a cheerio object, executing a function for each matched element. When the callback is fired, the function is fired in the context of the DOM element, so `this` refers to the current element, which is equivalent to the function parameter `element`. To break out of the `each` loop early, return with `false`.
-
-```js
-const fruits = [];
-
-$('li').each(function(i, elem) {
-  fruits[i] = $(this).text();
-});
-
-fruits.join(', ');
-//=> Apple, Orange, Pear
-```
-
-#### .map( function(index, element) )
-Pass each element in the current matched set through a function, producing a new Cheerio object containing the return values. The function can return an individual data item or an array of data items to be inserted into the resulting set. If an array is returned, the elements inside the array are inserted into the set. If the function returns null or undefined, no element will be inserted.
-
-```js
-$('li').map(function(i, el) {
-  // this === el
-  return $(this).text();
-}).get().join(' ');
-//=> "apple orange pear"
-```
-
-#### .filter( selector ) <br /> .filter( selection ) <br /> .filter( element ) <br /> .filter( function(index, element) )
-
-Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test. When a Cheerio selection is specified, return only the elements contained in that selection. When an element is specified, return only that element (if it is contained in the original selection). If using the function method, the function is executed in the context of the selected element, so `this` refers to the current element.
-
-Selector:
-
-```js
-$('li').filter('.orange').attr('class');
-//=> orange
-```
-
-Function:
-
-```js
-$('li').filter(function(i, el) {
-  // this === el
-  return $(this).attr('class') === 'orange';
-}).attr('class')
-//=> orange
-```
-
-#### .not( selector ) <br /> .not( selection ) <br /> .not( element ) <br /> .not( function(index, elem) )
-
-Remove elements from the set of matched elements. Given a jQuery object that represents a set of DOM elements, the `.not()` method constructs a new jQuery object from a subset of the matching elements. The supplied selector is tested against each element; the elements that don't match the selector will be included in the result. The `.not()` method can take a function as its argument in the same way that `.filter()` does. Elements for which the function returns true are excluded from the filtered set; all other elements are included.
-
-Selector:
-
-```js
-$('li').not('.apple').length;
-//=> 2
-```
-
-Function:
-
-```js
-$('li').not(function(i, el) {
-  // this === el
-  return $(this).attr('class') === 'orange';
-}).length;
-//=> 2
-```
-
-#### .has( selector ) <br /> .has( element )
-
-Filters the set of matched elements to only those which have the given DOM element as a descendant or which have a descendant that matches the given selector. Equivalent to `.filter(':has(selector)')`.
-
-Selector:
-
-```js
-$('ul').has('.pear').attr('id');
-//=> fruits
-```
-
-Element:
-
-```js
-$('ul').has($('.pear')[0]).attr('id');
-//=> fruits
-```
-
-#### .first()
-Will select the first element of a cheerio object
-
-```js
-$('#fruits').children().first().text()
-//=> Apple
-```
-
-#### .last()
-Will select the last element of a cheerio object
-
-```js
-$('#fruits').children().last().text()
-//=> Pear
-```
-
-#### .eq( i )
-Reduce the set of matched elements to the one at the specified index. Use `.eq(-i)` to count backwards from the last selected element.
-
-```js
-$('li').eq(0).text()
-//=> Apple
-
-$('li').eq(-1).text()
-//=> Pear
-```
-
-#### .get( [i] )
-
-Retrieve the DOM elements matched by the Cheerio object. If an index is specified, retrieve one of the elements matched by the Cheerio object:
-
-```js
-$('li').get(0).tagName
-//=> li
-```
-
-If no index is specified, retrieve all elements matched by the Cheerio object:
-
-```js
-$('li').get().length
-//=> 3
-```
-
-#### .index()
-#### .index( selector )
-#### .index( nodeOrSelection )
-
-Search for a given element from among the matched elements.
-
-```js
-$('.pear').index()
-//=> 2
-$('.orange').index('li')
-//=> 1
-$('.apple').index($('#fruit, li'))
-//=> 1
-```
-
-#### .end()
-End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
-
-```js
-$('li').eq(0).end().length
-//=> 3
-```
-
-#### .add( selector [, context] )
-#### .add( element )
-#### .add( elements )
-#### .add( html )
-#### .add( selection )
-Add elements to the set of matched elements.
-
-```js
-$('.apple').add('.orange').length
-//=> 2
-```
-
-#### .addBack( [filter] )
-
-Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
-
-```js
-$('li').eq(0).addBack('.orange').length
-//=> 2
-```
-
-### Manipulation
-Methods for modifying the DOM structure.
-
-#### .append( content, [content, ...] )
-Inserts content as the *last* child of each of the selected elements.
-
-```js
-$('ul').append('<li class="plum">Plum</li>')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//      <li class="plum">Plum</li>
-//    </ul>
-```
-
-#### .appendTo( target )
-Insert every element in the set of matched elements to the end of the target.
-
-```js
-$('<li class="plum">Plum</li>').appendTo('#fruits')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//      <li class="plum">Plum</li>
-//    </ul>
-```
-
-#### .prepend( content, [content, ...] )
-Inserts content as the *first* child of each of the selected elements.
-
-```js
-$('ul').prepend('<li class="plum">Plum</li>')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="plum">Plum</li>
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .prependTo( target )
-Insert every element in the set of matched elements to the beginning of the target.
-
-```js
-$('<li class="plum">Plum</li>').prependTo('#fruits')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="plum">Plum</li>
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .after( content, [content, ...] )
-Insert content next to each element in the set of matched elements.
-
-```js
-$('.apple').after('<li class="plum">Plum</li>')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="apple">Apple</li>
-//      <li class="plum">Plum</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .insertAfter( target )
-Insert every element in the set of matched elements after the target.
-
-```js
-$('<li class="plum">Plum</li>').insertAfter('.apple')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="apple">Apple</li>
-//      <li class="plum">Plum</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .before( content, [content, ...] )
-Insert content previous to each element in the set of matched elements.
-
-```js
-$('.apple').before('<li class="plum">Plum</li>')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="plum">Plum</li>
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .insertBefore( target )
-Insert every element in the set of matched elements before the target.
-
-```js
-$('<li class="plum">Plum</li>').insertBefore('.apple')
-$.html()
-//=>  <ul id="fruits">
-//      <li class="plum">Plum</li>
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//      <li class="pear">Pear</li>
-//    </ul>
-```
-
-#### .remove( [selector] )
-Removes the set of matched elements from the DOM and all their children. `selector` filters the set of matched elements to be removed.
-
-```js
-$('.pear').remove()
-$.html()
-//=>  <ul id="fruits">
-//      <li class="apple">Apple</li>
-//      <li class="orange">Orange</li>
-//    </ul>
-```
-
-#### .replaceWith( content )
-Replaces matched elements with `content`.
-
-```js
-const plum = $('<li class="plum">Plum</li>')
-$('.pear').replaceWith(plum)
-$.html()
-//=> <ul id="fruits">
-//     <li class="apple">Apple</li>
-//     <li class="orange">Orange</li>
-//     <li class="plum">Plum</li>
-//   </ul>
-```
-
-#### .empty()
-Empties an element, removing all its children.
-
-```js
-$('ul').empty()
-$.html()
-//=>  <ul id="fruits"></ul>
-```
-
-#### .html( [htmlString] )
-Gets an html content string from the first selected element. If `htmlString` is specified, each selected element's content is replaced by the new content.
-
-```js
-$('.orange').html()
-//=> Orange
-
-$('#fruits').html('<li class="mango">Mango</li>').html()
-//=> <li class="mango">Mango</li>
-```
-
-#### .text( [textString] )
-Get the combined text contents of each element in the set of matched elements, including their descendants. If `textString` is specified, each selected element's content is replaced by the new text content.
-
-```js
-$('.orange').text()
-//=> Orange
-
-$('ul').text()
-//=>  Apple
-//    Orange
-//    Pear
-```
-
-#### .wrap( content )
-The .wrap() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. A copy of this structure will be wrapped around each of the elements in the set of matched elements. This method returns the original set of elements for chaining purposes.
-
-```js
-const redFruit = $('<div class="red-fruit"></div>')
-$('.apple').wrap(redFruit)
-
-//=> <ul id="fruits">
-//     <div class="red-fruit">
-//      <li class="apple">Apple</li>
-//     </div>
-//     <li class="orange">Orange</li>
-//     <li class="plum">Plum</li>
-//   </ul>
-
-const healthy = $('<div class="healthy"></div>')
-$('li').wrap(healthy)
-
-//=> <ul id="fruits">
-//     <div class="healthy">
-//       <li class="apple">Apple</li>
-//     </div>
-//     <div class="healthy">
-//       <li class="orange">Orange</li>
-//     </div>
-//     <div class="healthy">
-//        <li class="plum">Plum</li>
-//     </div>
-//   </ul>
-```
-
-#### .css( [propertyName] ) <br /> .css( [ propertyNames] ) <br /> .css( [propertyName], [value] ) <br /> .css( [propertyName], [function] ) <br /> .css( [properties] )
-
-Get the value of a style property for the first element in the set of matched elements or set one or more CSS properties for every matched element.
-
 ### Rendering
 When you're ready to render the document, you can use the `html` utility function:
 
@@ -1030,44 +280,6 @@ cheerio.text($('div'))
 //=> This is content.
 ```
 
-### Miscellaneous
-DOM element methods that don't fit anywhere else
-
-#### .toArray()
-Retrieve all the DOM elements contained in the jQuery set as an array.
-
-```js
-$('li').toArray()
-//=> [ {...}, {...}, {...} ]
-```
-
-#### .clone() ####
-Clone the cheerio object.
-
-```js
-const moreFruit = $('#fruits').clone()
-```
-
-### Utilities
-
-#### $.root
-
-Sometimes you need to work with the top-level root element. To query it, you can use `$.root()`.
-
-```js
-$.root().append('<ul id="vegetables"></ul>').html();
-//=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
-```
-
-#### $.contains( container, contained )
-Checks to see if the `contained` DOM element is a descendant of the `container` DOM element.
-
-#### $.parseHTML( data [, context ] [, keepScripts ] )
-Parses a string into an array of DOM nodes. The `context` argument has no meaning for Cheerio, but it is maintained for API compatability.
-
-#### $.load( html[, options ] )
-Load in the HTML. (See the previous section titled "Loading" for more information.)
-
 ### Plugins
 
 Once you have loaded a document, you may extend the prototype or the equivalent `fn` property with custom plugin methods:
diff --git a/benchmark/.eslintrc.json b/benchmark/.eslintrc.json
new file mode 100644
index 0000000000..7753f32e77
--- /dev/null
+++ b/benchmark/.eslintrc.json
@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-console": 0
+  }
+}
diff --git a/benchmark/benchmark.js b/benchmark/benchmark.js
index 6d1825d94a..1aa0fdf53a 100755
--- a/benchmark/benchmark.js
+++ b/benchmark/benchmark.js
@@ -16,10 +16,14 @@ if (process.argv.indexOf('--cheerio-only') >= 0) {
 }
 
 suites.add('Select all', 'jquery.html', {
-  test: function($) { $('*').length; }
+  test: function($) {
+    $('*').length;
+  }
 });
 suites.add('Select some', 'jquery.html', {
-  test: function($) { $('li').length; }
+  test: function($) {
+    $('li').length;
+  }
 });
 
 /*
@@ -75,7 +79,7 @@ suites.add('manipulation - replaceWith', 'jquery.html', {
   setup: function($) {
     $('body').append('<div id="foo">');
   },
-  test: function($, $lis) {
+  test: function($) {
     $('#foo').replaceWith('<div id="foo">');
   }
 });
@@ -107,12 +111,14 @@ suites.add('manipulation - html render', 'jquery.html', {
 });
 suites.add('manipulation - html independent', 'jquery.html', {
   setup: function() {
-    return '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>';
+    return (
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
+      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+    );
   },
   test: function($, content) {
     $(content).html();
@@ -128,7 +134,6 @@ suites.add('manipulation - text', 'jquery.html', {
   }
 });
 
-
 /*
  * Traversing Tests
  */
@@ -261,7 +266,6 @@ suites.add('traversing - Eq', 'jquery.html', {
   }
 });
 
-
 /*
  * Attributes Tests
  */
diff --git a/benchmark/suite.js b/benchmark/suite.js
index da029ad7ec..b5d2cf863a 100644
--- a/benchmark/suite.js
+++ b/benchmark/suite.js
@@ -2,15 +2,18 @@ var fs = require('fs');
 var path = require('path');
 
 var Benchmark = require('benchmark');
-var jsdom = require('jsdom');
+var jsdom = require('jsdom/lib/old-api.js');
 var cheerio = require('..');
 
 var documentDir = path.join(__dirname, 'documents');
-var jQuerySrc = path.join(__dirname, '../node_modules/jquery/dist/jquery.slim.js');
+var jQuerySrc = path.join(
+  __dirname,
+  '../node_modules/jquery/dist/jquery.slim.js'
+);
 var filterRe = /./;
 var cheerioOnly = false;
 
-var Suites = module.exports = function() {};
+var Suites = (module.exports = function() {});
 
 Suites.prototype.filter = function(str) {
   filterRe = new RegExp(str, 'i');
@@ -21,15 +24,14 @@ Suites.prototype.cheerioOnly = function() {
 };
 
 Suites.prototype.add = function(name, fileName, options) {
-  var markup, suite, testFn;
+  var markup, suite;
   if (!filterRe.test(name)) {
     return;
   }
   markup = fs.readFileSync(path.join(documentDir, fileName), 'utf8');
   suite = new Benchmark.Suite(name);
-  testFn = options.test;
 
-  suite.on('start', function(event) {
+  suite.on('start', function() {
     console.log('Test: ' + name + ' (file: ' + fileName + ')');
   });
   suite.on('cycle', function(event) {
diff --git a/jsdoc-config.json b/jsdoc-config.json
new file mode 100644
index 0000000000..01e9af8b19
--- /dev/null
+++ b/jsdoc-config.json
@@ -0,0 +1,11 @@
+{
+  "opts": {
+    "destination": "./docs",
+    "readme": "Readme.md",
+    "recurse": true
+  },
+  "plugins": ["plugins/markdown"],
+  "source": {
+    "include": ["lib"]
+  }
+}
diff --git a/lib/api/attributes.js b/lib/api/attributes.js
index 6abbb2f7dc..3ce6a90706 100644
--- a/lib/api/attributes.js
+++ b/lib/api/attributes.js
@@ -1,4 +1,9 @@
-var $ = require('../static'),
+/**
+ * Methods for getting and modifying attributes.
+ *
+ * @module attributes
+ */
+var text = require('../static').text,
     utils = require('../utils'),
     isTag = utils.isTag,
     domEach = utils.domEach,
@@ -12,20 +17,17 @@ var $ = require('../static'),
       extend: require('lodash/assignIn'),
       some: require('lodash/some')
     },
-
-  // Lookup table for coercing string data-* attributes to their corresponding
-  // JavaScript primitives
-  primitives = {
-    null: null,
-    true: true,
-    false: false
-  },
-
-  // Attributes that are booleans
-  rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
-  // Matches strings that look like JSON objects or arrays
-  rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
-
+    // Lookup table for coercing string data-* attributes to their corresponding
+    // JavaScript primitives
+    primitives = {
+      null: null,
+      true: true,
+      false: false
+    },
+    // Attributes that are booleans
+    rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+    // Matches strings that look like JSON objects or arrays
+    rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
 
 var getAttr = function(elem, name) {
   if (!elem || !isTag(elem)) return;
@@ -46,26 +48,46 @@ var getAttr = function(elem, name) {
 
   // Mimic the DOM and return text content as value for `option's`
   if (elem.name === 'option' && name === 'value') {
-    return $.text(elem.children);
+    return text(elem.children);
   }
 
   // Mimic DOM with default value for radios/checkboxes
-  if (elem.name === 'input' &&
-      (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
-      name === 'value') {
+  if (
+    elem.name === 'input' &&
+    (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
+    name === 'value'
+  ) {
     return 'on';
   }
 };
 
 var setAttr = function(el, name, value) {
-
   if (value === null) {
     removeAttribute(el, name);
   } else {
-    el.attribs[name] = value+'';
+    el.attribs[name] = value + '';
   }
 };
 
+/**
+ * Method for getting and setting attributes. Gets the attribute value for only
+ * the first element in the matched set. If you set an attribute's value to
+ * `null`, you remove that attribute. You may also pass a `map` and `function`
+ * like jQuery.
+ *
+ * @example
+ *
+ * $('ul').attr('id')
+ * //=> fruits
+ *
+ * $('.apple').attr('id', 'favorite').html()
+ * //=> <li class="apple" id="favorite">Apple</li>
+ *
+ * @param {string} name - Name of the attribute.
+ * @param {string} [value] - If specified sets the value of the attribute.
+ *
+ * @see {@link http://api.jquery.com/attr/}
+ */
 exports.attr = function(name, value) {
   // Set the value (with attr map support)
   if (typeof name === 'object' || value !== undefined) {
@@ -90,31 +112,45 @@ exports.attr = function(name, value) {
   return getAttr(this[0], name);
 };
 
-var getProp = function (el, name) {
+var getProp = function(el, name) {
   if (!el || !isTag(el)) return;
 
   return name in el
-      ? el[name]
-      : rboolean.test(name)
-          ? getAttr(el, name) !== undefined
-          : getAttr(el, name);
+    ? el[name]
+    : rboolean.test(name) ? getAttr(el, name) !== undefined : getAttr(el, name);
 };
 
-var setProp = function (el, name, value) {
+var setProp = function(el, name, value) {
   el[name] = rboolean.test(name) ? !!value : value;
 };
 
-exports.prop = function (name, value) {
+/**
+ * Method for getting and setting properties. Gets the property value for only
+ * the first element in the matched set.
+ *
+ * @example
+ *
+ * $('input[type="checkbox"]').prop('checked')
+ * //=> false
+ *
+ * $('input[type="checkbox"]').prop('checked', true).val()
+ * //=> ok
+ *
+ * @param {string} name - Name of the property.
+ * @param {any} [value] - If specified set the property to this.
+ *
+ * @see {@link http://api.jquery.com/prop/}
+ */
+exports.prop = function(name, value) {
   var i = 0,
       property;
 
   if (typeof name === 'string' && value === undefined) {
-
     switch (name) {
       case 'style':
         property = this.css();
 
-        _.forEach(property, function (v, p) {
+        _.forEach(property, function(v, p) {
           property[i++] = p;
         });
 
@@ -125,6 +161,12 @@ exports.prop = function (name, value) {
       case 'nodeName':
         property = this[0].name.toUpperCase();
         break;
+      case 'outerHTML':
+        property = this.clone()
+          .wrap('<container />')
+          .parent()
+          .html();
+        break;
       default:
         property = getProp(this[0], name);
     }
@@ -133,7 +175,6 @@ exports.prop = function (name, value) {
   }
 
   if (typeof name === 'object' || value !== undefined) {
-
     if (typeof value === 'function') {
       return domEach(this, function(j, el) {
         setProp(el, name, value.call(el, j, getProp(el, name)));
@@ -144,16 +185,13 @@ exports.prop = function (name, value) {
       if (!isTag(el)) return;
 
       if (typeof name === 'object') {
-
         _.forEach(name, function(val, key) {
           setProp(el, key, val);
         });
-
       } else {
         setProp(el, name, value);
       }
     });
-
   }
 };
 
@@ -201,7 +239,9 @@ var readData = function(el, name) {
       } else if (rbrace.test(value)) {
         try {
           value = JSON.parse(value);
-        } catch(e){ }
+        } catch (e) {
+          /* ignore */
+        }
       }
 
       el.data[jsName] = value;
@@ -211,6 +251,27 @@ var readData = function(el, name) {
   return readAll ? el.data : value;
 };
 
+/**
+ * Method for getting and setting data attributes. Gets or sets the data
+ * attribute value for only the first element in the matched set.
+ *
+ * @example
+ *
+ * $('<div data-apple-color="red"></div>').data()
+ * //=> { appleColor: 'red' }
+ *
+ * $('<div data-apple-color="red"></div>').data('apple-color')
+ * //=> 'red'
+ *
+ * const apple = $('.apple').data('kind', 'mac')
+ * apple.data('kind')
+ * //=> 'mac'
+ *
+ * @param {string} name - Name of the attribute.
+ * @param {any} [value] - If specified new value.
+ *
+ * @see {@link http://api.jquery.com/data/}
+ */
 exports.data = function(name, value) {
   var elem = this[0];
 
@@ -239,38 +300,47 @@ exports.data = function(name, value) {
 };
 
 /**
- * Get the value of an element
+ * Method for getting and setting the value of input, select, and textarea.
+ * Note: Support for `map`, and `function` has not been added yet.
+ *
+ * @example
+ *
+ * $('input[type="text"]').val()
+ * //=> input_text
+ *
+ * $('input[type="text"]').val('test').html()
+ * //=> <input type="text" value="test"/>
+ *
+ * @param {string} [value] - If specified new value.
+ *
+ * @see {@link http://api.jquery.com/val/}
  */
-
 exports.val = function(value) {
   var querying = arguments.length === 0,
       element = this[0];
 
-  if(!element) return;
+  if (!element) return;
 
   switch (element.name) {
     case 'textarea':
       return this.text(value);
     case 'input':
-      switch (this.attr('type')) {
-        case 'radio':
-          if (querying) {
-            return this.attr('value');
-          } else {
-            this.attr('value', value);
-            return this;
-          }
-          break;
-        default:
-          return this.attr('value', value);
+      if (this.attr('type') === 'radio') {
+        if (querying) {
+          return this.attr('value');
+        }
+
+        this.attr('value', value);
+        return this;
       }
-      return;
+
+      return this.attr('value', value);
     case 'select':
       var option = this.find('option:selected'),
           returnValue;
       if (option === undefined) return undefined;
       if (!querying) {
-        if (!this.attr().hasOwnProperty('multiple') && typeof value == 'object') {
+        if (!hasOwn.call(this.attr(), 'multiple') && typeof value == 'object') {
           return this;
         }
         if (typeof value != 'object') {
@@ -283,7 +353,7 @@ exports.val = function(value) {
         return this;
       }
       returnValue = option.attr('value');
-      if (this.attr().hasOwnProperty('multiple')) {
+      if (hasOwn.call(this.attr(), 'multiple')) {
         returnValue = [];
         domEach(option, function(__, el) {
           returnValue.push(getAttr(el, 'value'));
@@ -300,17 +370,30 @@ exports.val = function(value) {
 };
 
 /**
- * Remove an attribute
+ * Remove an attribute.
+ *
+ * @private
+ * @param {node} elem - Node to remove attribute from.
+ * @param {string} name - Name of the attribute to remove.
  */
-
 var removeAttribute = function(elem, name) {
-  if (!elem.attribs || !hasOwn.call(elem.attribs, name))
-    return;
+  if (!elem.attribs || !hasOwn.call(elem.attribs, name)) return;
 
   delete elem.attribs[name];
 };
 
-
+/**
+ * Method for removing attributes by `name`.
+ *
+ * @example
+ *
+ * $('.pear').removeAttr('class').html()
+ * //=> <li>Pear</li>
+ *
+ * @param {string} name - Name of the attribute.
+ *
+ * @see {@link http://api.jquery.com/removeAttr/}
+ */
 exports.removeAttr = function(name) {
   domEach(this, function(i, elem) {
     removeAttribute(elem, name);
@@ -319,6 +402,24 @@ exports.removeAttr = function(name) {
   return this;
 };
 
+/**
+ * Check to see if *any* of the matched elements have the given `className`.
+ *
+ * @example
+ *
+ * $('.pear').hasClass('pear')
+ * //=> true
+ *
+ * $('apple').hasClass('fruit')
+ * //=> false
+ *
+ * $('li').hasClass('pear')
+ * //=> true
+ *
+ * @param {string} className - Name of the class.
+ *
+ * @see {@link http://api.jquery.com/hasClass/}
+ */
 exports.hasClass = function(className) {
   return _.some(this, function(elem) {
     var attrs = elem.attribs,
@@ -327,11 +428,13 @@ exports.hasClass = function(className) {
         end;
 
     if (clazz && className.length) {
-      while ((idx = clazz.indexOf(className, idx+1)) > -1) {
+      while ((idx = clazz.indexOf(className, idx + 1)) > -1) {
         end = idx + className.length;
 
-        if ((idx === 0 || rspace.test(clazz[idx-1]))
-            && (end === clazz.length || rspace.test(clazz[end]))) {
+        if (
+          (idx === 0 || rspace.test(clazz[idx - 1])) &&
+          (end === clazz.length || rspace.test(clazz[end]))
+        ) {
           return true;
         }
       }
@@ -339,6 +442,22 @@ exports.hasClass = function(className) {
   });
 };
 
+/**
+ * Adds class(es) to all of the matched elements. Also accepts a `function`
+ * like jQuery.
+ *
+ * @example
+ *
+ * $('.pear').addClass('fruit').html()
+ * //=> <li class="pear fruit">Pear</li>
+ *
+ * $('.apple').addClass('fruit red').html()
+ * //=> <li class="apple fruit red">Apple</li>
+ *
+ * @param {string} value - Name of new class.
+ *
+ * @see {@link http://api.jquery.com/addClass/}
+ */
 exports.addClass = function(value) {
   // Support functions
   if (typeof value === 'function') {
@@ -354,7 +473,6 @@ exports.addClass = function(value) {
   var classNames = value.split(rspace),
       numElements = this.length;
 
-
   for (var i = 0; i < numElements; i++) {
     // If selected element isn't a tag, move on
     if (!isTag(this[i])) continue;
@@ -373,8 +491,7 @@ exports.addClass = function(value) {
       // Check if class already exists
       for (var j = 0; j < numClasses; j++) {
         var appendClass = classNames[j] + ' ';
-        if (setClass.indexOf(' ' + appendClass) < 0)
-          setClass += appendClass;
+        if (setClass.indexOf(' ' + appendClass) < 0) setClass += appendClass;
       }
 
       setAttr(this[i], 'class', setClass.trim());
@@ -388,16 +505,31 @@ var splitClass = function(className) {
   return className ? className.trim().split(rspace) : [];
 };
 
+/**
+ * Removes one or more space-separated classes from the selected elements. If
+ * no `className` is defined, all classes will be removed. Also accepts a
+ * `function` like jQuery.
+ *
+ * @example
+ *
+ * $('.pear').removeClass('pear').html()
+ * //=> <li class="">Pear</li>
+ *
+ * $('.apple').addClass('red').removeClass().html()
+ * //=> <li class="">Apple</li>
+ * @param {string} value - Name of the class.
+ *
+ * @see {@link http://api.jquery.com/removeClass/}
+ */
 exports.removeClass = function(value) {
-  var classes,
-      numClasses,
-      removeAll;
+  var classes, numClasses, removeAll;
 
   // Handle if value is a function
   if (typeof value === 'function') {
     return domEach(this, function(i, el) {
       exports.removeClass.call(
-        [el], value.call(el, i, el.attribs['class'] || '')
+        [el],
+        value.call(el, i, el.attribs['class'] || '')
       );
     });
   }
@@ -436,6 +568,24 @@ exports.removeClass = function(value) {
   });
 };
 
+/**
+ * Add or remove class(es) from the matched elements, depending on either the
+ * class's presence or the value of the switch argument. Also accepts a
+ * `function` like jQuery.
+ *
+ * @example
+ *
+ * $('.apple.green').toggleClass('fruit green red').html()
+ * //=> <li class="apple fruit red">Apple</li>
+ *
+ * $('.apple.green').toggleClass('fruit green red', true).html()
+ * //=> <li class="apple green fruit red">Apple</li>
+ *
+ * @param {(string|Function)} value - Name of the class. Can also be a function.
+ * @param {boolean} [stateVal] - If specified the state of the class.
+ *
+ * @see {@link http://api.jquery.com/toggleClass/}
+ */
 exports.toggleClass = function(value, stateVal) {
   // Support functions
   if (typeof value === 'function') {
@@ -452,11 +602,11 @@ exports.toggleClass = function(value, stateVal) {
   if (!value || typeof value !== 'string') return this;
 
   var classNames = value.split(rspace),
-    numClasses = classNames.length,
-    state = typeof stateVal === 'boolean' ? stateVal ? 1 : -1 : 0,
-    numElements = this.length,
-    elementClasses,
-    index;
+      numClasses = classNames.length,
+      state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0,
+      numElements = this.length,
+      elementClasses,
+      index;
 
   for (var i = 0; i < numElements; i++) {
     // If selected element isn't a tag, move on
@@ -484,7 +634,18 @@ exports.toggleClass = function(value, stateVal) {
   return this;
 };
 
-exports.is = function (selector) {
+/**
+ * Checks the current list of elements and returns `true` if _any_ of the
+ * elements match the selector. If using an element or Cheerio selection,
+ * returns `true` if _any_ of the elements match. If using a predicate
+ * function, the function is executed in the context of the selected element,
+ * so `this` refers to the current element.
+ *
+ * @param {string|Function|cheerio|node} selector - Selector for the selection.
+ *
+ * @see {@link http://api.jquery.com/is/}
+ */
+exports.is = function(selector) {
   if (selector) {
     return this.filter(selector).length > 0;
   }
diff --git a/lib/api/css.js b/lib/api/css.js
index d9ffae6cfa..990cb973b8 100644
--- a/lib/api/css.js
+++ b/lib/api/css.js
@@ -1,23 +1,30 @@
+/**
+ * @module css
+ */
 var domEach = require('../utils').domEach,
     _ = {
-      pick: require('lodash/pick'),
+      pick: require('lodash/pick')
     };
 
 var toString = Object.prototype.toString;
 
 /**
- * Set / Get css.
+ * Get the value of a style property for the first element in the set of
+ * matched elements or set one or more CSS properties for every matched
+ * element.
  *
- * @param {String|Object} prop
- * @param {String} val
- * @return {self}
- * @api public
+ * @param {string|Object} prop - The name of the property.
+ * @param {string} [val] - If specified the new value.
+ * @returns {self}
+ *
+ * @see {@link http://api.jquery.com/css/}
  */
-
 exports.css = function(prop, val) {
-  if (arguments.length === 2 ||
+  if (
+    arguments.length === 2 ||
     // When `prop` is a "plain" object
-    (toString.call(prop) === '[object Object]')) {
+    toString.call(prop) === '[object Object]'
+  ) {
     return domEach(this, function(idx, el) {
       setCss(el, prop, val, idx);
     });
@@ -29,13 +36,13 @@ exports.css = function(prop, val) {
 /**
  * Set styles of all elements.
  *
- * @param {String|Object} prop
- * @param {String} val
- * @param {Number} idx - optional index within the selection
- * @return {self}
- * @api private
+ * @param {Object} el - Element to set style of.
+ * @param {string|Object} prop - Name of property.
+ * @param {string} val - Value to set property to.
+ * @param {number} [idx] - Optional index within the selection.
+ * @returns {self}
+ * @private
  */
-
 function setCss(el, prop, val, idx) {
   if ('string' == typeof prop) {
     var styles = getCss(el);
@@ -51,7 +58,7 @@ function setCss(el, prop, val, idx) {
 
     el.attribs.style = stringify(styles);
   } else if ('object' == typeof prop) {
-    Object.keys(prop).forEach(function(k){
+    Object.keys(prop).forEach(function(k) {
       setCss(el, k, prop[k]);
     });
   }
@@ -60,11 +67,11 @@ function setCss(el, prop, val, idx) {
 /**
  * Get parsed styles of the first element.
  *
- * @param {String} prop
- * @return {Object}
- * @api private
+ * @param {node} el - Element to get styles from.
+ * @param {string} prop - Name of the prop.
+ * @returns {Object}
+ * @private
  */
-
 function getCss(el, prop) {
   var styles = parse(el.attribs.style);
   if (typeof prop === 'string') {
@@ -79,43 +86,33 @@ function getCss(el, prop) {
 /**
  * Stringify `obj` to styles.
  *
- * @param {Object} obj
- * @return {Object}
- * @api private
+ * @param {Object} obj - Object to stringify.
+ * @returns {Object}
+ * @private
  */
-
 function stringify(obj) {
-  return Object.keys(obj || {})
-    .reduce(function(str, prop){
-      return str += ''
-        + (str ? ' ' : '')
-        + prop
-        + ': '
-        + obj[prop]
-        + ';';
-    }, '');
+  return Object.keys(obj || {}).reduce(function(str, prop) {
+    return (str += '' + (str ? ' ' : '') + prop + ': ' + obj[prop] + ';');
+  }, '');
 }
 
 /**
  * Parse `styles`.
  *
- * @param {String} styles
- * @return {Object}
- * @api private
+ * @param {string} styles - Styles to be parsed.
+ * @returns {Object}
+ * @private
  */
-
 function parse(styles) {
   styles = (styles || '').trim();
 
   if (!styles) return {};
 
-  return styles
-    .split(';')
-    .reduce(function(obj, str){
-      var n = str.indexOf(':');
-      // skip if there is no :, or if it is the first/last character
-      if (n < 1 || n === str.length-1) return obj;
-      obj[str.slice(0,n).trim()] = str.slice(n+1).trim();
-      return obj;
-    }, {});
+  return styles.split(';').reduce(function(obj, str) {
+    var n = str.indexOf(':');
+    // skip if there is no :, or if it is the first/last character
+    if (n < 1 || n === str.length - 1) return obj;
+    obj[str.slice(0, n).trim()] = str.slice(n + 1).trim();
+    return obj;
+  }, {});
 }
diff --git a/lib/api/forms.js b/lib/api/forms.js
index b66f162cd9..ade2adaded 100644
--- a/lib/api/forms.js
+++ b/lib/api/forms.js
@@ -1,3 +1,6 @@
+/**
+ * @module forms
+ */
 // https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
 // https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
 var submittableSelector = 'input,select,textarea,keygen',
@@ -7,6 +10,11 @@ var submittableSelector = 'input,select,textarea,keygen',
       map: require('lodash/map')
     };
 
+/**
+ * Encode a set of form elements as a string for submission.
+ *
+ * @see {@link http://api.jquery.com/serialize/}
+ */
 exports.serialize = function() {
   // Convert form elements into name/value objects
   var arr = this.serializeArray();
@@ -20,26 +28,37 @@ exports.serialize = function() {
   return retArr.join('&').replace(r20, '+');
 };
 
+/**
+ * Encode a set of form elements as an array of names and values.
+ *
+ * @example
+ * $('<form><input name="foo" value="bar" /></form>').serializeArray()
+ * //=> [ { name: 'foo', value: 'bar' } ]
+ *
+ * @see {@link http://api.jquery.com/serializeArray/}
+ */
 exports.serializeArray = function() {
   // Resolve all form elements from either forms or collections of form elements
   var Cheerio = this.constructor;
   return this.map(function() {
-      var elem = this;
-      var $elem = Cheerio(elem);
-      if (elem.name === 'form') {
-        return $elem.find(submittableSelector).toArray();
-      } else {
-        return $elem.filter(submittableSelector).toArray();
-      }
-    }).filter(
-        // Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
-        '[name!=""]:not(:disabled)'
+    var elem = this;
+    var $elem = Cheerio(elem);
+    if (elem.name === 'form') {
+      return $elem.find(submittableSelector).toArray();
+    } else {
+      return $elem.filter(submittableSelector).toArray();
+    }
+  })
+    .filter(
+      // Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
+      '[name!=""]:not(:disabled)' +
         // and cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
-        + ':not(:submit, :button, :image, :reset, :file)'
+        ':not(:submit, :button, :image, :reset, :file)' +
         // and are either checked/don't have a checkable state
-        + ':matches([checked], :not(:checkbox, :radio))'
-    // Convert each of the elements to its value(s)
-    ).map(function(i, elem) {
+        ':matches([checked], :not(:checkbox, :radio))'
+      // Convert each of the elements to its value(s)
+    )
+    .map(function(i, elem) {
       var $elem = Cheerio(elem);
       var name = $elem.attr('name');
       var value = $elem.val();
@@ -54,12 +73,13 @@ exports.serializeArray = function() {
         return _.map(value, function(val) {
           // We trim replace any line endings (e.g. `\r` or `\r\n` with `\r\n`) to guarantee consistency across platforms
           //   These can occur inside of `<textarea>'s`
-          return {name: name, value: val.replace( rCRLF, '\r\n' )};
+          return { name: name, value: val.replace(rCRLF, '\r\n') };
         });
-      // Otherwise (e.g. `<input type="text">`, return only one key/value pair
+        // Otherwise (e.g. `<input type="text">`, return only one key/value pair
       } else {
-        return {name: name, value: value.replace( rCRLF, '\r\n' )};
+        return { name: name, value: value.replace(rCRLF, '\r\n') };
       }
-    // Convert our result to an array
-    }).get();
+      // Convert our result to an array
+    })
+    .get();
 };
diff --git a/lib/api/manipulation.js b/lib/api/manipulation.js
index 09b9b43725..fb47943648 100644
--- a/lib/api/manipulation.js
+++ b/lib/api/manipulation.js
@@ -1,5 +1,11 @@
+/**
+ * Methods for modifying the DOM structure.
+ *
+ * @module manipulation
+ */
 var parse = require('../parse'),
-    $ = require('../static'),
+    html = require('../static').html,
+    text = require('../static').text,
     updateDOM = parse.update,
     evaluate = parse.evaluate,
     utils = require('../utils'),
@@ -13,19 +19,27 @@ var parse = require('../parse'),
       forEach: require('lodash/forEach')
     };
 
-// Create an array of nodes, recursing into arrays and parsing strings if
-// necessary
+/**
+ * Create an array of nodes, recursing into arrays and parsing strings if
+ * necessary.
+ *
+ * @param {cheerio|string|cheerio[]|string[]} [elem] - Elements to make an array of.
+ * @param {boolean} [clone] - Optionally clone nodes.
+ * @private
+ */
 exports._makeDomArray = function makeDomArray(elem, clone) {
   if (elem == null) {
     return [];
   } else if (elem.cheerio) {
     return clone ? cloneDom(elem.get(), elem.options) : elem.get();
   } else if (Array.isArray(elem)) {
-    return _.flatten(elem.map(function(el) {
-      return this._makeDomArray(el, clone);
-    }, this));
+    return _.flatten(
+      elem.map(function(el) {
+        return this._makeDomArray(el, clone);
+      }, this)
+    );
   } else if (typeof elem === 'string') {
-    return evaluate(elem, this.options);
+    return evaluate(elem, this.options, false);
   } else {
     return clone ? cloneDom([elem]) : [elem];
   }
@@ -40,7 +54,7 @@ var _insert = function(concatenator) {
       var dom, domSrc;
 
       if (typeof elems[0] === 'function') {
-        domSrc = elems[0].call(el, i, $.html(el.children));
+        domSrc = elems[0].call(el, i, html(el.children));
       } else {
         domSrc = elems;
       }
@@ -60,7 +74,7 @@ var _insert = function(concatenator) {
  * @param {Number} spliceCount Number of elements to remove from the array.
  * @param {Array} newElems Elements to insert into the array.
  *
- * @api private
+ * @private
  */
 var uniqueSplice = function(array, spliceIdx, spliceCount, newElems, parent) {
   var spliceArgs = [spliceIdx, spliceCount].concat(newElems),
@@ -106,9 +120,33 @@ var uniqueSplice = function(array, spliceIdx, spliceCount, newElems, parent) {
   return array.splice.apply(array, spliceArgs);
 };
 
+/**
+ * Insert every element in the set of matched elements to the end of the
+ * target.
+ *
+ * @param {string|cheerio} target - Element to append elements to.
+ *
+ * @example
+ *
+ * $('<li class="plum">Plum</li>').appendTo('#fruits')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/appendTo/}
+ */
 exports.appendTo = function(target) {
   if (!target.cheerio) {
-    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
+    target = this.constructor.call(
+      this.constructor,
+      target,
+      null,
+      this._originalRoot
+    );
   }
 
   target.append(this);
@@ -116,9 +154,33 @@ exports.appendTo = function(target) {
   return this;
 };
 
+/**
+ * Insert every element in the set of matched elements to the beginning of the
+ * target.
+ *
+ * @param {string|cheerio} target - Element to prepend elements to.
+ *
+ * @example
+ *
+ * $('<li class="plum">Plum</li>').prependTo('#fruits')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/prependTo/}
+ */
 exports.prependTo = function(target) {
   if (!target.cheerio) {
-    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
+    target = this.constructor.call(
+      this.constructor,
+      target,
+      null,
+      this._originalRoot
+    );
   }
 
   target.prepend(this);
@@ -126,65 +188,166 @@ exports.prependTo = function(target) {
   return this;
 };
 
+/**
+ * Inserts content as the *last* child of each of the selected elements.
+ *
+ * @method
+ *
+ * @example
+ *
+ * $('ul').append('<li class="plum">Plum</li>')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/append/}
+ */
 exports.append = _insert(function(dom, children, parent) {
   uniqueSplice(children, children.length, 0, dom, parent);
 });
 
+/**
+ * Inserts content as the *first* child of each of the selected elements.
+ *
+ * @method
+ *
+ * @example
+ *
+ * $('ul').prepend('<li class="plum">Plum</li>')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/prepend/}
+ */
 exports.prepend = _insert(function(dom, children, parent) {
   uniqueSplice(children, 0, 0, dom, parent);
 });
 
+/**
+ * The .wrap() function can take any string or object that could be passed to
+ * the $() factory function to specify a DOM structure. This structure may be
+ * nested several levels deep, but should contain only one inmost element. A
+ * copy of this structure will be wrapped around each of the elements in the
+ * set of matched elements. This method returns the original set of elements
+ * for chaining purposes.
+ *
+ * @param {cheerio} wrapper - The DOM structure to wrap around each element in the selection.
+ *
+ * @example
+ *
+ * const redFruit = $('<div class="red-fruit"></div>')
+ * $('.apple').wrap(redFruit)
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="red-fruit">
+ * //      <li class="apple">Apple</li>
+ * //     </div>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ *
+ * const healthy = $('<div class="healthy"></div>')
+ * $('li').wrap(healthy)
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="healthy">
+ * //       <li class="apple">Apple</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //       <li class="orange">Orange</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //        <li class="plum">Plum</li>
+ * //     </div>
+ * //   </ul>
+ *
+ * @see {@link http://api.jquery.com/wrap/}
+ */
 exports.wrap = function(wrapper) {
   var wrapperFn = typeof wrapper === 'function' && wrapper,
       lastIdx = this.length - 1;
 
-  _.forEach(this, _.bind(function(el, i) {
-    var parent = el.parent || el.root,
-        siblings = parent.children,
-        wrapperDom, elInsertLocation, j, index;
-
-    if (!parent) {
-      return;
-    }
-
-    if (wrapperFn) {
-      wrapper = wrapperFn.call(el, i);
-    }
-
-    if (typeof wrapper === 'string' && !isHtml(wrapper)) {
-      wrapper = this.parents().last().find(wrapper).clone();
-    }
+  _.forEach(
+    this,
+    _.bind(function(el, i) {
+      var parent = el.parent || el.root,
+          siblings = parent.children,
+          wrapperDom,
+          elInsertLocation,
+          j,
+          index;
+
+      if (!parent) {
+        return;
+      }
 
-    wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
-    elInsertLocation = wrapperDom[0];
-    // Find the deepest child. Only consider the first tag child of each node
-    // (ignore text); stop if no children are found.
-    j = 0;
+      if (wrapperFn) {
+        wrapper = wrapperFn.call(el, i);
+      }
 
-    while (elInsertLocation && elInsertLocation.children) {
-      if (j >= elInsertLocation.children.length) {
-        break;
+      if (typeof wrapper === 'string' && !isHtml(wrapper)) {
+        wrapper = this.parents()
+          .last()
+          .find(wrapper)
+          .clone();
       }
 
-      if (elInsertLocation.children[j].type === 'tag') {
-        elInsertLocation = elInsertLocation.children[j];
-        j=0;
-      } else {
-        j++;
+      wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
+      elInsertLocation = wrapperDom[0];
+      // Find the deepest child. Only consider the first tag child of each node
+      // (ignore text); stop if no children are found.
+      j = 0;
+
+      while (elInsertLocation && elInsertLocation.children) {
+        if (j >= elInsertLocation.children.length) {
+          break;
+        }
+
+        if (elInsertLocation.children[j].type === 'tag') {
+          elInsertLocation = elInsertLocation.children[j];
+          j = 0;
+        } else {
+          j++;
+        }
       }
-    }
-    index = siblings.indexOf(el);
+      index = siblings.indexOf(el);
 
-    updateDOM([el], elInsertLocation);
-    // The previous operation removed the current element from the `siblings`
-    // array, so the `dom` array can be inserted without removing any
-    // additional elements.
-    uniqueSplice(siblings, index, 0, wrapperDom, parent);
-  }, this));
+      updateDOM([el], elInsertLocation);
+      // The previous operation removed the current element from the `siblings`
+      // array, so the `dom` array can be inserted without removing any
+      // additional elements.
+      uniqueSplice(siblings, index, 0, wrapperDom, parent);
+    }, this)
+  );
 
   return this;
 };
 
+/**
+ * Insert content next to each element in the set of matched elements.
+ *
+ * @example
+ *
+ * $('.apple').after('<li class="plum">Plum</li>')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/after/}
+ */
 exports.after = function() {
   var elems = slice.call(arguments),
       lastIdx = this.length - 1;
@@ -197,13 +360,14 @@ exports.after = function() {
 
     var siblings = parent.children,
         index = siblings.indexOf(el),
-        domSrc, dom;
+        domSrc,
+        dom;
 
     // If not found, move on
     if (index < 0) return;
 
     if (typeof elems[0] === 'function') {
-      domSrc = elems[0].call(el, i, $.html(el.children));
+      domSrc = elems[0].call(el, i, html(el.children));
     } else {
       domSrc = elems;
     }
@@ -216,11 +380,34 @@ exports.after = function() {
   return this;
 };
 
+/**
+ * Insert every element in the set of matched elements after the target.
+ *
+ * @example
+ *
+ * $('<li class="plum">Plum</li>').insertAfter('.apple')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @param {string|cheerio} target - Element to insert elements after.
+ *
+ * @see {@link http://api.jquery.com/insertAfter/}
+ */
 exports.insertAfter = function(target) {
   var clones = [],
       self = this;
   if (typeof target === 'string') {
-    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
+    target = this.constructor.call(
+      this.constructor,
+      target,
+      null,
+      this._originalRoot
+    );
   }
   target = this._makeDomArray(target);
   self.remove();
@@ -244,6 +431,22 @@ exports.insertAfter = function(target) {
   return this.constructor.call(this.constructor, this._makeDomArray(clones));
 };
 
+/**
+ * Insert content previous to each element in the set of matched elements.
+ *
+ * @example
+ *
+ * $('.apple').before('<li class="plum">Plum</li>')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @see {@link http://api.jquery.com/before/}
+ */
 exports.before = function() {
   var elems = slice.call(arguments),
       lastIdx = this.length - 1;
@@ -256,13 +459,14 @@ exports.before = function() {
 
     var siblings = parent.children,
         index = siblings.indexOf(el),
-        domSrc, dom;
+        domSrc,
+        dom;
 
     // If not found, move on
     if (index < 0) return;
 
     if (typeof elems[0] === 'function') {
-      domSrc = elems[0].call(el, i, $.html(el.children));
+      domSrc = elems[0].call(el, i, html(el.children));
     } else {
       domSrc = elems;
     }
@@ -276,11 +480,34 @@ exports.before = function() {
   return this;
 };
 
+/**
+ * Insert every element in the set of matched elements before the target.
+ *
+ * @example
+ *
+ * $('<li class="plum">Plum</li>').insertBefore('.apple')
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ *
+ * @param {string|cheerio} target - Element to insert elements before.
+ *
+ * @see {@link http://api.jquery.com/insertBefore/}
+ */
 exports.insertBefore = function(target) {
   var clones = [],
       self = this;
   if (typeof target === 'string') {
-    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
+    target = this.constructor.call(
+      this.constructor,
+      target,
+      null,
+      this._originalRoot
+    );
   }
   target = this._makeDomArray(target);
   self.remove();
@@ -304,15 +531,28 @@ exports.insertBefore = function(target) {
   return this.constructor.call(this.constructor, this._makeDomArray(clones));
 };
 
-/*
-  remove([selector])
-*/
+/**
+ * Removes the set of matched elements from the DOM and all their children.
+ * `selector` filters the set of matched elements to be removed.
+ *
+ * @example
+ *
+ * $('.pear').remove()
+ * $.html()
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //    </ul>
+ *
+ * @param {string} [selector] - Optional selector for elements to remove.
+ *
+ * @see {@link http://api.jquery.com/remove/}
+ */
 exports.remove = function(selector) {
   var elems = this;
 
   // Filter if we have selector
-  if (selector)
-    elems = elems.filter(selector);
+  if (selector) elems = elems.filter(selector);
 
   domEach(elems, function(i, el) {
     var parent = el.parent || el.root;
@@ -338,6 +578,24 @@ exports.remove = function(selector) {
   return this;
 };
 
+/**
+ * Replaces matched elements with `content`.
+ *
+ * @example
+ *
+ * const plum = $('<li class="plum">Plum</li>')
+ * $('.pear').replaceWith(plum)
+ * $.html()
+ * //=> <ul id="fruits">
+ * //     <li class="apple">Apple</li>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ *
+ * @param {cheerio|Function} content - Replacement for matched elements.
+ *
+ * @see {@link http://api.jquery.com/replaceWith/}
+ */
 exports.replaceWith = function(content) {
   var self = this;
 
@@ -348,7 +606,9 @@ exports.replaceWith = function(content) {
     }
 
     var siblings = parent.children,
-        dom = self._makeDomArray(typeof content === 'function' ? content.call(el, i, el) : content),
+        dom = self._makeDomArray(
+          typeof content === 'function' ? content.call(el, i, el) : content
+        ),
         index;
 
     // In the case that `dom` contains nodes that already exist in other
@@ -365,6 +625,17 @@ exports.replaceWith = function(content) {
   return this;
 };
 
+/**
+ * Empties an element, removing all its children.
+ *
+ * @example
+ *
+ * $('ul').empty()
+ * $.html()
+ * //=>  <ul id="fruits"></ul>
+ *
+ * @see {@link http://api.jquery.com/empty/}
+ */
 exports.empty = function() {
   domEach(this, function(i, el) {
     _.forEach(el.children, function(child) {
@@ -377,12 +648,26 @@ exports.empty = function() {
 };
 
 /**
- * Set/Get the HTML
+ * Gets an HTML content string from the first selected element. If `htmlString`
+ * is specified, each selected element's content is replaced by the new
+ * content.
+ *
+ * @param {string} str - If specified used to replace selection's contents.
+ *
+ * @example
+ *
+ * $('.orange').html()
+ * //=> Orange
+ *
+ * $('#fruits').html('<li class="mango">Mango</li>').html()
+ * //=> <li class="mango">Mango</li>
+ *
+ * @see {@link http://api.jquery.com/html/}
  */
 exports.html = function(str) {
   if (str === undefined) {
     if (!this[0] || !this[0].children) return null;
-    return $.html(this[0].children, this.options);
+    return html(this[0].children, this.options);
   }
 
   var opts = this.options;
@@ -392,7 +677,9 @@ exports.html = function(str) {
       child.next = child.prev = child.parent = null;
     });
 
-    var content = str.cheerio ? str.clone().get() : evaluate('' + str, opts);
+    var content = str.cheerio
+      ? str.clone().get()
+      : evaluate('' + str, opts, false);
 
     updateDOM(content, el);
   });
@@ -401,42 +688,66 @@ exports.html = function(str) {
 };
 
 exports.toString = function() {
-  return $.html(this, this.options);
+  return html(this, this.options);
 };
 
+/**
+ * Get the combined text contents of each element in the set of matched
+ * elements, including their descendants. If `textString` is specified, each
+ * selected element's content is replaced by the new text content.
+ *
+ * @param {string} [str] - If specified replacement for the selected element's contents.
+ *
+ * @example
+ *
+ * $('.orange').text()
+ * //=> Orange
+ *
+ * $('ul').text()
+ * //=>  Apple
+ * //    Orange
+ * //    Pear
+ *
+ * @see {@link http://api.jquery.com/text/}
+ */
 exports.text = function(str) {
   // If `str` is undefined, act as a "getter"
   if (str === undefined) {
-    return $.text(this);
+    return text(this);
   } else if (typeof str === 'function') {
     // Function support
+    var self = this;
     return domEach(this, function(i, el) {
-      var $el = [el];
-      return exports.text.call($el, str.call(el, i, $.text($el)));
+      return exports.text.call(self._make(el), str.call(el, i, text([el])));
     });
   }
 
+  var opts = this.options;
+
   // Append text node to each selected elements
   domEach(this, function(i, el) {
     _.forEach(el.children, function(child) {
       child.next = child.prev = child.parent = null;
     });
 
-    var elem = {
-      data: '' + str,
-      type: 'text',
-      parent: el,
-      prev: null,
-      next: null,
-      children: []
-    };
+    var textNode = evaluate(' ', opts)[0];
+    textNode.data = str;
 
-    updateDOM(elem, el);
+    updateDOM(textNode, el);
   });
 
   return this;
 };
 
+/**
+ * Clone the cheerio object.
+ *
+ * @example
+ *
+ * const moreFruit = $('#fruits').clone()
+ *
+ * @see {@link http://api.jquery.com/clone/}
+ */
 exports.clone = function() {
   return this._make(cloneDom(this.get(), this.options));
 };
diff --git a/lib/api/traversing.js b/lib/api/traversing.js
index 6722361d1a..2ee1d84477 100644
--- a/lib/api/traversing.js
+++ b/lib/api/traversing.js
@@ -1,3 +1,8 @@
+/**
+ * Methods for traversing the DOM structure.
+ *
+ * @module traversing
+ */
 var select = require('css-select'),
     utils = require('../utils'),
     domEach = utils.domEach,
@@ -11,10 +16,29 @@ var select = require('css-select'),
       reduce: require('lodash/reduce')
     };
 
+/**
+ * Get the descendants of each element in the current set of matched elements,
+ * filtered by a selector, jQuery object, or element.
+ *
+ * @example
+ *
+ * $('#fruits').find('li').length
+ * //=> 3
+ * $('#fruits').find($('.apple')).length
+ * //=> 1
+ *
+ * @param {string|cheerio|node} selectorOrHaystack  - Element to look for.
+ *
+ * @see {@link http://api.jquery.com/find/}
+ */
 exports.find = function(selectorOrHaystack) {
-  var elems = _.reduce(this, function(memo, elem) {
-    return memo.concat(_.filter(elem.children, isTag));
-  }, []);
+  var elems = _.reduce(
+    this,
+    function(memo, elem) {
+      return memo.concat(_.filter(elem.children, isTag));
+    },
+    []
+  );
   var contains = this.constructor.contains;
   var haystack;
 
@@ -25,23 +49,36 @@ exports.find = function(selectorOrHaystack) {
       haystack = [selectorOrHaystack];
     }
 
-    return this._make(haystack.filter(function(elem) {
-      var idx, len;
-      for (idx = 0, len = this.length; idx < len; ++idx) {
-        if (contains(this[idx], elem)) {
-          return true;
+    return this._make(
+      haystack.filter(function(elem) {
+        var idx, len;
+        for (idx = 0, len = this.length; idx < len; ++idx) {
+          if (contains(this[idx], elem)) {
+            return true;
+          }
         }
-      }
-    }, this));
+      }, this)
+    );
   }
 
-  var options = {__proto__: this.options, context: this.toArray()};
+  var options = { __proto__: this.options, context: this.toArray() };
 
   return this._make(select(selectorOrHaystack, elems, options));
 };
 
-// Get the parent of each element in the current set of matched elements,
-// optionally filtered by a selector.
+/**
+ * Get the parent of each element in the current set of matched elements,
+ * optionally filtered by a selector.
+ *
+ * @example
+ *
+ * $('.pear').parent().attr('id')
+ * //=> fruits
+ *
+ * @param {string} [selector] - If specified filter for parent.
+ *
+ * @see {@link http://api.jquery.com/parent/}
+ */
 exports.parent = function(selector) {
   var set = [];
 
@@ -59,27 +96,61 @@ exports.parent = function(selector) {
   return this._make(set);
 };
 
+/**
+ * Get a set of parents filtered by `selector` of each element in the current
+ * set of match elements.
+ *
+ * @example
+ *
+ * $('.orange').parents().length
+ * // => 2
+ * $('.orange').parents('#fruits').length
+ * // => 1
+ *
+ * @param {string} [selector] - If specified filter for parents.
+ *
+ * @see {@link http://api.jquery.com/parents/}
+ */
 exports.parents = function(selector) {
   var parentNodes = [];
 
   // When multiple DOM elements are in the original set, the resulting set will
   // be in *reverse* order of the original elements as well, with duplicates
   // removed.
-  this.get().reverse().forEach(function(elem) {
-    traverseParents(this, elem.parent, selector, Infinity)
-      .forEach(function(node) {
+  this.get()
+    .reverse()
+    .forEach(function(elem) {
+      traverseParents(this, elem.parent, selector, Infinity).forEach(function(
+        node
+      ) {
         if (parentNodes.indexOf(node) === -1) {
           parentNodes.push(node);
         }
-      }
-    );
-  }, this);
+      });
+    }, this);
 
   return this._make(parentNodes);
 };
 
+/**
+ * Get the ancestors of each element in the current set of matched elements, up
+ * to but not including the element matched by the selector, DOM node, or
+ * cheerio object.
+ *
+ * @example
+ *
+ * $('.orange').parentsUntil('#food').length
+ * // => 1
+ *
+ * @param {string|node|cheerio} selector - Selector for element to stop at.
+ * @param {string|Function} [filter] - Optional filter for parents.
+ *
+ * @see {@link http://api.jquery.com/parentsUntil/}
+ */
 exports.parentsUntil = function(selector, filter) {
-  var parentNodes = [], untilNode, untilNodes;
+  var parentNodes = [],
+      untilNode,
+      untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.parents().toArray(), this.options)[0];
@@ -93,24 +164,49 @@ exports.parentsUntil = function(selector, filter) {
   // be in *reverse* order of the original elements as well, with duplicates
   // removed.
 
-  this.toArray().reverse().forEach(function(elem) {
-    while ((elem = elem.parent)) {
-      if ((untilNode && elem !== untilNode) ||
-        (untilNodes && untilNodes.indexOf(elem) === -1) ||
-        (!untilNode && !untilNodes)) {
-        if (isTag(elem) && parentNodes.indexOf(elem) === -1) { parentNodes.push(elem); }
-      } else {
-        break;
+  this.toArray()
+    .reverse()
+    .forEach(function(elem) {
+      while ((elem = elem.parent)) {
+        if (
+          (untilNode && elem !== untilNode) ||
+          (untilNodes && untilNodes.indexOf(elem) === -1) ||
+          (!untilNode && !untilNodes)
+        ) {
+          if (isTag(elem) && parentNodes.indexOf(elem) === -1) {
+            parentNodes.push(elem);
+          }
+        } else {
+          break;
+        }
       }
-    }
-  }, this);
+    }, this);
 
-  return this._make(filter ? select(filter, parentNodes, this.options) : parentNodes);
+  return this._make(
+    filter ? select(filter, parentNodes, this.options) : parentNodes
+  );
 };
 
-// For each element in the set, get the first element that matches the selector
-// by testing the element itself and traversing up through its ancestors in the
-// DOM tree.
+/**
+ * For each element in the set, get the first element that matches the selector
+ * by testing the element itself and traversing up through its ancestors in
+ * the DOM tree.
+ *
+ * @example
+ *
+ * $('.orange').closest()
+ * // => []
+ * $('.orange').closest('.apple')
+ * // => []
+ * $('.orange').closest('li')
+ * // => [<li class="orange">Orange</li>]
+ * $('.orange').closest('#fruits')
+ * // => [<ul id="fruits"> ... </ul>]
+ *
+ * @param {string} [selector] - Selector for the element to find.
+ *
+ * @see {@link http://api.jquery.com/closest/}
+ */
 exports.closest = function(selector) {
   var set = [];
 
@@ -118,20 +214,38 @@ exports.closest = function(selector) {
     return this._make(set);
   }
 
-  domEach(this, function(idx, elem) {
-    var closestElem = traverseParents(this, elem, selector, 1)[0];
+  domEach(
+    this,
+    function(idx, elem) {
+      var closestElem = traverseParents(this, elem, selector, 1)[0];
 
-    // Do not add duplicate elements to the set
-    if (closestElem && set.indexOf(closestElem) < 0) {
-      set.push(closestElem);
-    }
-  }.bind(this));
+      // Do not add duplicate elements to the set
+      if (closestElem && set.indexOf(closestElem) < 0) {
+        set.push(closestElem);
+      }
+    }.bind(this)
+  );
 
   return this._make(set);
 };
 
+/**
+ * Gets the next sibling of the first selected element, optionally filtered by
+ * a selector.
+ *
+ * @example
+ *
+ * $('.apple').next().hasClass('orange')
+ * //=> true
+ *
+ * @param {string} [selector] - If specified filter for sibling.
+ *
+ * @see {@link http://api.jquery.com/next/}
+ */
 exports.next = function(selector) {
-  if (!this[0]) { return this; }
+  if (!this[0]) {
+    return this;
+  }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -143,13 +257,30 @@ exports.next = function(selector) {
     }
   });
 
-  return selector ?
-    exports.filter.call(elems, selector, this) :
-    this._make(elems);
+  return selector
+    ? exports.filter.call(elems, selector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets all the following siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @example
+ *
+ * $('.apple').nextAll()
+ * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
+ * $('.apple').nextAll('.orange')
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * @param {string} [selector] - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/nextAll/}
+ */
 exports.nextAll = function(selector) {
-  if (!this[0]) { return this; }
+  if (!this[0]) {
+    return this;
+  }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -160,14 +291,32 @@ exports.nextAll = function(selector) {
     }
   });
 
-  return selector ?
-    exports.filter.call(elems, selector, this) :
-    this._make(elems);
+  return selector
+    ? exports.filter.call(elems, selector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets all the following siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @example
+ *
+ * $('.apple').nextUntil('.pear')
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * @param {string|cheerio|node} selector - Selector for element to stop at.
+ * @param {string} [filterSelector]  - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/nextUntil/}
+ */
 exports.nextUntil = function(selector, filterSelector) {
-  if (!this[0]) { return this; }
-  var elems = [], untilNode, untilNodes;
+  if (!this[0]) {
+    return this;
+  }
+  var elems = [],
+      untilNode,
+      untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.nextAll().get(), this.options)[0];
@@ -179,9 +328,11 @@ exports.nextUntil = function(selector, filterSelector) {
 
   _.forEach(this, function(elem) {
     while ((elem = elem.next)) {
-      if ((untilNode && elem !== untilNode) ||
+      if (
+        (untilNode && elem !== untilNode) ||
         (untilNodes && untilNodes.indexOf(elem) === -1) ||
-        (!untilNode && !untilNodes)) {
+        (!untilNode && !untilNodes)
+      ) {
         if (isTag(elem) && elems.indexOf(elem) === -1) {
           elems.push(elem);
         }
@@ -191,13 +342,28 @@ exports.nextUntil = function(selector, filterSelector) {
     }
   });
 
-  return filterSelector ?
-    exports.filter.call(elems, filterSelector, this) :
-    this._make(elems);
+  return filterSelector
+    ? exports.filter.call(elems, filterSelector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets the previous sibling of the first selected element optionally filtered
+ * by a selector.
+ *
+ * @example
+ *
+ * $('.orange').prev().hasClass('apple')
+ * //=> true
+ *
+ * @param {string} [selector]  - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/prev/}
+ */
 exports.prev = function(selector) {
-  if (!this[0]) { return this; }
+  if (!this[0]) {
+    return this;
+  }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -209,13 +375,30 @@ exports.prev = function(selector) {
     }
   });
 
-  return selector ?
-    exports.filter.call(elems, selector, this) :
-    this._make(elems);
+  return selector
+    ? exports.filter.call(elems, selector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets all the preceding siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @example
+ *
+ * $('.pear').prevAll()
+ * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
+ * $('.pear').prevAll('.orange')
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * @param {string} [selector]  - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/prevAll/}
+ */
 exports.prevAll = function(selector) {
-  if (!this[0]) { return this; }
+  if (!this[0]) {
+    return this;
+  }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -226,14 +409,32 @@ exports.prevAll = function(selector) {
     }
   });
 
-  return selector ?
-    exports.filter.call(elems, selector, this) :
-    this._make(elems);
+  return selector
+    ? exports.filter.call(elems, selector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets all the preceding siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @example
+ *
+ * $('.pear').prevUntil('.apple')
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * @param {string|cheerio|node} selector - Selector for element to stop at.
+ * @param {string} [filterSelector]  - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/prevUntil/}
+ */
 exports.prevUntil = function(selector, filterSelector) {
-  if (!this[0]) { return this; }
-  var elems = [], untilNode, untilNodes;
+  if (!this[0]) {
+    return this;
+  }
+  var elems = [],
+      untilNode,
+      untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.prevAll().get(), this.options)[0];
@@ -245,9 +446,11 @@ exports.prevUntil = function(selector, filterSelector) {
 
   _.forEach(this, function(elem) {
     while ((elem = elem.prev)) {
-      if ((untilNode && elem !== untilNode) ||
+      if (
+        (untilNode && elem !== untilNode) ||
         (untilNodes && untilNodes.indexOf(elem) === -1) ||
-        (!untilNode && !untilNodes)) {
+        (!untilNode && !untilNodes)
+      ) {
         if (isTag(elem) && elems.indexOf(elem) === -1) {
           elems.push(elem);
         }
@@ -257,17 +460,34 @@ exports.prevUntil = function(selector, filterSelector) {
     }
   });
 
-  return filterSelector ?
-    exports.filter.call(elems, filterSelector, this) :
-    this._make(elems);
+  return filterSelector
+    ? exports.filter.call(elems, filterSelector, this)
+    : this._make(elems);
 };
 
+/**
+ * Gets the first selected element's siblings, excluding itself.
+ *
+ * @example
+ *
+ * $('.pear').siblings().length
+ * //=> 2
+ *
+ * $('.pear').siblings('.orange').length
+ * //=> 1
+ *
+ * @param {string} [selector]  - If specified filter for siblings.
+ *
+ * @see {@link http://api.jquery.com/siblings/}
+ */
 exports.siblings = function(selector) {
   var parent = this.parent();
 
   var elems = _.filter(
     parent ? parent.children() : this.siblingsAndMe(),
-    _.bind(function(elem) { return isTag(elem) && !this.is(elem); }, this)
+    _.bind(function(elem) {
+      return isTag(elem) && !this.is(elem);
+    }, this)
   );
 
   if (selector !== undefined) {
@@ -277,35 +497,119 @@ exports.siblings = function(selector) {
   }
 };
 
+/**
+ * Gets the children of the first selected element.
+ *
+ * @example
+ *
+ * $('#fruits').children().length
+ * //=> 3
+ *
+ * $('#fruits').children('.pear').text()
+ * //=> Pear
+ *
+ * @param {string} [selector]  - If specified filter for children.
+ *
+ * @see {@link http://api.jquery.com/children/}
+ */
 exports.children = function(selector) {
-
-  var elems = _.reduce(this, function(memo, elem) {
-    return memo.concat(_.filter(elem.children, isTag));
-  }, []);
+  var elems = _.reduce(
+    this,
+    function(memo, elem) {
+      return memo.concat(_.filter(elem.children, isTag));
+    },
+    []
+  );
 
   if (selector === undefined) return this._make(elems);
 
   return exports.filter.call(elems, selector, this);
 };
 
+/**
+ * Gets the children of each element in the set of matched elements, including
+ * text and comment nodes.
+ *
+ * @example
+ *
+ * $('#fruits').contents().length
+ * //=> 3
+ *
+ * @see {@link http://api.jquery.com/contents/}
+ */
 exports.contents = function() {
-  return this._make(_.reduce(this, function(all, elem) {
-    all.push.apply(all, elem.children);
-    return all;
-  }, []));
+  return this._make(
+    _.reduce(
+      this,
+      function(all, elem) {
+        all.push.apply(all, elem.children);
+        return all;
+      },
+      []
+    )
+  );
 };
 
+/**
+ * Iterates over a cheerio object, executing a function for each matched
+ * element. When the callback is fired, the function is fired in the context of
+ * the DOM element, so `this` refers to the current element, which is
+ * equivalent to the function parameter `element`. To break out of the `each`
+ * loop early, return with `false`.
+ *
+ * @example
+ *
+ * const fruits = [];
+ *
+ * $('li').each(function(i, elem) {
+ *   fruits[i] = $(this).text();
+ * });
+ *
+ * fruits.join(', ');
+ * //=> Apple, Orange, Pear
+ *
+ * @param {Function} fn  - Function to execute.
+ *
+ * @see {@link http://api.jquery.com/each/}
+ */
 exports.each = function(fn) {
-  var i = 0, len = this.length;
+  var i = 0,
+      len = this.length;
   while (i < len && fn.call(this[i], i, this[i]) !== false) ++i;
   return this;
 };
 
+/**
+ * Pass each element in the current matched set through a function, producing a
+ * new Cheerio object containing the return values. The function can return an
+ * individual data item or an array of data items to be inserted into the
+ * resulting set. If an array is returned, the elements inside the array are
+ * inserted into the set. If the function returns null or undefined, no element
+ * will be inserted.
+ *
+ * @example
+ *
+ * $('li').map(function(i, el) {
+ *   // this === el
+ *   return $(this).text();
+ * }).get().join(' ');
+ * //=> "apple orange pear"
+ *
+ * @param {Function} fn  - Function to execute.
+ *
+ * @see {@link http://api.jquery.com/map/}
+ */
 exports.map = function(fn) {
-  return this._make(_.reduce(this, function(memo, el, i) {
-    var val = fn.call(el, i, el);
-    return val == null ? memo : memo.concat(val);
-  }, []));
+  return this._make(
+    _.reduce(
+      this,
+      function(memo, el, i) {
+        var val = fn.call(el, i, el);
+        return val == null ? memo : memo.concat(val);
+      },
+      []
+    )
+  );
 };
 
 var makeFilterMethod = function(filterFn) {
@@ -331,9 +635,82 @@ var makeFilterMethod = function(filterFn) {
   };
 };
 
+/**
+ * Iterates over a cheerio object, reducing the set of selector elements to
+ * those that match the selector or pass the function's test. When a Cheerio
+ * selection is specified, return only the elements contained in that
+ * selection. When an element is specified, return only that element (if it is
+ * contained in the original selection). If using the function method, the
+ * function is executed in the context of the selected element, so `this`
+ * refers to the current element.
+ *
+ * @method
+ *
+ * @example <caption>Selector</caption>
+ *
+ * $('li').filter('.orange').attr('class');
+ * //=> orange
+ *
+ * @example <caption>Function</caption>
+ *
+ * $('li').filter(function(i, el) {
+ *   // this === el
+ *   return $(this).attr('class') === 'orange';
+ * }).attr('class')
+ * //=> orange
+ *
+ * @see {@link http://api.jquery.com/filter/}
+ */
 exports.filter = makeFilterMethod(_.filter);
+
+/**
+ * Remove elements from the set of matched elements. Given a jQuery object that
+ * represents a set of DOM elements, the `.not()` method constructs a new
+ * jQuery object from a subset of the matching elements. The supplied selector
+ * is tested against each element; the elements that don't match the selector
+ * will be included in the result. The `.not()` method can take a function as
+ * its argument in the same way that `.filter()` does. Elements for which the
+ * function returns true are excluded from the filtered set; all other elements
+ * are included.
+ *
+ * @method
+ *
+ * @example <caption>Selector</caption>
+ *
+ * $('li').not('.apple').length;
+ * //=> 2
+ *
+ * @example <caption>Function</caption>
+ *
+ * $('li').not(function(i, el) {
+ *   // this === el
+ *   return $(this).attr('class') === 'orange';
+ * }).length;
+ * //=> 2
+ *
+ * @see {@link http://api.jquery.com/not/}
+ */
 exports.not = makeFilterMethod(_.reject);
 
+/**
+ * Filters the set of matched elements to only those which have the given DOM
+ * element as a descendant or which have a descendant that matches the given
+ * selector. Equivalent to `.filter(':has(selector)')`.
+ *
+ * @example <caption>Selector</caption>
+ *
+ * $('ul').has('.pear').attr('id');
+ * //=> fruits
+ *
+ * @example <caption>Element</caption>
+ *
+ * $('ul').has($('.pear')[0]).attr('id');
+ * //=> fruits
+ *
+ * @param {string|cheerio|node} selectorOrHaystack  - Element to look for.
+ *
+ * @see {@link http://api.jquery.com/has/}
+ */
 exports.has = function(selectorOrHaystack) {
   var that = this;
   return exports.filter.call(this, function() {
@@ -341,15 +718,50 @@ exports.has = function(selectorOrHaystack) {
   });
 };
 
+/**
+ * Will select the first element of a cheerio object.
+ *
+ * @example
+ *
+ * $('#fruits').children().first().text()
+ * //=> Apple
+ *
+ * @see {@link http://api.jquery.com/first/}
+ */
 exports.first = function() {
   return this.length > 1 ? this._make(this[0]) : this;
 };
 
+/**
+ * Will select the last element of a cheerio object.
+ *
+ * @example
+ *
+ * $('#fruits').children().last().text()
+ * //=> Pear
+ *
+ * @see {@link http://api.jquery.com/last/}
+ */
 exports.last = function() {
   return this.length > 1 ? this._make(this[this.length - 1]) : this;
 };
 
-// Reduce the set of matched elements to the one at the specified index.
+/**
+ * Reduce the set of matched elements to the one at the specified index. Use
+ * `.eq(-i)` to count backwards from the last selected element.
+ *
+ * @example
+ *
+ * $('li').eq(0).text()
+ * //=> Apple
+ *
+ * $('li').eq(-1).text()
+ * //=> Pear
+ *
+ * @param {number} i - Index of the element to select.
+ *
+ * @see {@link http://api.jquery.com/eq/}
+ */
 exports.eq = function(i) {
   i = +i;
 
@@ -360,16 +772,50 @@ exports.eq = function(i) {
   return this[i] ? this._make(this[i]) : this._make([]);
 };
 
-// Retrieve the DOM elements matched by the jQuery object.
+/**
+ * Retrieve the DOM elements matched by the Cheerio object. If an index is
+ * specified, retrieve one of the elements matched by the Cheerio object.
+ *
+ * @example
+ *
+ * $('li').get(0).tagName
+ * //=> li
+ *
+ * If no index is specified, retrieve all elements matched by the Cheerio object:
+ *
+ * @example
+ *
+ * $('li').get().length
+ * //=> 3
+ *
+ * @param {number} [i] - Element to retrieve.
+ *
+ * @see {@link http://api.jquery.com/get/}
+ */
 exports.get = function(i) {
   if (i == null) {
     return Array.prototype.slice.call(this);
   } else {
-    return this[i < 0 ? (this.length + i) : i];
+    return this[i < 0 ? this.length + i : i];
   }
 };
 
-// Search for a given element from among the matched elements.
+/**
+ * Search for a given element from among the matched elements.
+ *
+ * @example
+ *
+ * $('.pear').index()
+ * //=> 2
+ * $('.orange').index('li')
+ * //=> 1
+ * $('.apple').index($('#fruit, li'))
+ * //=> 1
+ *
+ * @param {string|cheerio|node} [selectorOrNeedle]  - Element to look for.
+ *
+ * @see {@link http://api.jquery.com/index/}
+ */
 exports.index = function(selectorOrNeedle) {
   var $haystack, needle;
 
@@ -387,6 +833,19 @@ exports.index = function(selectorOrNeedle) {
   return $haystack.get().indexOf(needle);
 };
 
+/**
+ * Gets the elements matching the specified range.
+ *
+ * @example
+ *
+ * $('li').slice(1).eq(0).text()
+ * //=> 'Orange'
+ *
+ * $('li').slice(1, 2).length
+ * //=> 1
+ *
+ * @see {@link http://api.jquery.com/slice/}
+ */
 exports.slice = function() {
   return this._make([].slice.apply(this, arguments));
 };
@@ -402,12 +861,34 @@ function traverseParents(self, elem, selector, limit) {
   return elems;
 }
 
-// End the most recent filtering operation in the current chain and return the
-// set of matched elements to its previous state.
+/**
+ * End the most recent filtering operation in the current chain and return the
+ * set of matched elements to its previous state.
+ *
+ * @example
+ *
+ * $('li').eq(0).end().length
+ * //=> 3
+ *
+ * @see {@link http://api.jquery.com/end/}
+ */
 exports.end = function() {
   return this.prevObject || this._make([]);
 };
 
+/**
+ * Add elements to the set of matched elements.
+ *
+ * @example
+ *
+ * $('.apple').add('.orange').length
+ * //=> 2
+ *
+ * @param {string|cheerio} other - Elements to add.
+ * @param {cheerio} [context] - Optionally the context of the new selection.
+ *
+ * @see {@link http://api.jquery.com/add/}
+ */
 exports.add = function(other, context) {
   var selection = this._make(other, context);
   var contents = uniqueSort(selection.get().concat(this.get()));
@@ -420,8 +901,19 @@ exports.add = function(other, context) {
   return selection;
 };
 
-// Add the previous set of elements on the stack to the current set, optionally
-// filtered by a selector.
+/**
+ * Add the previous set of elements on the stack to the current set, optionally
+ * filtered by a selector.
+ *
+ * @example
+ *
+ * $('li').eq(0).addBack('.orange').length
+ * //=> 2
+ *
+ * @param {string} selector - Selector for the elements to add.
+ *
+ * @see {@link http://api.jquery.com/addBack/}
+ */
 exports.addBack = function(selector) {
   return this.add(
     arguments.length ? this.prevObject.filter(selector) : this.prevObject
diff --git a/lib/cheerio.js b/lib/cheerio.js
index a4195104e2..e742567e76 100644
--- a/lib/cheerio.js
+++ b/lib/cheerio.js
@@ -1,8 +1,11 @@
+/*global Symbol*/
 /*
   Module dependencies
 */
 
 var parse = require('./parse'),
+    defaultOptions = require('./options').default,
+    flattenOptions = require('./options').flatten,
     isHtml = require('./utils').isHtml,
     _ = {
       extend: require('lodash/assignIn'),
@@ -14,7 +17,6 @@ var parse = require('./parse'),
 /*
  * The API
  */
-
 var api = [
   require('./api/attributes'),
   require('./api/traversing'),
@@ -23,20 +25,31 @@ var api = [
   require('./api/forms')
 ];
 
-/*
- * Instance of cheerio
+/**
+ * Instance of cheerio. Methods are specified in the modules.
+ * Usage of this constructor is not recommended. Please use $.load instead.
+ *
+ * @class
+ * @param {string|cheerio|node|node[]} selector - The new selection.
+ * @param {string|cheerio|node|node[]} [context] - Context of the selection.
+ * @param {string|cheerio|node|node[]} [root] - Sets the root node.
+ * @param {Object} [options] - Options for the instance.
  */
+var Cheerio = (module.exports = function(selector, context, root, options) {
+  if (!(this instanceof Cheerio))
+    return new Cheerio(selector, context, root, options);
 
-var Cheerio = module.exports = function(selector, context, root, options) {
-  if (!(this instanceof Cheerio)) return new Cheerio(selector, context, root, options);
-
-  this.options = _.defaults(options || {}, this.options);
+  this.options = _.defaults(
+    flattenOptions(options),
+    this.options,
+    defaultOptions
+  );
 
   // $(), $(null), $(undefined), $(false)
   if (!selector) return this;
 
   if (root) {
-    if (typeof root === 'string') root = parse(root, this.options);
+    if (typeof root === 'string') root = parse(root, this.options, false);
     this._root = Cheerio.call(this, root);
   }
 
@@ -44,21 +57,23 @@ var Cheerio = module.exports = function(selector, context, root, options) {
   if (selector.cheerio) return selector;
 
   // $(dom)
-  if (isNode(selector))
-    selector = [selector];
+  if (isNode(selector)) selector = [selector];
 
   // $([dom])
   if (Array.isArray(selector)) {
-    _.forEach(selector, _.bind(function(elem, idx) {
-      this[idx] = elem;
-    }, this));
+    _.forEach(
+      selector,
+      _.bind(function(elem, idx) {
+        this[idx] = elem;
+      }, this)
+    );
     this.length = selector.length;
     return this;
   }
 
   // $(<html>)
   if (typeof selector === 'string' && isHtml(selector)) {
-    return Cheerio.call(this, parse(selector, this.options).children);
+    return Cheerio.call(this, parse(selector, this.options, false).children);
   }
 
   // If we don't have a context, maybe we have a root, from loading
@@ -67,15 +82,15 @@ var Cheerio = module.exports = function(selector, context, root, options) {
   } else if (typeof context === 'string') {
     if (isHtml(context)) {
       // $('li', '<ul>...</ul>')
-      context = parse(context, this.options);
+      context = parse(context, this.options, false);
       context = Cheerio.call(this, context);
     } else {
       // $('li', 'ul')
       selector = [context, selector].join(' ');
       context = this._root;
     }
-  // $('li', node), $('li', [nodes])
   } else if (!context.cheerio) {
+    // $('li', node), $('li', [nodes])
     context = Cheerio.call(this, context);
   }
 
@@ -84,44 +99,29 @@ var Cheerio = module.exports = function(selector, context, root, options) {
 
   // #id, .class, tag
   return context.find(selector);
-};
+});
 
 /**
  * Mix in `static`
  */
-
 _.extend(Cheerio, require('./static'));
 
 /*
  * Set a signature of the object
  */
-
 Cheerio.prototype.cheerio = '[cheerio object]';
 
-/*
- * Cheerio default options
- */
-
-Cheerio.prototype.options = {
-  withDomLvl1: true,
-  normalizeWhitespace: false,
-  xmlMode: false,
-  decodeEntities: true
-};
-
 /*
  * Make cheerio an array-like object
  */
-
 Cheerio.prototype.length = 0;
 Cheerio.prototype.splice = Array.prototype.splice;
 
 /*
  * Make a cheerio object
  *
- * @api private
+ * @private
  */
-
 Cheerio.prototype._make = function(dom, context) {
   var cheerio = new this.constructor(dom, context, this._root, this.options);
   cheerio.prevObject = this;
@@ -129,16 +129,22 @@ Cheerio.prototype._make = function(dom, context) {
 };
 
 /**
- * Turn a cheerio object into an array
+ * Retrieve all the DOM elements contained in the jQuery set as an array.
+ *
+ * @example
+ * $('li').toArray()
+ * //=> [ {...}, {...}, {...} ]
  */
-
 Cheerio.prototype.toArray = function() {
   return this.get();
 };
 
-/**
- * Plug in the API
- */
+// Support for (const element of $(...)) iteration:
+if (typeof Symbol !== 'undefined') {
+  Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
+}
+
+// Plug in the API
 api.forEach(function(mod) {
   _.extend(Cheerio.prototype, mod);
 });
diff --git a/lib/options.js b/lib/options.js
new file mode 100644
index 0000000000..fc7c3af8b0
--- /dev/null
+++ b/lib/options.js
@@ -0,0 +1,18 @@
+var assign = require('lodash/assign');
+
+/*
+ * Cheerio default options
+ */
+
+exports.default = {
+  withDomLvl1: true,
+  normalizeWhitespace: false,
+  xml: false,
+  decodeEntities: true
+};
+
+exports.flatten = function(options) {
+  return options && options.xml
+    ? assign({ xmlMode: true }, options.xml)
+    : options;
+};
diff --git a/lib/parse.js b/lib/parse.js
index b06245d5e8..298be39b52 100644
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -2,16 +2,18 @@
   Module Dependencies
 */
 var htmlparser = require('htmlparser2');
+var parse5 = require('parse5');
 
 /*
   Parser
 */
-exports = module.exports = function(content, options) {
-  var dom = exports.evaluate(content, options),
-      // Generic root element
-      root = exports.evaluate('<root></root>', options)[0];
+exports = module.exports = function(content, options, isDocument) {
+  var dom = exports.evaluate(content, options, isDocument);
+  // Generic root element
+  var root = exports.evaluate('<root></root>', options, false)[0];
 
   root.type = 'root';
+  root.parent = null;
 
   // Update the dom using the root
   exports.update(dom, root);
@@ -19,13 +21,29 @@ exports = module.exports = function(content, options) {
   return root;
 };
 
-exports.evaluate = function(content, options) {
+function parseWithParse5(content, options, isDocument) {
+  var parse = isDocument ? parse5.parse : parse5.parseFragment;
+  var root = parse(content, {
+    treeAdapter: parse5.treeAdapters.htmlparser2,
+    locationInfo: options.locationInfo
+  });
+
+  return root.children;
+}
+
+exports.evaluate = function(content, options, isDocument) {
   // options = options || $.fn.options;
 
   var dom;
 
-  if (typeof content === 'string' || Buffer.isBuffer(content)) {
-    dom = htmlparser.parseDOM(content, options);
+  if (Buffer.isBuffer(content)) content = content.toString();
+
+  if (typeof content === 'string') {
+    var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
+
+    dom = useHtmlParser2
+      ? htmlparser.parseDOM(content, options)
+      : parseWithParse5(content, options, isDocument);
   } else {
     dom = content;
   }
@@ -52,8 +70,8 @@ exports.update = function(arr, parent) {
     var node = arr[i];
 
     // Cleanly remove existing nodes from their previous structures.
-    var oldParent = node.parent || node.root,
-        oldSiblings = oldParent && oldParent.children;
+    var oldParent = node.parent || node.root;
+    var oldSiblings = oldParent && oldParent.children;
     if (oldSiblings && oldSiblings !== arr) {
       oldSiblings.splice(oldSiblings.indexOf(node), 1);
       if (node.prev) {
diff --git a/lib/static.js b/lib/static.js
index 6056cb7a30..29f7cdf0de 100644
--- a/lib/static.js
+++ b/lib/static.js
@@ -1,25 +1,40 @@
 /**
- * Module dependencies
+ * @module static
  */
-
-var serialize = require('dom-serializer'),
-    select = require('css-select'),
-    parse = require('./parse'),
-    _ = {
-      merge: require('lodash/merge'),
-      defaults: require('lodash/defaults')
-    };
+var serialize = require('dom-serializer');
+var defaultOptions = require('./options').default;
+var flattenOptions = require('./options').flatten;
+var select = require('css-select');
+var parse5 = require('parse5');
+var parse = require('./parse');
+var _ = {
+  merge: require('lodash/merge'),
+  defaults: require('lodash/defaults')
+};
 
 /**
- * $.load(str)
+ * Create a querying function, bound to a document created from the provided
+ * markup. Note that similar to web browser contexts, this operation may
+ * introduce `<html>`, `<head>`, and `<body>` elements. See the previous
+ * section titled "Loading" for usage information.
+ *
+ * @param {string} content - Markup to be loaded.
+ * @param {Object} [options] - Options for the created instance.
+ * @param {boolean} [isDocument] - Allows parser to be switched to fragment mode.
+ *
  */
+exports.load = function(content, options, isDocument) {
+  if (content === null || content === undefined) {
+    throw new Error('cheerio.load() expects a string');
+  }
 
-exports.load = function(content, options) {
   var Cheerio = require('./cheerio');
 
-  options = _.defaults(options || {}, Cheerio.prototype.options);
+  options = _.defaults(flattenOptions(options || {}), defaultOptions);
 
-  var root = parse(content, options);
+  if (isDocument === void 0) isDocument = true;
+
+  var root = parse(content, options, isDocument);
 
   var initialize = function(selector, context, r, opts) {
     if (!(this instanceof initialize)) {
@@ -67,47 +82,66 @@ function render(that, dom, options) {
     dom = select(dom, that._root, options);
   }
 
-  return serialize(dom, options);
+  var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
+
+  return useHtmlParser2
+    ? serialize(dom, options)
+    : parse5.serialize(
+      { children: 'length' in dom ? dom : [dom] },
+      {
+        treeAdapter: parse5.treeAdapters.htmlparser2
+      }
+    );
 }
 
 /**
- * $.html([selector | dom], [options])
+ * Renders the document.
+ *
+ * @param {string|cheerio|node} [dom] - Element to render.
+ * @param {Object} [options] - Options for the renderer.
  */
-
 exports.html = function(dom, options) {
-  var Cheerio = require('./cheerio');
-
   // be flexible about parameters, sometimes we call html(),
   // with options as only parameter
   // check dom argument for dom element specific properties
   // assume there is no 'length' or 'type' properties in the options object
-  if (Object.prototype.toString.call(dom) === '[object Object]' && !options && !('length' in dom) && !('type' in dom))
-  {
+  if (
+    Object.prototype.toString.call(dom) === '[object Object]' &&
+    !options &&
+    !('length' in dom) &&
+    !('type' in dom)
+  ) {
     options = dom;
     dom = undefined;
   }
 
   // sometimes $.html() used without preloading html
   // so fallback non existing options to the default ones
-  options = _.defaults(options || {}, this._options, Cheerio.prototype.options);
+  options = _.defaults(
+    flattenOptions(options || {}),
+    this._options,
+    defaultOptions
+  );
 
   return render(this, dom, options);
 };
 
 /**
- * $.xml([selector | dom])
+ * Render the document as XML.
+ *
+ * @param {string|cheerio|node} [dom] - Element to render.
  */
-
 exports.xml = function(dom) {
-  var options = _.defaults({xmlMode: true}, this._options);
+  var options = _.defaults({ xml: true }, this._options);
 
   return render(this, dom, options);
 };
 
 /**
- * $.text(dom)
+ * Render the document as text.
+ *
+ * @param {string|cheerio|node} [elems] - Elements to render.
  */
-
 exports.text = function(elems) {
   if (!elems) {
     elems = this.root();
@@ -120,7 +154,12 @@ exports.text = function(elems) {
   for (var i = 0; i < len; i++) {
     elem = elems[i];
     if (elem.type === 'text') ret += elem.data;
-    else if (elem.children && elem.type !== 'comment' && elem.tagName !== 'script' && elem.tagName !== 'style') {
+    else if (
+      elem.children &&
+      elem.type !== 'comment' &&
+      elem.tagName !== 'script' &&
+      elem.tagName !== 'style'
+    ) {
       ret += exports.text(elem.children);
     }
   }
@@ -129,9 +168,14 @@ exports.text = function(elems) {
 };
 
 /**
- * $.parseHTML(data [, context ] [, keepScripts ])
  * Parses a string into an array of DOM nodes. The `context` argument has no
  * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
+ *
+ * @param {string} data - Markup that will be parsed.
+ * @param {any|boolean} [context] - Will be ignored. If it is a boolean it will be used as the value of `keepScripts`.
+ * @param {boolean} [keepScripts] - If false all scripts will be removed.
+ *
+ * @see {@link https://api.jquery.com/jQuery.parseHTML/}
  */
 exports.parseHTML = function(data, context, keepScripts) {
   var parsed;
@@ -144,7 +188,7 @@ exports.parseHTML = function(data, context, keepScripts) {
     keepScripts = context;
   }
 
-  parsed = this.load(data);
+  parsed = this.load(data, defaultOptions, false);
   if (!keepScripts) {
     parsed('script').remove();
   }
@@ -158,17 +202,29 @@ exports.parseHTML = function(data, context, keepScripts) {
 };
 
 /**
- * $.root()
+ * Sometimes you need to work with the top-level root element. To query it, you
+ * can use `$.root()`.
+ *
+ * @example
+ * ```js
+ * $.root().append('<ul id="vegetables"></ul>').html();
+ * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+ * ```
  */
 exports.root = function() {
   return this(this._root);
 };
 
 /**
- * $.contains()
+ * Checks to see if the `contained` DOM element is a descendant of the
+ * `container` DOM element.
+ *
+ * @param {node} container - Potential parent node.
+ * @param {node} contained - Potential child node.
+ *
+ * @see {@link https://api.jquery.com/jQuery.contains}
  */
 exports.contains = function(container, contained) {
-
   // According to the jQuery API, an element does not "contain" itself
   if (contained === container) {
     return false;
@@ -187,16 +243,20 @@ exports.contains = function(container, contained) {
 };
 
 /**
- * $.merge()
+ * $.merge().
+ *
+ * @param {Array|cheerio} arr1 - First array.
+ * @param {Array|cheerio} arr2 - Second array.
+ *
+ * @see {@link https://api.jquery.com/jQuery.merge}
  */
-
 exports.merge = function(arr1, arr2) {
-  if(!(isArrayLike(arr1) && isArrayLike(arr2))){
+  if (!(isArrayLike(arr1) && isArrayLike(arr2))) {
     return;
   }
   var newLength = arr1.length + arr2.length;
   var i = 0;
-  while(i < arr2.length){
+  while (i < arr2.length) {
     arr1[i + arr1.length] = arr2[i];
     i++;
   }
@@ -204,25 +264,25 @@ exports.merge = function(arr1, arr2) {
   return arr1;
 };
 
-function isArrayLike(item){
-  if(Array.isArray(item)){
+function isArrayLike(item) {
+  if (Array.isArray(item)) {
     return true;
   }
-  if(typeof item !== 'object'){
+  if (typeof item !== 'object') {
     return false;
   }
-  if(!item.hasOwnProperty('length')){
+  if (!item.hasOwnProperty('length')) {
     return false;
   }
-  if(typeof item.length !== 'number') {
+  if (typeof item.length !== 'number') {
     return false;
   }
-  if(item.length < 0){
+  if (item.length < 0) {
     return false;
   }
   var i = 0;
-  while(i < item.length){
-    if(!(i in item)){
+  while (i < item.length) {
+    if (!(i in item)) {
       return false;
     }
     i++;
diff --git a/lib/utils.js b/lib/utils.js
index baa62fc616..b1a18ac090 100644
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -1,18 +1,17 @@
-var parse = require('./parse'),
-    render = require('dom-serializer');
-
-/**
- * HTML Tags
- */
+var cloneDeepWith = require('lodash/cloneDeepWith');
 
+// HTML Tags
 var tags = { tag: true, script: true, style: true };
 
 /**
- * Check if the DOM element is a tag
+ * Check if the DOM element is a tag.
  *
- * isTag(type) includes <script> and <style> tags
+ * `isTag(type)` includes `<script>` and `<style>` tags.
+ *
+ * @param {node} type - DOM node to check.
+ *
+ * @private
  */
-
 exports.isTag = function(type) {
   if (type.type) type = type.type;
   return tags[type] || false;
@@ -20,10 +19,12 @@ exports.isTag = function(type) {
 
 /**
  * Convert a string to camel case notation.
- * @param  {String} str String to be converted.
- * @return {String}     String in camel case notation.
+ *
+ * @param  {string} str - String to be converted.
+ * @returns {string}      String in camel case notation.
+ *
+ * @private
  */
-
 exports.camelCase = function(str) {
   return str.replace(/[_.-](\w|$)/g, function(_, x) {
     return x.toUpperCase();
@@ -33,49 +34,72 @@ exports.camelCase = function(str) {
 /**
  * Convert a string from camel case to "CSS case", where word boundaries are
  * described by hyphens ("-") and all characters are lower-case.
- * @param  {String} str String to be converted.
- * @return {string}     String in "CSS case".
+ *
+ * @param  {string} str - String to be converted.
+ * @returns {string}      String in "CSS case".
+ *
+ * @private
  */
 exports.cssCase = function(str) {
   return str.replace(/[A-Z]/g, '-$&').toLowerCase();
 };
 
-/**
- * Iterate over each DOM element without creating intermediary Cheerio instances.
- *
- * This is indented for use internally to avoid otherwise unnecessary memory pressure introduced
- * by _make.
- */
-
+// Iterate over each DOM element without creating intermediary Cheerio
+// instances.
+//
+// This is indented for use internally to avoid otherwise unnecessary memory
+// pressure introduced by _make.
 exports.domEach = function(cheerio, fn) {
-  var i = 0, len = cheerio.length;
+  var i = 0,
+      len = cheerio.length;
   while (i < len && fn.call(cheerio, i, cheerio[i]) !== false) ++i;
   return cheerio;
 };
 
 /**
- * Create a deep copy of the given DOM structure by first rendering it to a
- * string and then parsing the resultant markup.
+ * Create a deep copy of the given DOM structure.
+ * Sets the parents of the copies of the passed nodes to `null`.
  *
- * @argument {Object} dom - The htmlparser2-compliant DOM structure
- * @argument {Object} options - The parsing/rendering options
+ * @param {Object} dom - The htmlparser2-compliant DOM structure.
+ * @private
  */
-exports.cloneDom = function(dom, options) {
-  return parse(render(dom, options), options).children;
+exports.cloneDom = function(dom) {
+  var parents =
+    'length' in dom
+      ? Array.prototype.map.call(dom, function(el) {
+        return el.parent;
+      })
+      : [dom.parent];
+
+  function filterOutParent(node) {
+    if (parents.indexOf(node) > -1) {
+      return null;
+    }
+  }
+
+  return cloneDeepWith(dom, filterOutParent);
 };
 
 /*
  * A simple way to check for HTML strings or ID strings
  */
+var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w-]*)$)/;
 
-var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/;
-
-/*
- * Check if string is HTML
+/**
+ * Check if string is HTML.
+ *
+ * @param {string} str - String to check.
+ *
+ * @private
  */
 exports.isHtml = function(str) {
   // Faster than running regex, if str starts with `<` and ends with `>`, assume it's HTML
-  if (str.charAt(0) === '<' && str.charAt(str.length - 1) === '>' && str.length >= 3) return true;
+  if (
+    str.charAt(0) === '<' &&
+    str.charAt(str.length - 1) === '>' &&
+    str.length >= 3
+  )
+    return true;
 
   // Run the regex
   var match = quickExpr.exec(str);
diff --git a/package.json b/package.json
index 91d4e0aa34..0c323de6d5 100644
--- a/package.json
+++ b/package.json
@@ -1,48 +1,56 @@
 {
   "name": "cheerio",
-  "version": "0.22.0",
-  "description": "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
+  "version": "1.0.0-rc.2",
+  "description":
+    "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
   "author": "Matt Mueller <mattmuelle@gmail.com> (mat.io)",
   "license": "MIT",
-  "keywords": [
-    "htmlparser",
-    "jquery",
-    "selector",
-    "scraper",
-    "parser",
-    "html"
-  ],
+  "keywords": ["htmlparser", "jquery", "selector", "scraper", "parser", "html"],
   "repository": {
     "type": "git",
     "url": "git://github.com/cheeriojs/cheerio.git"
   },
   "main": "./index.js",
-  "files": [
-    "index.js",
-    "lib"
-  ],
+  "files": ["index.js", "lib"],
   "engines": {
     "node": ">= 0.6"
   },
   "dependencies": {
-    "css-select": "~1.2.0",
+    "css-select": "~2.0.0",
     "dom-serializer": "~0.1.0",
     "entities": "~1.1.1",
     "htmlparser2": "^3.9.1",
-    "lodash": "^4.15.0"
+    "lodash": "^4.17.5",
+    "parse5": "^3.0.1"
   },
   "devDependencies": {
     "benchmark": "^2.1.0",
-    "coveralls": "^2.11.9",
+    "coveralls": "^3.0.0",
+    "eslint": "^4.18.1",
+    "eslint-config-prettier": "^2.9.0",
+    "eslint-plugin-jsdoc": "^3.5.0",
     "expect.js": "~0.3.1",
+    "husky": "^0.14.3",
     "istanbul": "^0.4.3",
-    "jsdom": "^9.2.1",
     "jquery": "^3.0.0",
-    "jshint": "^2.9.2",
-    "mocha": "^3.1.2",
+    "jsdoc": "^3.5.5",
+    "jsdom": "^11.6.2",
+    "lint-staged": "^7.0.0",
+    "mocha": "^5.0.4",
+    "prettier": "^1.11.0",
     "xyz": "~1.1.0"
   },
   "scripts": {
-    "test": "jshint lib/ test/ && mocha --recursive --reporter dot"
+    "test": "npm run test:lint && npm run test:mocha",
+    "test:mocha": "mocha --recursive --reporter dot",
+    "test:lint": "eslint --ignore-path .gitignore .",
+    "precommit": "lint-staged"
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "lint-staged": {
+    "*.js": ["prettier --write", "eslint --fix", "git add"],
+    "*.json": ["prettier --write", "git add"]
   }
 }
diff --git a/scripts/generate_history.sh b/scripts/generate_history.sh
new file mode 100755
index 0000000000..cd04b946e6
--- /dev/null
+++ b/scripts/generate_history.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -e
+
+function error {
+  echo Cheerio "generate_history.sh" script: $1 >&2
+  false
+}
+
+if [ "$VERSION" == "" ] ; then
+  error 'VERSION environment variable unset.'
+fi
+
+if [ "$PREVIOUS_VERSION" == "" ] ; then
+  error 'PREVIOUS_VERSION environment variable unset.'
+fi
+
+tmp="$(mktemp -t "$(basename "$0").XXXXXXXXXX")"
+
+log="$(git --no-pager log --no-merges --pretty="format: * %s (%an)" $PREVIOUS_VERSION..)"
+
+printf "
+$VERSION / $(date +"%Y-%m-%d")
+==================
+
+$log
+" >"$tmp"
+
+cat History.md >>"$tmp"
+
+mv "$tmp" History.md
diff --git a/scripts/prepublish b/scripts/prepublish
index e24c7a22c1..7198f7174f 100755
--- a/scripts/prepublish
+++ b/scripts/prepublish
@@ -1,17 +1,23 @@
 #!/usr/bin/env bash
 set -e
 
-tmp="$(mktemp -t "$(basename "$0").XXXXXXXXXX")"
+function error {
+  echo Cheerio "prepublish" script: $1 >&2
+  false
+}
 
-log="$(git --no-pager log --no-merges --pretty="format: * %s (%an)" $PREVIOUS_VERSION..)"
+if [ "$VERSION" == "" ] ; then
+  error 'VERSION environment variable unset.'
+fi
 
-printf "
-$VERSION / $(date +"%Y-%m-%d")
-==================
+if [ "$PREVIOUS_VERSION" == "" ] ; then
+  error 'PREVIOUS_VERSION environment variable unset.'
+fi
 
-$log
-" >"$tmp"
+if ! grep -E "^$VERSION / [0-9]{4}-[0-9]{2}-[0-9]{2}" History.md > /dev/null; then
+  error "No entry for version $VERSION found in History.md file. (This may be seeded with the generate_history.sh script.)"
+fi
 
-cat History.md >>"$tmp"
-mv "$tmp" History.md
-git add History.md
+if ! git diff-index --quiet HEAD -- History.md; then
+  error 'History.md file contains untracked changes. Commit them prior to publication.'
+fi
diff --git a/test/.eslintrc.json b/test/.eslintrc.json
new file mode 100644
index 0000000000..7eeefc33b6
--- /dev/null
+++ b/test/.eslintrc.json
@@ -0,0 +1,5 @@
+{
+  "env": {
+    "mocha": true
+  }
+}
diff --git a/test/.jshintrc b/test/.jshintrc
deleted file mode 100644
index 7b01de5f58..0000000000
--- a/test/.jshintrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "extends": "../.jshintrc",
-  "globals": {
-    "expect": true,
-    "it": true,
-    "describe": true,
-    "beforeEach": true
-  }
-}
diff --git a/test/api/attributes.js b/test/api/attributes.js
index 61072dd9b9..129d8e2b0f 100644
--- a/test/api/attributes.js
+++ b/test/api/attributes.js
@@ -16,7 +16,6 @@ describe('$(...)', function() {
   });
 
   describe('.attr', function() {
-
     it('() : should get all the attributes', function() {
       var attrs = $('ul').attr();
       expect(attrs.id).to.equal('fruits');
@@ -82,10 +81,18 @@ describe('$(...)', function() {
 
     it('(key, value) : should correctly encode then decode unsafe values', function() {
       var $apple = $('.apple');
-      $apple.attr('href', 'http://github.com/"><script>alert("XSS!")</script><br');
-      expect($apple.attr('href')).to.equal('http://github.com/"><script>alert("XSS!")</script><br');
-
-      $apple.attr('href', 'http://github.com/"><script>alert("XSS!")</script><br');
+      $apple.attr(
+        'href',
+        'http://github.com/"><script>alert("XSS!")</script><br'
+      );
+      expect($apple.attr('href')).to.equal(
+        'http://github.com/"><script>alert("XSS!")</script><br'
+      );
+
+      $apple.attr(
+        'href',
+        'http://github.com/"><script>alert("XSS!")</script><br'
+      );
       expect($apple.html()).to.not.contain('<script>alert("XSS!")</script>');
     });
 
@@ -120,19 +127,22 @@ describe('$(...)', function() {
     });
 
     it('(map) : should remove attributes with null values', function() {
-      var $pear = $('.pear').attr({'autofocus': 'autofocus', 'style': 'color:red'});
+      var $pear = $('.pear').attr({
+        autofocus: 'autofocus',
+        style: 'color:red'
+      });
       expect($pear.attr('autofocus')).to.equal('autofocus');
       expect($pear.attr('style')).to.equal('color:red');
-      $pear.attr({'autofocus': null, 'style': 'color:blue'});
+      $pear.attr({ autofocus: null, style: 'color:blue' });
       expect($pear.attr('autofocus')).to.be(undefined);
       expect($pear.attr('style')).to.equal('color:blue');
     });
   });
 
-  describe('.prop', function () {
+  describe('.prop', function() {
     var checkbox, selectMenu;
 
-    beforeEach(function () {
+    beforeEach(function() {
       $ = cheerio.load(inputs);
       selectMenu = $('select');
       checkbox = $('input[name=checkbox_on]');
@@ -182,11 +192,18 @@ describe('$(...)', function() {
     it('(key, value) : should support chaining after setting props', function() {
       expect(checkbox.prop('checked', false)).to.equal(checkbox);
     });
-    
+
     it('(invalid element/tag) : prop should return undefined', function() {
       expect($(undefined).prop('prop')).to.be(undefined);
       expect($(null).prop('prop')).to.be(undefined);
     });
+
+    it('("outerHTML") : should render properly', function() {
+      var outerHtml = "<div><a></a></div>";
+      var $a = $(outerHtml);
+
+      expect($a.prop("outerHTML")).to.be(outerHtml);
+    });
     
     it('(inherited properties) : prop should support inherited properties', function() {
       expect(selectMenu.prop('childNodes')).to.equal(selectMenu[0].childNodes);
@@ -194,7 +211,6 @@ describe('$(...)', function() {
   });
 
   describe('.data', function() {
-
     beforeEach(function() {
       $ = cheerio.load(chocolates);
     });
@@ -247,7 +263,9 @@ describe('$(...)', function() {
     });
 
     it('(key) : should translate camel-cased key values to hyphen-separated versions', function() {
-      var $el = cheerio('<div data--three-word-attribute="a" data-foo-Bar_BAZ-="b">');
+      var $el = cheerio(
+        '<div data--three-word-attribute="a" data-foo-Bar_BAZ-="b">'
+      );
 
       expect($el.data('ThreeWordAttribute')).to.be('a');
       expect($el.data('fooBar_baz-')).to.be('b');
@@ -265,7 +283,7 @@ describe('$(...)', function() {
     it('(key) : should parse JSON data derived from the markup', function() {
       var $el = cheerio('<div data-json="[1, 2, 3]">');
 
-      expect($el.data('json')).to.eql([1,2,3]);
+      expect($el.data('json')).to.eql([1, 2, 3]);
     });
 
     it('(key) : should not parse JSON data set via the `data` API', function() {
@@ -287,9 +305,9 @@ describe('$(...)', function() {
     });
 
     it('(key) : should recover from malformed JSON', function() {
-        var $el = cheerio('<div data-custom="{{templatevar}}">');
+      var $el = cheerio('<div data-custom="{{templatevar}}">');
 
-        expect($el.data('custom')).to.be('{{templatevar}}');
+      expect($el.data('custom')).to.be('{{templatevar}}');
     });
 
     it('(hyphen key) : data addribute with hyphen should be camelized ;-)', function() {
@@ -315,9 +333,21 @@ describe('$(...)', function() {
     it('(key, value) : should set data for all elements in the selection', function() {
       $('li').data('foo', 'bar');
 
-      expect($('li').eq(0).data('foo')).to.eql('bar');
-      expect($('li').eq(1).data('foo')).to.eql('bar');
-      expect($('li').eq(2).data('foo')).to.eql('bar');
+      expect(
+        $('li')
+          .eq(0)
+          .data('foo')
+      ).to.eql('bar');
+      expect(
+        $('li')
+          .eq(1)
+          .data('foo')
+      ).to.eql('bar');
+      expect(
+        $('li')
+          .eq(2)
+          .data('foo')
+      ).to.eql('bar');
     });
 
     it('(map) : object map should set multiple data attributes', function() {
@@ -364,14 +394,10 @@ describe('$(...)', function() {
         var $el = cheerio('<div data-array="[1, 2, 3]">');
         expect($el.data('array')).to.eql([1, 2, 3]);
       });
-
     });
-
   });
 
-
   describe('.val', function() {
-
     beforeEach(function() {
       $ = cheerio.load(inputs);
     });
@@ -393,7 +419,9 @@ describe('$(...)', function() {
       expect(val).to.equal('Option selected');
     });
     it('(): on option should get value', function() {
-      var val = $('select#one option').eq(0).val();
+      var val = $('select#one option')
+        .eq(0)
+        .val();
       expect(val).to.equal('option_not_selected');
     });
     it('(): on text input should get value', function() {
@@ -445,7 +473,9 @@ describe('$(...)', function() {
       expect(element.val()).to.equal('option_not_selected');
     });
     it('(value): on option should set value', function() {
-      var element = $('select#one option').eq(0).val('option_changed');
+      var element = $('select#one option')
+        .eq(0)
+        .val('option_changed');
       expect(element.val()).to.equal('option_changed');
     });
     it('(value): on radio should set value', function() {
@@ -463,7 +493,6 @@ describe('$(...)', function() {
   });
 
   describe('.removeAttr', function() {
-
     it('(key) : should remove a single attr', function() {
       var $fruits = $('#fruits');
       expect($fruits.attr('id')).to.not.be(undefined);
@@ -475,7 +504,6 @@ describe('$(...)', function() {
       var obj = $('ul').removeAttr('id');
       expect(obj).to.be.a($);
     });
-
   });
 
   describe('.hasClass', function() {
@@ -509,19 +537,26 @@ describe('$(...)', function() {
 
       // Remove one and test again
       $('.apple').removeClass('apple');
-      expect($('li').eq(0).hasClass('apple')).to.not.be.ok();
+      expect(
+        $('li')
+          .eq(0)
+          .hasClass('apple')
+      ).to.not.be.ok();
       // expect($('li', $fruits).eq(0).hasClass('red')).to.be.ok();
     });
 
     it('(empty string argument) : should return false', function() {
       expect(test('foo').hasClass('')).to.not.be.ok();
       expect(test('foo bar').hasClass('')).to.not.be.ok();
-      expect(test('foo bar').removeClass('foo').hasClass('')).to.not.be.ok();
+      expect(
+        test('foo bar')
+          .removeClass('foo')
+          .hasClass('')
+      ).to.not.be.ok();
     });
   });
 
   describe('.addClass', function() {
-
     it('(first class) : should add the class to the element', function() {
       var $fruits = $('#fruits');
       $fruits.addClass('fruits');
@@ -562,26 +597,16 @@ describe('$(...)', function() {
         return toAdd[idx];
       });
 
-      expect(args).to.eql([
-        [0, 'apple'],
-        [1, 'orange'],
-        [2, 'pear']
-      ]);
-      expect(thisVals).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(args).to.eql([[0, 'apple'], [1, 'orange'], [2, 'pear']]);
+      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
       expect($fruits.eq(0).hasClass('apple')).to.be.ok();
       expect($fruits.eq(0).hasClass('red')).to.be.ok();
       expect($fruits.eq(1).hasClass('orange')).to.be.ok();
       expect($fruits.eq(2).hasClass('pear')).to.be.ok();
     });
-
   });
 
   describe('.removeClass', function() {
-
     it('() : should remove all the classes', function() {
       $('.pear').addClass('fruit');
       $('.pear').removeClass();
@@ -604,8 +629,7 @@ describe('$(...)', function() {
 
       expect(function() {
         $('li', $vegetables).removeClass('vegetable');
-      })
-      .to.not.throwException();
+      }).to.not.throwException();
     });
 
     it('(single class) : should remove a single class from the element', function() {
@@ -659,34 +683,24 @@ describe('$(...)', function() {
         return toAdd[idx];
       });
 
-      expect(args).to.eql([
-        [0, 'apple'],
-        [1, 'orange'],
-        [2, 'pear']
-      ]);
-      expect(thisVals).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(args).to.eql([[0, 'apple'], [1, 'orange'], [2, 'pear']]);
+      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
       expect($fruits.eq(0).hasClass('apple')).to.not.be.ok();
       expect($fruits.eq(0).hasClass('red')).to.not.be.ok();
       expect($fruits.eq(1).hasClass('orange')).to.be.ok();
       expect($fruits.eq(2).hasClass('pear')).to.be.ok();
     });
 
-    it('(fn) : should no op elements without attributes', function(){
+    it('(fn) : should no op elements without attributes', function() {
       var $inputs = $(inputs);
       var val = $inputs.removeClass(function() {
         return 'tasty';
       });
       expect(val).to.have.length(15);
     });
-
   });
 
   describe('.toggleClass', function() {
-
     it('(class class) : should toggle multiple classes from the element', function() {
       $('.apple').addClass('fruit');
       expect($('.apple').hasClass('apple')).to.be.ok();
@@ -711,10 +725,14 @@ describe('$(...)', function() {
       expect($('.fruit').hasClass('fruit')).to.be.ok();
     });
 
-    it('(class true) : should add only one instance of class', function () {
+    it('(class true) : should add only one instance of class', function() {
       $('.apple').toggleClass('tasty', true);
       $('.apple').toggleClass('tasty', true);
-      expect($('.apple').attr('class').match(/tasty/g).length).to.equal(1);
+      expect(
+        $('.apple')
+          .attr('class')
+          .match(/tasty/g).length
+      ).to.equal(1);
     });
 
     it('(class class, false) : should remove multiple classes from the element', function() {
@@ -744,7 +762,11 @@ describe('$(...)', function() {
       expect($('.sweetcorn').hasClass('vegetable')).to.not.be.ok();
 
       $('li').toggleClass(function() {
-        return $(this).parent().is('#fruits') ? 'fruit' : 'vegetable';
+        return $(this)
+          .parent()
+          .is('#fruits')
+          ? 'fruit'
+          : 'vegetable';
       });
       expect($('.apple').hasClass('fruit')).to.not.be.ok();
       expect($('.apple').hasClass('vegetable')).to.not.be.ok();
@@ -759,13 +781,15 @@ describe('$(...)', function() {
     it('(fn) : should work with no initial class attribute', function() {
       var $inputs = cheerio.load(inputs);
       $inputs('input, select').toggleClass(function() {
-        return $inputs(this).get(0).tagName === 'select' ? 'selectable' : 'inputable';
+        return $inputs(this).get(0).tagName === 'select'
+          ? 'selectable'
+          : 'inputable';
       });
       expect($inputs('.selectable')).to.have.length(6);
       expect($inputs('.inputable')).to.have.length(9);
     });
 
-    it('(invalid) : should be a no-op for invalid inputs', function(){
+    it('(invalid) : should be a no-op for invalid inputs', function() {
       var original = $('.apple');
       var testAgainst = original.attr('class');
       expect(original.toggleClass().attr('class')).to.be.eql(testAgainst);
@@ -776,10 +800,9 @@ describe('$(...)', function() {
       expect(original.toggleClass(1).attr('class')).to.be.eql(testAgainst);
       expect(original.toggleClass({}).attr('class')).to.be.eql(testAgainst);
     });
-
   });
 
-  describe('.is', function () {
+  describe('.is', function() {
     it('() : should return false', function() {
       expect($('li.apple').is()).to.be(false);
     });
@@ -821,12 +844,13 @@ describe('$(...)', function() {
       expect(result).to.be(true);
     });
 
-    it('(false predicate) : should return false', function () {
-      var result = $('li').last().is(function() {
-        return this.tagName === 'ul';
-      });
+    it('(false predicate) : should return false', function() {
+      var result = $('li')
+        .last()
+        .is(function() {
+          return this.tagName === 'ul';
+        });
       expect(result).to.be(false);
     });
   });
-
 });
diff --git a/test/api/css.js b/test/api/css.js
index 9e394c44f0..a037fff77d 100644
--- a/test/api/css.js
+++ b/test/api/css.js
@@ -2,7 +2,6 @@ var expect = require('expect.js');
 var cheerio = require('../..');
 
 describe('$(...)', function() {
-
   describe('.css', function() {
     it('(prop): should return a css property value', function() {
       var el = cheerio('<li style="hai: there">');
@@ -11,7 +10,10 @@ describe('$(...)', function() {
 
     it('([prop1, prop2]): should return the specified property values as an object', function() {
       var el = cheerio('<li style="margin: 1px; padding: 2px; color: blue;">');
-      expect(el.css(['margin', 'color'])).to.eql({ margin: '1px', color: 'blue' });
+      expect(el.css(['margin', 'color'])).to.eql({
+        margin: '1px',
+        color: 'blue'
+      });
     });
 
     it('(prop, val): should set a css property', function() {
@@ -28,23 +30,29 @@ describe('$(...)', function() {
     });
 
     it('(prop): should not mangle embedded urls', function() {
-      var el = cheerio('<li style="background-image:url(http://example.com/img.png);">');
-      expect(el.css('background-image')).to.equal('url(http://example.com/img.png)');
+      var el = cheerio(
+        '<li style="background-image:url(http://example.com/img.png);">'
+      );
+      expect(el.css('background-image')).to.equal(
+        'url(http://example.com/img.png)'
+      );
     });
 
     it('(prop): should ignore blank properties', function() {
       var el = cheerio('<li style=":#ccc;color:#aaa;">');
-      expect(el.css()).to.eql({color:'#aaa'});
+      expect(el.css()).to.eql({ color: '#aaa' });
     });
 
     it('(prop): should ignore blank values', function() {
       var el = cheerio('<li style="color:;position:absolute;">');
-      expect(el.css()).to.eql({position:'absolute'});
+      expect(el.css()).to.eql({ position: 'absolute' });
     });
 
     describe('(prop, function):', function() {
       beforeEach(function() {
-        this.$el = cheerio('<div style="margin: 0px;"></div><div style="margin: 1px;"></div><div style="margin: 2px;">');
+        this.$el = cheerio(
+          '<div style="margin: 0px;"></div><div style="margin: 1px;"></div><div style="margin: 2px;">'
+        );
       });
 
       it('should iterate over the selection', function() {
@@ -77,12 +85,11 @@ describe('$(...)', function() {
       expect(el.eq(1).attr('style')).to.equal('foo: 0;');
     });
 
-    describe('parser', function(){
+    describe('parser', function() {
       it('should allow any whitespace between declarations', function() {
         var el = cheerio('<li style="one \t:\n 0;\n two \f\r:\v 1">');
         expect(el.css(['one', 'two'])).to.eql({ one: 0, two: 1 });
       });
     });
   });
-
 });
diff --git a/test/api/forms.js b/test/api/forms.js
index a94f4a9365..6ba31018b5 100644
--- a/test/api/forms.js
+++ b/test/api/forms.js
@@ -1,9 +1,8 @@
 var expect = require('expect.js'),
-  cheerio = require('../..'),
-  forms = require('../fixtures').forms;
+    cheerio = require('../..'),
+    forms = require('../fixtures').forms;
 
 describe('$(...)', function() {
-
   var $;
 
   beforeEach(function() {
@@ -11,7 +10,6 @@ describe('$(...)', function() {
   });
 
   describe('.serializeArray', function() {
-
     it('() : should get form controls', function() {
       expect($('form#simple').serializeArray()).to.eql([
         {
@@ -24,7 +22,7 @@ describe('$(...)', function() {
     it('() : should get nested form controls', function() {
       expect($('form#nested').serializeArray()).to.have.length(2);
       var data = $('form#nested').serializeArray();
-      data.sort(function (a, b) {
+      data.sort(function(a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -73,7 +71,7 @@ describe('$(...)', function() {
     it('() : should get multiple selected options', function() {
       expect($('form#multiple').serializeArray()).to.have.length(2);
       var data = $('form#multiple').serializeArray();
-      data.sort(function (a, b) {
+      data.sort(function(a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -90,7 +88,7 @@ describe('$(...)', function() {
 
     it('() : should get individually selected elements', function() {
       var data = $('form#nested input').serializeArray();
-      data.sort(function (a, b) {
+      data.sort(function(a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -103,7 +101,6 @@ describe('$(...)', function() {
           value: 'Carrot'
         }
       ]);
-
     });
 
     it('() : should standardize line breaks', function() {
@@ -115,36 +112,38 @@ describe('$(...)', function() {
       ]);
     });
 
-    it('() : shouldn\'t serialize the empty string', function() {
-        expect($('<input value=pineapple>').serializeArray()).to.eql([]);
-        expect($('<input name="" value=pineapple>').serializeArray()).to.eql([]);
-        expect($('<input name="fruit" value=pineapple>').serializeArray()).to.eql([
-            {
-                name: 'fruit',
-                value: 'pineapple'
-            }
-        ]);
+    it("() : shouldn't serialize the empty string", function() {
+      expect($('<input value=pineapple>').serializeArray()).to.eql([]);
+      expect($('<input name="" value=pineapple>').serializeArray()).to.eql([]);
+      expect($('<input name="fruit" value=pineapple>').serializeArray()).to.eql(
+        [
+          {
+            name: 'fruit',
+            value: 'pineapple'
+          }
+        ]
+      );
     });
 
     it('() : should serialize inputs without value attributes', function() {
-        expect($('<input name="fruit">').serializeArray()).to.eql([
-            {
-                name: 'fruit',
-                value: ''
-            }
-        ]);
+      expect($('<input name="fruit">').serializeArray()).to.eql([
+        {
+          name: 'fruit',
+          value: ''
+        }
+      ]);
     });
-
   });
 
   describe('.serialize', function() {
-
     it('() : should get form controls', function() {
       expect($('form#simple').serialize()).to.equal('fruit=Apple');
     });
 
     it('() : should get nested form controls', function() {
-      expect($('form#nested').serialize()).to.equal('fruit=Apple&vegetable=Carrot');
+      expect($('form#nested').serialize()).to.equal(
+        'fruit=Apple&vegetable=Carrot'
+      );
     });
 
     it('() : should not get disabled form controls', function() {
@@ -152,13 +151,13 @@ describe('$(...)', function() {
     });
 
     it('() : should get multiple selected options', function() {
-      expect($('form#multiple').serialize()).to.equal('fruit=Apple&fruit=Orange');
+      expect($('form#multiple').serialize()).to.equal(
+        'fruit=Apple&fruit=Orange'
+      );
     });
 
-    it('() : should encode spaces as +\'s', function() {
+    it("() : should encode spaces as +'s", function() {
       expect($('form#spaces').serialize()).to.equal('fruit=Blood+orange');
     });
-
   });
-
 });
diff --git a/test/api/manipulation.js b/test/api/manipulation.js
index b6eaaaf9d0..500cd82d32 100644
--- a/test/api/manipulation.js
+++ b/test/api/manipulation.js
@@ -4,7 +4,6 @@ var expect = require('expect.js'),
     toArray = Function.call.bind(Array.prototype.slice);
 
 describe('$(...)', function() {
-
   var $, $fruits;
 
   beforeEach(function() {
@@ -17,15 +16,30 @@ describe('$(...)', function() {
       var $redFruits = $('<div class="red-fruits"></div>');
       $('.apple').wrap($redFruits);
 
-      expect($fruits.children().eq(0).hasClass('red-fruits')).to.be.ok();
-      expect($('.red-fruits').children().eq(0).hasClass('apple')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('orange')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('red-fruits')
+      ).to.be.ok();
+      expect(
+        $('.red-fruits')
+          .children()
+          .eq(0)
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('orange')
+      ).to.be.ok();
       expect($redFruits.children()).to.have.length(1);
     });
 
-    it('(element) : should wrap the base element correctly', function(){
+    it('(element) : should wrap the base element correctly', function() {
       $('ul').wrap('<a></a>');
-      expect($.root().children()[0].tagName).to.equal('a');
+      expect($('body').children()[0].tagName).to.equal('a');
     });
 
     it('(element) : should insert the element and add selected element(s) as its child', function() {
@@ -40,9 +54,24 @@ describe('$(...)', function() {
 
     it('(html) : should insert the markup and add selected element(s) as its child', function() {
       $('.apple').wrap('<div class="red-fruits"> </div>');
-      expect($fruits.children().eq(0).hasClass('red-fruits')).to.be.ok();
-      expect($('.red-fruits').children().eq(0).hasClass('apple')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('orange')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('red-fruits')
+      ).to.be.ok();
+      expect(
+        $('.red-fruits')
+          .children()
+          .eq(0)
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('orange')
+      ).to.be.ok();
       expect($('.red-fruits').children()).to.have.length(1);
     });
 
@@ -53,12 +82,29 @@ describe('$(...)', function() {
     });
 
     it('(html) : wraps with nested elements', function() {
-      var $orangeFruits = $('<div class="orange-fruits"><div class="and-stuff"></div></div>');
+      var $orangeFruits = $(
+        '<div class="orange-fruits"><div class="and-stuff"></div></div>'
+      );
       $('.orange').wrap($orangeFruits);
 
-      expect($fruits.children().eq(1).hasClass('orange-fruits')).to.be.ok();
-      expect($('.orange-fruits').children().eq(0).hasClass('and-stuff')).to.be.ok();
-      expect($fruits.children().eq(2).hasClass('pear')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('orange-fruits')
+      ).to.be.ok();
+      expect(
+        $('.orange-fruits')
+          .children()
+          .eq(0)
+          .hasClass('and-stuff')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('pear')
+      ).to.be.ok();
       expect($('.orange-fruits').children()).to.have.length(1);
     });
 
@@ -93,16 +139,8 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([
-        [0],
-        [1],
-        [2]
-      ]);
-      expect(thisValues).to.eql([
-        $children[0],
-        $children[1],
-        $children[2]
-      ]);
+      expect(args).to.eql([[0], [1], [2]]);
+      expect(thisValues).to.eql([$children[0], $children[1], $children[2]]);
     });
 
     it('(fn) : should use the returned HTML to wrap each element', function() {
@@ -121,7 +159,9 @@ describe('$(...)', function() {
       expect($fruits.find('span')).to.have.length(1);
       expect($fruits.find('span')[0]).to.be($fruits.children()[1]);
       expect($fruits.find('.orange')).to.have.length(1);
-      expect($fruits.find('.orange').parent()[0]).to.be($fruits.find('span')[0]);
+      expect($fruits.find('.orange').parent()[0]).to.be(
+        $fruits.find('span')[0]
+      );
 
       expect($fruits.find('p')).to.have.length(1);
       expect($fruits.find('p')[0]).to.be($fruits.children()[2]);
@@ -156,36 +196,86 @@ describe('$(...)', function() {
     it('($(...)) : for each element it should add a wrapper elment and add the selected element as its child', function() {
       var $fruitDecorator = $('<div class="fruit-decorator"></div>');
       $('li').wrap($fruitDecorator);
-      expect($fruits.children().eq(0).hasClass('fruit-decorator')).to.be.ok();
-      expect($fruits.children().eq(0).children().eq(0).hasClass('apple')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('fruit-decorator')).to.be.ok();
-      expect($fruits.children().eq(1).children().eq(0).hasClass('orange')).to.be.ok();
-      expect($fruits.children().eq(2).hasClass('fruit-decorator')).to.be.ok();
-      expect($fruits.children().eq(2).children().eq(0).hasClass('pear')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('fruit-decorator')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .children()
+          .eq(0)
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('fruit-decorator')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .children()
+          .eq(0)
+          .hasClass('orange')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('fruit-decorator')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .children()
+          .eq(0)
+          .hasClass('pear')
+      ).to.be.ok();
     });
-   });
+  });
 
   describe('.append', function() {
-
     it('() : should do nothing', function() {
       expect($('#fruits').append()[0].tagName).to.equal('ul');
     });
 
     it('(html) : should add element as last child', function() {
       $fruits.append('<li class="plum">Plum</li>');
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as last child', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $fruits.append($plum);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add element as last child', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $fruits.append(plum);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove node from previous location', function() {
@@ -241,23 +331,49 @@ describe('$(...)', function() {
 
       $apple.remove();
       $fruits.append($apple);
-      expect($fruits.children().eq(2).hasClass('apple')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('apple')
+      ).to.be.ok();
     });
 
     it('($(...), html) : should add multiple elements as last children', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $fruits.append($plum, grape);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(4).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(4)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(Array) : should append all elements in the array', function() {
-      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
-        .get();
+      var more = $(
+        '<li class="plum">Plum</li><li class="grape">Grape</li>'
+      ).get();
       $fruits.append(more);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(4).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(4)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -270,16 +386,8 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([
-        [0, 'Apple'],
-        [1, 'Orange'],
-        [2, 'Pear']
-      ]);
-      expect(thisValues).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
+      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
     });
 
     it('(fn) : should add returned string as last child', function() {
@@ -354,26 +462,40 @@ describe('$(...)', function() {
   });
 
   describe('.prepend', function() {
-
     it('() : should do nothing', function() {
       expect($('#fruits').prepend()[0].tagName).to.equal('ul');
     });
 
     it('(html) : should add element as first child', function() {
       $fruits.prepend('<li class="plum">Plum</li>');
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as first child', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $fruits.prepend($plum);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add node as first child', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $fruits.prepend(plum);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -413,23 +535,49 @@ describe('$(...)', function() {
 
       $apple.remove();
       $fruits.prepend($apple);
-      expect($fruits.children().eq(0).hasClass('apple')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('apple')
+      ).to.be.ok();
     });
 
     it('(Array) : should add all elements in the array as inital children', function() {
-      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
-        .get();
+      var more = $(
+        '<li class="plum">Plum</li><li class="grape">Grape</li>'
+      ).get();
       $fruits.prepend(more);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(html, $(...), html) : should add multiple elements as first children', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $fruits.prepend($plum, grape);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -442,16 +590,8 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([
-        [0, 'Apple'],
-        [1, 'Orange'],
-        [2, 'Pear']
-      ]);
-      expect(thisValues).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
+      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
     });
 
     it('(fn) : should add returned string as first child', function() {
@@ -505,7 +645,6 @@ describe('$(...)', function() {
       expect($pear.find('.third')[0]).to.equal($pear.contents()[0]);
     });
 
-
     it('($(...)) : should remove from root element', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var root = $plum[0].root;
@@ -518,67 +657,130 @@ describe('$(...)', function() {
   });
 
   describe('.appendTo', function() {
-
     it('(html) : should add element as last child', function() {
       var $plum = $('<li class="plum">Plum</li>').appendTo(fruits);
-      expect($plum.parent().children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $plum
+          .parent()
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo($fruits);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo($fruits[0]);
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(selector) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo('#fruits');
-      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Array) : should add element as last child of all elements in the array', function() {
       var $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>');
       $('<li class="plum">Plum</li>').appendTo($multiple.get());
-      expect($multiple.first().children().eq(1).hasClass('plum')).to.be.ok();
-      expect($multiple.last().children().eq(1).hasClass('plum')).to.be.ok();
+      expect(
+        $multiple
+          .first()
+          .children()
+          .eq(1)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $multiple
+          .last()
+          .children()
+          .eq(1)
+          .hasClass('plum')
+      ).to.be.ok();
     });
   });
 
   describe('.prependTo', function() {
-
     it('(html) : should add element as first child', function() {
       var $plum = $('<li class="plum">Plum</li>').prependTo(fruits);
-      expect($plum.parent().children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $plum
+          .parent()
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as first child', function() {
       $('<li class="plum">Plum</li>').prependTo($fruits);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add node as first child', function() {
       $('<li class="plum">Plum</li>').prependTo($fruits[0]);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(selector) : should add element as first child', function() {
       $('<li class="plum">Plum</li>').prependTo('#fruits');
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Array) : should add element as first child of all elements in the array', function() {
       var $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>');
       $('<li class="plum">Plum</li>').prependTo($multiple.get());
-      expect($multiple.first().children().eq(0).hasClass('plum')).to.be.ok();
-      expect($multiple.last().children().eq(0).hasClass('plum')).to.be.ok();
+      expect(
+        $multiple
+          .first()
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $multiple
+          .last()
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
     });
   });
 
   describe('.after', function() {
-
     it('() : should do nothing', function() {
       expect($('#fruits').after()[0].tagName).to.equal('ul');
     });
@@ -586,27 +788,50 @@ describe('$(...)', function() {
     it('(html) : should add element as next sibling', function() {
       var grape = '<li class="grape">Grape</li>';
       $('.apple').after(grape);
-      expect($('.apple').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(Array) : should add all elements in the array as next sibling', function() {
-      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
-        .get();
+      var more = $(
+        '<li class="plum">Plum</li><li class="grape">Grape</li>'
+      ).get();
       $('.apple').after(more);
-      expect($fruits.children().eq(1).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(2).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as next sibling', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.apple').after($plum);
-      expect($('.apple').next().hasClass('plum')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add element as next sibling', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $('.apple').after(plum);
-      expect($('.apple').next().hasClass('plum')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -631,10 +856,26 @@ describe('$(...)', function() {
       $('.orange, .pear').after($originalApple);
 
       expect($('.apple')).to.have.length(2);
-      expect($('.apple').eq(0).prev()[0]).to.be($('.orange')[0]);
-      expect($('.apple').eq(0).next()[0]).to.be($('.pear')[0]);
-      expect($('.apple').eq(1).prev()[0]).to.be($('.pear')[0]);
-      expect($('.apple').eq(1).next()).to.have.length(0);
+      expect(
+        $('.apple')
+          .eq(0)
+          .prev()[0]
+      ).to.be($('.orange')[0]);
+      expect(
+        $('.apple')
+          .eq(0)
+          .next()[0]
+      ).to.be($('.pear')[0]);
+      expect(
+        $('.apple')
+          .eq(1)
+          .prev()[0]
+      ).to.be($('.pear')[0]);
+      expect(
+        $('.apple')
+          .eq(1)
+          .next()
+      ).to.have.length(0);
       expect($('.apple')[0]).to.not.eql($originalApple[0]);
       expect($('.apple')[1]).to.eql($originalApple[0]);
     });
@@ -652,8 +893,16 @@ describe('$(...)', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $('.apple').after($plum, grape);
-      expect($('.apple').next().hasClass('plum')).to.be.ok();
-      expect($('.plum').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $('.plum')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -667,11 +916,7 @@ describe('$(...)', function() {
       });
 
       expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
     });
 
     it('(fn) : should add returned string as next sibling', function() {
@@ -722,67 +967,144 @@ describe('$(...)', function() {
   });
 
   describe('.insertAfter', function() {
-
     it('(selector) : should create element and add as next sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter('.apple');
-      expect($('.apple').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(selector) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter('.apple, .pear');
-      expect($('.apple').next().hasClass('grape')).to.be.ok();
-      expect($('.pear').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter($('.apple'));
-      expect($('.apple').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter($('.apple, .pear'));
-      expect($('.apple').next().hasClass('grape')).to.be.ok();
-      expect($('.pear').next().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .next()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create all elements in the array and add as next siblings', function() {
       var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>');
       more.insertAfter($('.apple'));
-      expect($fruits.children().eq(0).hasClass('apple')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(2).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
       $('.orange').insertAfter('.pear');
-      expect($fruits.children().eq(1).hasClass('orange')).to.not.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('orange')
+      ).to.not.be.ok();
       expect($fruits.children().length).to.be(3);
       expect($('.orange').length).to.be(1);
     });
 
     it('(existing Node) : should update original direct siblings', function() {
       $('.orange').insertAfter('.pear');
-      expect($('.apple').next().hasClass('pear')).to.be.ok();
-      expect($('.pear').prev().hasClass('apple')).to.be.ok();
-      expect($('.pear').next().hasClass('orange')).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('pear')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .prev()
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .next()
+          .hasClass('orange')
+      ).to.be.ok();
       expect($('.orange').next()).to.be.empty();
     });
 
     it('(existing Node) : should update original direct siblings of multiple elements', function() {
       $('.apple').insertAfter('.orange, .pear');
       expect($('.orange').prev()).to.be.empty();
-      expect($('.orange').next().hasClass('apple')).to.be.ok();
-      expect($('.pear').next().hasClass('apple')).to.be.ok();
-      expect($('.pear').prev().hasClass('apple')).to.be.ok();
+      expect(
+        $('.orange')
+          .next()
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .next()
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .prev()
+          .hasClass('apple')
+      ).to.be.ok();
       expect($fruits.children().length).to.be(4);
       var apples = $('.apple');
       expect(apples.length).to.be(2);
-      expect(apples.eq(0).prev().hasClass('orange')).to.be.ok();
-      expect(apples.eq(1).prev().hasClass('pear')).to.be.ok();
+      expect(
+        apples
+          .eq(0)
+          .prev()
+          .hasClass('orange')
+      ).to.be.ok();
+      expect(
+        apples
+          .eq(1)
+          .prev()
+          .hasClass('pear')
+      ).to.be.ok();
     });
 
     it('(elem) : should handle if removed', function() {
@@ -802,7 +1124,9 @@ describe('$(...)', function() {
     });
 
     it('(single) should return the new elements for chaining', function() {
-      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertAfter('.apple');
+      var $purple = $(
+        '<li class="grape">Grape</li><li class="plum">Plum</li>'
+      ).insertAfter('.apple');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(2);
@@ -811,7 +1135,9 @@ describe('$(...)', function() {
     });
 
     it('(multiple) should return the new elements for chaining', function() {
-      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertAfter('.apple, .pear');
+      var $purple = $(
+        '<li class="grape">Grape</li><li class="plum">Plum</li>'
+      ).insertAfter('.apple, .pear');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(4);
@@ -849,11 +1175,9 @@ describe('$(...)', function() {
       expect($things.eq(2).hasClass('apple')).to.be.ok();
       expect($things.eq(3).hasClass('orange')).to.be.ok();
     });
-
   });
 
   describe('.before', function() {
-
     it('() : should do nothing', function() {
       expect($('#fruits').before()[0].tagName).to.equal('ul');
     });
@@ -861,19 +1185,31 @@ describe('$(...)', function() {
     it('(html) : should add element as previous sibling', function() {
       var grape = '<li class="grape">Grape</li>';
       $('.apple').before(grape);
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should add element as previous sibling', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.apple').before($plum);
-      expect($('.apple').prev().hasClass('plum')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(Node) : should add element as previous sibling', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $('.apple').before(plum);
-      expect($('.apple').prev().hasClass('plum')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -898,10 +1234,26 @@ describe('$(...)', function() {
       $('.apple, .orange').before($originalPear);
 
       expect($('.pear')).to.have.length(2);
-      expect($('.pear').eq(0).prev()).to.have.length(0);
-      expect($('.pear').eq(0).next()[0]).to.be($('.apple')[0]);
-      expect($('.pear').eq(1).prev()[0]).to.be($('.apple')[0]);
-      expect($('.pear').eq(1).next()[0]).to.be($('.orange')[0]);
+      expect(
+        $('.pear')
+          .eq(0)
+          .prev()
+      ).to.have.length(0);
+      expect(
+        $('.pear')
+          .eq(0)
+          .next()[0]
+      ).to.be($('.apple')[0]);
+      expect(
+        $('.pear')
+          .eq(1)
+          .prev()[0]
+      ).to.be($('.apple')[0]);
+      expect(
+        $('.pear')
+          .eq(1)
+          .next()[0]
+      ).to.be($('.orange')[0]);
       expect($('.pear')[0]).to.not.eql($originalPear[0]);
       expect($('.pear')[1]).to.eql($originalPear[0]);
     });
@@ -916,19 +1268,38 @@ describe('$(...)', function() {
     });
 
     it('(Array) : should add all elements in the array as previous sibling', function() {
-      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
-        .get();
+      var more = $(
+        '<li class="plum">Plum</li><li class="grape">Grape</li>'
+      ).get();
       $('.apple').before(more);
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...), html) : should add multiple elements as previous siblings', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $('.apple').before($plum, grape);
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
-      expect($('.grape').prev().hasClass('plum')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $('.grape')
+          .prev()
+          .hasClass('plum')
+      ).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -942,11 +1313,7 @@ describe('$(...)', function() {
       });
 
       expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
     });
 
     it('(fn) : should add returned string as previous sibling', function() {
@@ -997,67 +1364,144 @@ describe('$(...)', function() {
   });
 
   describe('.insertBefore', function() {
-
     it('(selector) : should create element and add as prev sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore('.apple');
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('(selector) : should create element and add as prev sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore('.apple, .pear');
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
-      expect($('.pear').prev().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create element and add as prev sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore($('.apple'));
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore($('.apple, .pear'));
-      expect($('.apple').prev().hasClass('grape')).to.be.ok();
-      expect($('.pear').prev().hasClass('grape')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .prev()
+          .hasClass('grape')
+      ).to.be.ok();
     });
 
     it('($(...)) : should create all elements in the array and add as prev siblings', function() {
       var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>');
       more.insertBefore($('.apple'));
-      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
-      expect($fruits.children().eq(2).hasClass('apple')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(0)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(1)
+          .hasClass('grape')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('apple')
+      ).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
       $('.pear').insertBefore('.apple');
-      expect($fruits.children().eq(2).hasClass('pear')).to.not.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('pear')
+      ).to.not.be.ok();
       expect($fruits.children().length).to.be(3);
       expect($('.pear').length).to.be(1);
     });
 
     it('(existing Node) : should update original direct siblings', function() {
       $('.pear').insertBefore('.apple');
-      expect($('.apple').prev().hasClass('pear')).to.be.ok();
-      expect($('.apple').next().hasClass('orange')).to.be.ok();
-      expect($('.pear').next().hasClass('apple')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('pear')
+      ).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('orange')
+      ).to.be.ok();
+      expect(
+        $('.pear')
+          .next()
+          .hasClass('apple')
+      ).to.be.ok();
       expect($('.pear').prev()).to.be.empty();
     });
 
     it('(existing Node) : should update original direct siblings of multiple elements', function() {
       $('.pear').insertBefore('.apple, .orange');
-      expect($('.apple').prev().hasClass('pear')).to.be.ok();
-      expect($('.apple').next().hasClass('pear')).to.be.ok();
-      expect($('.orange').prev().hasClass('pear')).to.be.ok();
+      expect(
+        $('.apple')
+          .prev()
+          .hasClass('pear')
+      ).to.be.ok();
+      expect(
+        $('.apple')
+          .next()
+          .hasClass('pear')
+      ).to.be.ok();
+      expect(
+        $('.orange')
+          .prev()
+          .hasClass('pear')
+      ).to.be.ok();
       expect($('.orange').next()).to.be.empty();
       expect($fruits.children().length).to.be(4);
       var pears = $('.pear');
       expect(pears.length).to.be(2);
-      expect(pears.eq(0).next().hasClass('apple')).to.be.ok();
-      expect(pears.eq(1).next().hasClass('orange')).to.be.ok();
+      expect(
+        pears
+          .eq(0)
+          .next()
+          .hasClass('apple')
+      ).to.be.ok();
+      expect(
+        pears
+          .eq(1)
+          .next()
+          .hasClass('orange')
+      ).to.be.ok();
     });
 
     it('(elem) : should handle if removed', function() {
@@ -1078,7 +1522,9 @@ describe('$(...)', function() {
     });
 
     it('(single) should return the new elements for chaining', function() {
-      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertBefore('.apple');
+      var $purple = $(
+        '<li class="grape">Grape</li><li class="plum">Plum</li>'
+      ).insertBefore('.apple');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(2);
@@ -1087,7 +1533,9 @@ describe('$(...)', function() {
     });
 
     it('(multiple) should return the new elements for chaining', function() {
-      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertBefore('.apple, .pear');
+      var $purple = $(
+        '<li class="grape">Grape</li><li class="plum">Plum</li>'
+      ).insertBefore('.apple, .pear');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(4);
@@ -1125,11 +1573,9 @@ describe('$(...)', function() {
       expect($things.eq(2).hasClass('apple')).to.be.ok();
       expect($things.eq(3).hasClass('orange')).to.be.ok();
     });
-
   });
 
   describe('.remove', function() {
-
     it('() : should remove selected elements', function() {
       $('.apple').remove();
       expect($fruits.find('.apple')).to.have.length(0);
@@ -1159,21 +1605,39 @@ describe('$(...)', function() {
   });
 
   describe('.replaceWith', function() {
-
     it('(elem) : should replace one <li> tag with another', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.pear').replaceWith($plum);
-      expect($('.orange').next().hasClass('plum')).to.be.ok();
-      expect($('.orange').next().html()).to.equal('Plum');
+      expect(
+        $('.orange')
+          .next()
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $('.orange')
+          .next()
+          .html()
+      ).to.equal('Plum');
     });
 
     it('(Array) : should replace one <li> tag with the elements in the array', function() {
-      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
-        .get();
+      var more = $(
+        '<li class="plum">Plum</li><li class="grape">Grape</li>'
+      ).get();
       $('.pear').replaceWith(more);
 
-      expect($fruits.children().eq(2).hasClass('plum')).to.be.ok();
-      expect($fruits.children().eq(3).hasClass('grape')).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(2)
+          .hasClass('plum')
+      ).to.be.ok();
+      expect(
+        $fruits
+          .children()
+          .eq(3)
+          .hasClass('grape')
+      ).to.be.ok();
       expect($fruits.children()).to.have.length(4);
     });
 
@@ -1199,7 +1663,11 @@ describe('$(...)', function() {
 
       $pear.remove();
       $pear.replaceWith($plum);
-      expect($('.orange').next().hasClass('plum')).to.not.be.ok();
+      expect(
+        $('.orange')
+          .next()
+          .hasClass('plum')
+      ).to.not.be.ok();
     });
 
     it('(elem) : should replace the single selected element with given element', function() {
@@ -1306,7 +1774,7 @@ describe('$(...)', function() {
       expect($fruits.children()).to.have.length(4);
     });
 
-    it('() : should destroy children\'s references to the parent', function() {
+    it("() : should destroy children's references to the parent", function() {
       var $children = $fruits.children();
 
       $fruits.empty();
@@ -1321,17 +1789,17 @@ describe('$(...)', function() {
       expect($children.eq(2).next()).to.have.length(0);
       expect($children.eq(2).prev()).to.have.length(0);
     });
-
   });
 
   describe('.html', function() {
-
     it('() : should get the innerHTML for an element', function() {
-      expect($fruits.html()).to.equal([
-        '<li class="apple">Apple</li>',
-        '<li class="orange">Orange</li>',
-        '<li class="pear">Pear</li>'
-      ].join(''));
+      expect($fruits.html()).to.equal(
+        [
+          '<li class="apple">Apple</li>',
+          '<li class="orange">Orange</li>',
+          '<li class="pear">Pear</li>'
+        ].join('')
+      );
     });
 
     it('() : should get innerHTML even if its just text', function() {
@@ -1354,8 +1822,13 @@ describe('$(...)', function() {
       $fruits = $('li');
       $fruits.html('<li class="durian">Durian</li>');
       var tested = 0;
-      $fruits.each(function(){
-        expect($(this).children().parent().get(0)).to.equal(this);
+      $fruits.each(function() {
+        expect(
+          $(this)
+            .children()
+            .parent()
+            .get(0)
+        ).to.equal(this);
         tested++;
       });
       expect(tested).to.equal(3);
@@ -1386,7 +1859,9 @@ describe('$(...)', function() {
     });
 
     it('() : should return an html string for a set of elements', function() {
-      expect($fruits.find('li').toString()).to.equal('<li class="apple">Apple</li><li class="orange">Orange</li><li class="pear">Pear</li>');
+      expect($fruits.find('li').toString()).to.equal(
+        '<li class="apple">Apple</li><li class="orange">Orange</li><li class="pear">Pear</li>'
+      );
     });
 
     it('() : should be called implicitly', function() {
@@ -1395,13 +1870,12 @@ describe('$(...)', function() {
     });
 
     it('() : should pass options', function() {
-      var dom = cheerio.load('&', {decodeEntities: false});
+      var dom = cheerio.load('&', { xml: { decodeEntities: false } });
       expect(dom.root().toString()).to.equal('&');
     });
   });
 
   describe('.text', function() {
-
     it('() : gets the text for a single element', function() {
       expect($('.apple').text()).to.equal('Apple');
     });
@@ -1418,13 +1892,25 @@ describe('$(...)', function() {
     it('(text) : inserts separate nodes for all children', function() {
       $('li').text('Fruits');
       var tested = 0;
-      $('li').each(function(){
-        expect(this.childNodes[0].parent).to.equal(this);
+      $('li').each(function() {
+        expect(this.childNodes[0].parentNode).to.equal(this);
         tested++;
       });
       expect(tested).to.equal(3);
     });
 
+    it('(text) : should create a Node with the DOM level 1 API', function() {
+      var $apple = $('.apple');
+      var textNode;
+
+      $apple.text('anything');
+      textNode = $apple[0].childNodes[0];
+
+      expect(textNode.parentNode).to.be($apple[0]);
+      expect(textNode.nodeType).to.be(3);
+      expect(textNode.data).to.be('anything');
+    });
+
     it('should allow functions as arguments', function() {
       $('.apple').text(function(idx, content) {
         expect(idx).to.equal(0);
@@ -1434,6 +1920,15 @@ describe('$(...)', function() {
       expect($('.apple')[0].childNodes[0].data).to.equal('whatever mate');
     });
 
+    it('should allow functions as arguments for multiple elements', function() {
+      $('li').text(function(idx) {
+        return 'text' + idx;
+      });
+      $('li').each(function(idx) {
+        expect(this.childNodes[0].data).to.equal('text' + idx);
+      });
+    });
+
     it('should decode special chars', function() {
       var text = $('<p>M&amp;M</p>').text();
       expect(text).to.equal('M&M');
@@ -1456,23 +1951,34 @@ describe('$(...)', function() {
     });
 
     it('( null ) : should convert to string', function() {
-      expect($('<div>').text(null).text()).to.equal('null');
+      expect(
+        $('<div>')
+          .text(null)
+          .text()
+      ).to.equal('null');
     });
 
     it('( 0 ) : should convert to string', function() {
-      expect($('<div>').text(0).text()).to.equal('0');
+      expect(
+        $('<div>')
+          .text(0)
+          .text()
+      ).to.equal('0');
     });
 
     it('(str) should encode then decode unsafe characters', function() {
       var $apple = $('.apple');
 
       $apple.text('blah <script>alert("XSS!")</script> blah');
-      expect($apple[0].childNodes[0].data).to.equal('blah <script>alert("XSS!")</script> blah');
-      expect($apple.text()).to.equal('blah <script>alert("XSS!")</script> blah');
+      expect($apple[0].childNodes[0].data).to.equal(
+        'blah <script>alert("XSS!")</script> blah'
+      );
+      expect($apple.text()).to.equal(
+        'blah <script>alert("XSS!")</script> blah'
+      );
 
       $apple.text('blah <script>alert("XSS!")</script> blah');
       expect($apple.html()).to.not.contain('<script>alert("XSS!")</script>');
     });
   });
-
 });
diff --git a/test/api/traversing.js b/test/api/traversing.js
index 06a969ca42..61e018d668 100644
--- a/test/api/traversing.js
+++ b/test/api/traversing.js
@@ -1,20 +1,30 @@
+/*global Symbol*/
 var expect = require('expect.js'),
-  cheerio = require('../..'),
-  food = require('../fixtures').food,
-  fruits = require('../fixtures').fruits,
-  drinks = require('../fixtures').drinks,
-  text = require('../fixtures').text;
+    cheerio = require('../..'),
+    food = require('../fixtures').food,
+    fruits = require('../fixtures').fruits,
+    drinks = require('../fixtures').drinks,
+    text = require('../fixtures').text;
 
 describe('$(...)', function() {
-
   var $;
 
   beforeEach(function() {
     $ = cheerio.load(fruits);
   });
 
-  describe('.find', function() {
+  describe('.load', function() {
+    it('should throw a TypeError if given invalid input', function() {
+      expect(function() {
+        cheerio.load();
+      }).to.throwException(function(err) {
+        expect(err).to.be.an(Error);
+        expect(err.message).to.be('cheerio.load() expects a string');
+      });
+    });
+  });
 
+  describe('.find', function() {
     it('() : should find nothing', function() {
       expect($('ul').find()).to.have.length(0);
     });
@@ -52,19 +62,19 @@ describe('$(...)', function() {
       expect(q('foo').find('> bar')).to.have.length(1);
     });
 
-    it('should query case-sensitively when in xmlMode', function() {
-      var q = cheerio.load('<caseSenSitive allTheWay>', {xmlMode: true});
+    it('should query case-sensitively when in xml mode', function() {
+      var q = cheerio.load('<caseSenSitive allTheWay>', { xml: true });
       expect(q('caseSenSitive')).to.have.length(1);
       expect(q('[allTheWay]')).to.have.length(1);
       expect(q('casesensitive')).to.have.length(0);
       expect(q('[alltheway]')).to.have.length(0);
     });
 
-    it('should throw a SyntaxError if given an invalid selector', function() {
+    it('should throw an Error if given an invalid selector', function() {
       expect(function() {
         $('#fruits').find(':bah');
       }).to.throwException(function(err) {
-        expect(err).to.be.a(SyntaxError);
+        expect(err).to.be.a(Error);
       });
     });
 
@@ -113,7 +123,6 @@ describe('$(...)', function() {
   });
 
   describe('.children', function() {
-
     it('() : should get all children', function() {
       expect($('ul').children()).to.have.length(3);
     });
@@ -134,11 +143,9 @@ describe('$(...)', function() {
     it('should only match immediate children, not ancestors', function() {
       expect($(food).children('li')).to.have.length(0);
     });
-
   });
 
   describe('.contents', function() {
-
     beforeEach(function() {
       $ = cheerio.load(text);
     });
@@ -148,17 +155,23 @@ describe('$(...)', function() {
     });
 
     it('() : should include text nodes', function() {
-      expect($('p').contents().first()[0].type).to.equal('text');
+      expect(
+        $('p')
+          .contents()
+          .first()[0].type
+      ).to.equal('text');
     });
 
     it('() : should include comment nodes', function() {
-      expect($('p').contents().last()[0].type).to.equal('comment');
+      expect(
+        $('p')
+          .contents()
+          .last()[0].type
+      ).to.equal('comment');
     });
-
   });
 
   describe('.next', function() {
-
     it('() : should return next element', function() {
       var cls = $('.orange').next()[0].attribs['class'];
       expect(cls).to.equal('pear');
@@ -185,11 +198,9 @@ describe('$(...)', function() {
         expect($('.apple').next('.orange')).to.have.length(1);
       });
     });
-
   });
 
   describe('.nextAll', function() {
-
     it('() : should return all following siblings', function() {
       var elems = $('.apple').nextAll();
       expect(elems).to.have.length(2);
@@ -219,15 +230,13 @@ describe('$(...)', function() {
         expect($('.apple').nextAll('.pear')).to.have.length(1);
       });
 
-      it('should not consider siblings\' contents when filtering', function() {
+      it("should not consider siblings' contents when filtering", function() {
         expect($('#fruits', food).nextAll('li')).to.have.length(0);
       });
     });
-
   });
 
   describe('.nextUntil', function() {
-
     it('() : should return all following siblings if no selector specified', function() {
       var elems = $('.apple', food).nextUntil();
       expect(elems).to.have.length(2);
@@ -270,7 +279,10 @@ describe('$(...)', function() {
 
     it('(null, filterString) : should return all following siblings until selector, filtered by filter', function() {
       var elems = $('<ul><li></li><li><p></p></li></ul>');
-      var empty = elems.find('li').eq(0).nextUntil(null, 'p');
+      var empty = elems
+        .find('li')
+        .eq(0)
+        .nextUntil(null, 'p');
       expect(empty).to.have.length(0);
     });
 
@@ -294,11 +306,9 @@ describe('$(...)', function() {
       var elems = $drinks.eq(0).nextUntil($until);
       expect(elems).to.have.length(2);
     });
-
   });
 
   describe('.prev', function() {
-
     it('() : should return previous element', function() {
       var cls = $('.orange').prev()[0].attribs['class'];
       expect(cls).to.equal('apple');
@@ -325,11 +335,9 @@ describe('$(...)', function() {
         expect($('.orange').prev('.apple')).to.have.length(1);
       });
     });
-
   });
 
   describe('.prevAll', function() {
-
     it('() : should return all preceding siblings', function() {
       var elems = $('.pear').prevAll();
       expect(elems).to.have.length(2);
@@ -360,16 +368,14 @@ describe('$(...)', function() {
         expect(elems).to.have.length(1);
       });
 
-      it('should not consider siblings\'s descendents', function() {
+      it("should not consider siblings's descendents", function() {
         var elems = $('#vegetables', food).prevAll('li');
         expect(elems).to.have.length(0);
       });
     });
-
   });
 
   describe('.prevUntil', function() {
-
     it('() : should return all preceding siblings if no selector specified', function() {
       var elems = $('.pear').prevUntil();
       expect(elems).to.have.length(2);
@@ -378,7 +384,9 @@ describe('$(...)', function() {
     });
 
     it('() : should filter out non-element nodes', function() {
-      var elems = $('<div class="1"><div class="2"></div><!-- comment -->text<div class="3"></div></div>');
+      var elems = $(
+        '<div class="1"><div class="2"></div><!-- comment -->text<div class="3"></div></div>'
+      );
       var div = elems.children().last();
       expect(div.prevUntil()).to.have.length(1);
     });
@@ -413,7 +421,10 @@ describe('$(...)', function() {
 
     it('(selector, filterString) : should return all preceding siblings until selector', function() {
       var elems = $('<ul><li><p></p></li><li></li></ul>');
-      var empty = elems.find('li').eq(1).prevUntil(null, 'p');
+      var empty = elems
+        .find('li')
+        .eq(1)
+        .prevUntil(null, 'p');
       expect(empty).to.have.length(0);
     });
 
@@ -437,11 +448,9 @@ describe('$(...)', function() {
       var elems = $drinks.eq(4).prevUntil($until);
       expect(elems).to.have.length(2);
     });
-
   });
 
   describe('.siblings', function() {
-
     it('() : should get all the siblings', function() {
       expect($('.orange').siblings()).to.have.length(2);
       expect($('#fruits').siblings()).to.have.length(0);
@@ -453,34 +462,36 @@ describe('$(...)', function() {
       expect($('.orange').siblings('.peach')).to.have.length(0);
     });
 
-    it('(selector) : should throw a SyntaxError if given an invalid selector', function() {
+    it('(selector) : should throw an Error if given an invalid selector', function() {
       expect(function() {
         $('.orange').siblings(':bah');
       }).to.throwException(function(err) {
-        expect(err).to.be.a(SyntaxError);
+        expect(err).to.be.a(Error);
       });
     });
 
     it('(selector) : does not consider the contents of siblings when filtering (GH-374)', function() {
       expect($('#fruits', food).siblings('li')).to.have.length(0);
     });
-
   });
 
   describe('.parents', function() {
-
     beforeEach(function() {
       $ = cheerio.load(food);
     });
 
-    it('() : should get all of the parents in logical order', function(){
+    it('() : should get all of the parents in logical order', function() {
       var result = $('.orange').parents();
-      expect(result).to.have.length(2);
+      expect(result).to.have.length(4);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
+      expect(result[2].tagName).to.be('body');
+      expect(result[3].tagName).to.be('html');
       result = $('#fruits').parents();
-      expect(result).to.have.length(1);
+      expect(result).to.have.length(3);
       expect(result[0].attribs.id).to.be('food');
+      expect(result[1].tagName).to.be('body');
+      expect(result[2].tagName).to.be('html');
     });
 
     it('(selector) : should get all of the parents that match the selector in logical order', function() {
@@ -499,40 +510,44 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty set for top-level elements', function() {
-      var result = $('#food').parents();
+      var result = $('html').parents();
       expect(result).to.have.length(0);
     });
 
     it('() : should return the parents of every element in the *reveresed* collection, omitting duplicates', function() {
       var $parents = $('li').parents();
 
-      expect($parents).to.have.length(3);
+      expect($parents).to.have.length(5);
       expect($parents[0]).to.be($('#vegetables')[0]);
       expect($parents[1]).to.be($('#food')[0]);
-      expect($parents[2]).to.be($('#fruits')[0]);
+      expect($parents[2]).to.be($('body')[0]);
+      expect($parents[3]).to.be($('html')[0]);
+      expect($parents[4]).to.be($('#fruits')[0]);
     });
-
   });
 
   describe('.parentsUntil', function() {
-
     beforeEach(function() {
       $ = cheerio.load(food);
     });
 
     it('() : should get all of the parents in logical order', function() {
       var result = $('.orange').parentsUntil();
-      expect(result).to.have.length(2);
+      expect(result).to.have.length(4);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
+      expect(result[2].tagName).to.be('body');
+      expect(result[3].tagName).to.be('html');
     });
 
     it('() : should get all of the parents in reversed order, omitting duplicates', function() {
       var result = $('.apple, .sweetcorn').parentsUntil();
-      expect(result).to.have.length(3);
+      expect(result).to.have.length(5);
       expect(result[0].attribs.id).to.be('vegetables');
       expect(result[1].attribs.id).to.be('food');
-      expect(result[2].attribs.id).to.be('fruits');
+      expect(result[2].tagName).to.be('body');
+      expect(result[3].tagName).to.be('html');
+      expect(result[4].attribs.id).to.be('fruits');
     });
 
     it('(selector) : should get all of the parents until selector', function() {
@@ -545,13 +560,18 @@ describe('$(...)', function() {
 
     it('(selector not parent) : should return all parents', function() {
       var result = $('.orange').parentsUntil('.apple');
-      expect(result).to.have.length(2);
+      expect(result).to.have.length(4);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
+      expect(result[2].tagName).to.be('body');
+      expect(result[3].tagName).to.be('html');
     });
 
     it('(selector, filter) : should get all of the parents that match the filter', function() {
-      var result = $('.apple, .sweetcorn').parentsUntil('.saladbar', '#vegetables');
+      var result = $('.apple, .sweetcorn').parentsUntil(
+        '.saladbar',
+        '#vegetables'
+      );
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('vegetables');
     });
@@ -562,22 +582,23 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty set for top-level elements', function() {
-      var result = $('#food').parentsUntil();
+      var result = $('html').parentsUntil();
       expect(result).to.have.length(0);
     });
 
     it('(cheerio object) : should return all parents until any member of the cheerio object', function() {
       var $fruits = $('#fruits');
       var $until = $('#food');
-      var result = $fruits.children().eq(1).parentsUntil($until);
+      var result = $fruits
+        .children()
+        .eq(1)
+        .parentsUntil($until);
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('fruits');
     });
-
   });
 
   describe('.parent', function() {
-
     it('() : should return the parent of each matched element', function() {
       var result = $('.orange').parent();
       expect(result).to.have.length(1);
@@ -589,7 +610,7 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty object for top-level elements', function() {
-      var result = $('ul').parent();
+      var result = $('html').parent();
       expect(result).to.have.length(0);
     });
 
@@ -606,11 +627,9 @@ describe('$(...)', function() {
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('fruits');
     });
-
   });
 
   describe('.closest', function() {
-
     it('() : should return an empty array', function() {
       var result = $('.orange').closest();
       expect(result).to.have.length(0);
@@ -636,11 +655,9 @@ describe('$(...)', function() {
       var result = $('.saladbar', food).closest('ul');
       expect(result).to.have.length(0);
     });
-
   });
 
   describe('.each', function() {
-
     it('( (i, elem) -> ) : should loop selected returning fn with (i, elem)', function() {
       var items = [],
           classes = ['apple', 'orange', 'pear'];
@@ -662,9 +679,23 @@ describe('$(...)', function() {
 
       expect(iterationCount).to.equal(2);
     });
-
   });
 
+  if (typeof Symbol !== 'undefined') {
+    describe('[Symbol.iterator]', function() {
+
+      it('should yield each element', function() {
+        // The equivalent of: for (const element of $('li')) ...
+        var $li = $('li'),
+            iterator = $li[Symbol.iterator]();
+        expect(iterator.next().value.attribs['class']).to.equal('apple');
+        expect(iterator.next().value.attribs['class']).to.equal('orange');
+        expect(iterator.next().value.attribs['class']).to.equal('pear');
+        expect(iterator.next().done).to.equal(true);
+      });
+    });
+  }
+
   describe('.map', function() {
     it('(fn) : should be invoked with the correct arguments and context', function() {
       var $fruits = $('li');
@@ -676,16 +707,8 @@ describe('$(...)', function() {
         thisVals.push(this);
       });
 
-      expect(args).to.eql([
-        [0, $fruits[0]],
-        [1, $fruits[1]],
-        [2, $fruits[2]]
-      ]);
-      expect(thisVals).to.eql([
-        $fruits[0],
-        $fruits[1],
-        $fruits[2]
-      ]);
+      expect(args).to.eql([[0, $fruits[0]], [1, $fruits[1]], [2, $fruits[2]]]);
+      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
     });
 
     it('(fn) : should return an Cheerio object wrapping the returned items', function() {
@@ -719,11 +742,7 @@ describe('$(...)', function() {
         return [1, [3, 4]];
       });
 
-      expect($mapped.get()).to.eql([
-        1, [3, 4],
-        1, [3, 4],
-        1, [3, 4]
-      ]);
+      expect($mapped.get()).to.eql([1, [3, 4], 1, [3, 4], 1, [3, 4]]);
     });
 
     it('(fn) : should tolerate `null` and `undefined` when flattening arrays returned by iterator', function() {
@@ -734,16 +753,21 @@ describe('$(...)', function() {
       });
 
       expect($mapped.get()).to.eql([
-        null, undefined,
-        null, undefined,
-        null, undefined,
+        null,
+        undefined,
+        null,
+        undefined,
+        null,
+        undefined
       ]);
     });
   });
 
   describe('.filter', function() {
     it('(selector) : should reduce the set of matched elements to those that match the selector', function() {
-      var pear = $('li').filter('.pear').text();
+      var pear = $('li')
+        .filter('.pear')
+        .text();
       expect(pear).to.be('Pear');
     });
 
@@ -764,13 +788,15 @@ describe('$(...)', function() {
       expect($fruits.filter(pear)).to.have.length(1);
     });
 
-    it('(fn) : should reduce the set of matched elements to those that pass the function\'s test', function() {
-      var orange = $('li').filter(function(i, el) {
-        expect(this).to.be(el);
-        expect(el.tagName).to.be('li');
-        expect(i).to.be.a('number');
-        return $(this).attr('class') === 'orange';
-      }).text();
+    it("(fn) : should reduce the set of matched elements to those that pass the function's test", function() {
+      var orange = $('li')
+        .filter(function(i, el) {
+          expect(this).to.be(el);
+          expect(el.tagName).to.be('li');
+          expect(i).to.be.a('number');
+          return $(this).attr('class') === 'orange';
+        })
+        .text();
 
       expect(orange).to.be('Orange');
     });
@@ -814,7 +840,7 @@ describe('$(...)', function() {
       expect($notApple[1]).to.be($fruits[2]);
     });
 
-    it('(fn) : should reduce the set of matched elements to those that do not pass the function\'s test', function() {
+    it("(fn) : should reduce the set of matched elements to those that do not pass the function's test", function() {
       var $fruits = $('li');
 
       var $notOrange = $fruits.not(function(i, el) {
@@ -831,7 +857,6 @@ describe('$(...)', function() {
   });
 
   describe('.has', function() {
-
     beforeEach(function() {
       $ = cheerio.load(food);
     });
@@ -863,7 +888,6 @@ describe('$(...)', function() {
   });
 
   describe('.first', function() {
-
     it('() : should return the first item', function() {
       var $src = $('<span>foo</span><span>bar</span><span>baz</span>');
       var $elem = $src.first();
@@ -877,11 +901,9 @@ describe('$(...)', function() {
       expect($first.length).to.equal(0);
       expect($first[0]).to.be(undefined);
     });
-
   });
 
   describe('.last', function() {
-
     it('() : should return the last element', function() {
       var $src = $('<span>foo</span><span>bar</span><span>baz</span>');
       var $elem = $src.last();
@@ -895,11 +917,9 @@ describe('$(...)', function() {
       expect($last.length).to.equal(0);
       expect($last[0]).to.be(undefined);
     });
-
   });
 
   describe('.first & .last', function() {
-
     it('() : should return equivalent collections if only one element', function() {
       var $src = $('<span>bar</span>');
       var $first = $src.first();
@@ -910,13 +930,11 @@ describe('$(...)', function() {
       expect($last[0].childNodes[0].data).to.equal('bar');
       expect($first[0]).to.equal($last[0]);
     });
-
   });
 
   describe('.eq', function() {
-
     function getText(el) {
-      if(!el.length) return '';
+      if (!el.length) return '';
       return el[0].childNodes[0].data;
     }
 
@@ -927,11 +945,9 @@ describe('$(...)', function() {
       expect(getText($('li').eq(3))).to.equal('');
       expect(getText($('li').eq(-1))).to.equal('Pear');
     });
-
   });
 
   describe('.get', function() {
-
     it('(i) : should return the element at the specified index', function() {
       var children = $('#fruits').children();
       expect(children.get(0)).to.be(children[0]);
@@ -950,13 +966,8 @@ describe('$(...)', function() {
       var children = $('#fruits').children();
       var all = children.get();
       expect(Array.isArray(all)).to.be.ok();
-      expect(all).to.eql([
-        children[0],
-        children[1],
-        children[2]
-      ]);
+      expect(all).to.eql([children[0], children[1], children[2]]);
     });
-
   });
 
   describe('.index', function() {
@@ -1014,9 +1025,8 @@ describe('$(...)', function() {
   });
 
   describe('.slice', function() {
-
     function getText(el) {
-      if(!el.length) return '';
+      if (!el.length) return '';
       return el[0].childNodes[0].data;
     }
 
@@ -1038,7 +1048,6 @@ describe('$(...)', function() {
       expect(sliced).to.have.length(1);
       expect(getText(sliced.eq(0))).to.equal('Pear');
     });
-
   });
 
   describe('.end() :', function() {
@@ -1049,8 +1058,18 @@ describe('$(...)', function() {
     });
 
     it('returns an empty object at the end of the chain', function() {
-      expect($fruits.end().end().end()).to.be.ok();
-      expect($fruits.end().end().end()).to.have.length(0);
+      expect(
+        $fruits
+          .end()
+          .end()
+          .end()
+      ).to.be.ok();
+      expect(
+        $fruits
+          .end()
+          .end()
+          .end()
+      ).to.have.length(0);
     });
     it('find', function() {
       expect($fruits.find('.apple').end()).to.be($fruits);
@@ -1059,7 +1078,13 @@ describe('$(...)', function() {
       expect($fruits.filter('.apple').end()).to.be($fruits);
     });
     it('map', function() {
-      expect($fruits.map(function() { return this; }).end()).to.be($fruits);
+      expect(
+        $fruits
+          .map(function() {
+            return this;
+          })
+          .end()
+      ).to.be($fruits);
     });
     it('contents', function() {
       expect($fruits.contents().end()).to.be($fruits);
@@ -1373,7 +1398,9 @@ describe('$(...)', function() {
   describe('.addBack', function() {
     describe('() : ', function() {
       it('includes siblings and self', function() {
-        var $selection = $('.orange').siblings().addBack();
+        var $selection = $('.orange')
+          .siblings()
+          .addBack();
 
         expect($selection).to.have.length(3);
         expect($selection[0]).to.be($('.apple')[0]);
@@ -1381,7 +1408,9 @@ describe('$(...)', function() {
         expect($selection[2]).to.be($('.pear')[0]);
       });
       it('includes children and self', function() {
-        var $selection = $('#fruits').children().addBack();
+        var $selection = $('#fruits')
+          .children()
+          .addBack();
 
         expect($selection).to.have.length(4);
         expect($selection[0]).to.be($('#fruits')[0]);
@@ -1390,7 +1419,9 @@ describe('$(...)', function() {
         expect($selection[3]).to.be($('.pear')[0]);
       });
       it('includes parent and self', function() {
-        var $selection = $('.apple').parent().addBack();
+        var $selection = $('.apple')
+          .parent()
+          .addBack();
 
         expect($selection).to.have.length(2);
         expect($selection[0]).to.be($('#fruits')[0]);
@@ -1398,16 +1429,22 @@ describe('$(...)', function() {
       });
       it('includes parents and self', function() {
         var q = cheerio.load(food);
-        var $selection = q('.apple').parents().addBack();
-
-        expect($selection).to.have.length(3);
-        expect($selection[0]).to.be(q('#food')[0]);
-        expect($selection[1]).to.be(q('#fruits')[0]);
-        expect($selection[2]).to.be(q('.apple')[0]);
+        var $selection = q('.apple')
+          .parents()
+          .addBack();
+
+        expect($selection).to.have.length(5);
+        expect($selection[0]).to.be(q('html')[0]);
+        expect($selection[1]).to.be(q('body')[0]);
+        expect($selection[2]).to.be(q('#food')[0]);
+        expect($selection[3]).to.be(q('#fruits')[0]);
+        expect($selection[4]).to.be(q('.apple')[0]);
       });
     });
     it('(filter) : filters the previous selection', function() {
-      var $selection = $('li').eq(1).addBack('.apple');
+      var $selection = $('li')
+        .eq(1)
+        .addBack('.apple');
 
       expect($selection).to.have.length(2);
       expect($selection[0]).to.be($('.apple')[0]);
diff --git a/test/api/utils.js b/test/api/utils.js
index d6983c8a1c..28c0ab7d55 100644
--- a/test/api/utils.js
+++ b/test/api/utils.js
@@ -3,9 +3,7 @@ var expect = require('expect.js'),
     cheerio = require('../..');
 
 describe('cheerio', function() {
-
   describe('.html', function() {
-
     it('() : should return innerHTML; $.html(obj) should return outerHTML', function() {
       var $div = cheerio('div', '<div><span>foo</span><span>bar</span></div>');
       var span = $div.children()[1];
@@ -23,95 +21,101 @@ describe('cheerio', function() {
       var $elem = cheerio('<span>foo</span>').html('');
       expect(cheerio.html($elem)).to.equal('<span></span>');
     });
-
-    it('() : of empty cheerio object should return null', function() {
-      expect(cheerio().html()).to.be(null);
-    });
-
-    it('(selector) : should return the outerHTML of the selected element', function() {
-      var $ = cheerio.load(fixtures.fruits);
-      expect($.html('.pear')).to.equal('<li class="pear">Pear</li>');
-    });
   });
 
-
   describe('.text', function() {
     it('(cheerio object) : should return the text contents of the specified elements', function() {
       var $ = cheerio.load('<a>This is <em>content</em>.</a>');
-      expect($.text($('a'))).to.equal('This is content.');
+      expect(cheerio.text($('a'))).to.equal('This is content.');
     });
 
     it('(cheerio object) : should omit comment nodes', function() {
       var $ = cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
-      expect($.text($('a'))).to.equal('This is  not a comment.');
+      expect(cheerio.text($('a'))).to.equal('This is  not a comment.');
     });
 
     it('(cheerio object) : should include text contents of children recursively', function() {
-      var $ = cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
-      expect($.text($('a'))).to.equal('This is a child with another child and  not a comment followed by one last child and some final text.');
+      var $ = cheerio.load(
+        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
+      );
+      expect(cheerio.text($('a'))).to.equal(
+        'This is a child with another child and  not a comment followed by one last child and some final text.'
+      );
     });
 
     it('() : should return the rendered text content of the root', function() {
-      var $ = cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
-      expect($.text()).to.equal('This is a child with another child and  not a comment followed by one last child and some final text.');
+      var $ = cheerio.load(
+        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
+      );
+      expect(cheerio.text($.root())).to.equal(
+        'This is a child with another child and  not a comment followed by one last child and some final text.'
+      );
     });
 
-    it('(cheerio object) : should omit script tags', function(){
-       var $ = cheerio.load('<script>console.log("test")</script>');
-       expect($.text()).to.equal('');
+    it('(cheerio object) : should omit script tags', function() {
+      var $ = cheerio.load('<script>console.log("test")</script>');
+      expect(cheerio.text($.root())).to.equal('');
     });
 
-    it('(cheerio object) : should omit style tags', function(){
-       var $ = cheerio.load('<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>');
-       expect($.text()).to.equal('');
+    it('(cheerio object) : should omit style tags', function() {
+      var $ = cheerio.load(
+        '<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>'
+      );
+      expect($.text()).to.equal('');
     });
 
-     it('(cheerio object) : should include text contents of children omiting style and script tags', function(){
-       var $ = cheerio.load('<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>');
-       expect($.text()).to.equal('Welcome Hello, testing text function,End of messege');
+    it('(cheerio object) : should include text contents of children omiting style and script tags', function() {
+      var $ = cheerio.load(
+        '<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>'
+      );
+      expect(cheerio.text($.root())).to.equal(
+        'Welcome Hello, testing text function,End of messege'
+      );
     });
-
   });
 
-
   describe('.load', function() {
-
     it('(html) : should retain original root after creating a new node', function() {
-      var $html = cheerio.load('<body><ul id="fruits"></ul></body>');
-      expect($html('body')).to.have.length(1);
-      $html('<script>');
-      expect($html('body')).to.have.length(1);
+      var $ = cheerio.load('<body><ul id="fruits"></ul></body>');
+      expect($('body')).to.have.length(1);
+      $('<script>');
+      expect($('body')).to.have.length(1);
     });
 
     it('(html) : should handle lowercase tag options', function() {
-      var $html = cheerio.load('<BODY><ul id="fruits"></ul></BODY>', { lowerCaseTags : true });
-      expect($html.html()).to.be('<body><ul id="fruits"></ul></body>');
+      var $ = cheerio.load('<BODY><ul id="fruits"></ul></BODY>', {
+        xml: { lowerCaseTags: true }
+      });
+      expect($.html()).to.be('<body><ul id="fruits"/></body>');
     });
 
     it('(html) : should handle the `normalizeWhitepace` option', function() {
-      var $html = cheerio.load('<body><b>foo</b>  <b>bar</b></body>', { normalizeWhitespace : true });
-      expect($html.html()).to.be('<body><b>foo</b> <b>bar</b></body>');
+      var $ = cheerio.load('<body><b>foo</b>  <b>bar</b></body>', {
+        xml: { normalizeWhitespace: true }
+      });
+      expect($.html()).to.be('<body><b>foo</b> <b>bar</b></body>');
     });
 
     // TODO:
     // it('(html) : should handle xml tag option', function() {
-    //   var $html = $.load('<body><script>oh hai</script></body>', { xmlMode : true });
-    //   console.log($html('script')[0].type);
-    //   expect($html('script')[0].type).to.be('tag');
+    //   var $ = $.load('<body><script>oh hai</script></body>', { xml : true });
+    //   console.log($('script')[0].type);
+    //   expect($('script')[0].type).to.be('tag');
     // });
 
     it('(buffer) : should accept a buffer', function() {
-      var $html = cheerio.load(new Buffer('<div>foo</div>'));
-      expect($html.html()).to.be('<div>foo</div>');
+      var $ = cheerio.load(
+        new Buffer('<html><head></head><body>foo</body></html>')
+      );
+      expect($.html()).to.be('<html><head></head><body>foo</body></html>');
     });
-
   });
 
-
   describe('.clone', function() {
-
     it('() : should return a copy', function() {
-      var $src = cheerio('<div><span>foo</span><span>bar</span><span>baz</span></div>').children();
+      var $src = cheerio(
+        '<div><span>foo</span><span>bar</span><span>baz</span></div>'
+      ).children();
       var $elem = $src.clone();
       expect($elem.length).to.equal(3);
       expect($elem.parent()).to.have.length(0);
@@ -120,6 +124,19 @@ describe('cheerio', function() {
       expect($elem.text()).to.not.equal($src.text());
     });
 
+    it('() : should return a copy of document', function() {
+      var $src = cheerio
+        .load('<html><body><div>foo</div>bar</body></html>')
+        .root()
+        .children();
+      var $elem = $src.clone();
+      expect($elem.length).to.equal(1);
+      expect($elem.parent()).to.have.length(0);
+      expect($elem.text()).to.equal($src.text());
+      $src.text('rofl');
+      expect($elem.text()).to.not.equal($src.text());
+    });
+
     it('() : should preserve parsing options', function() {
       var $ = cheerio.load('<div>π</div>', { decodeEntities: false });
       var $div = $('div');
@@ -129,22 +146,23 @@ describe('cheerio', function() {
   });
 
   describe('.parseHTML', function() {
+    var $ = cheerio.load('');
 
     it('() : returns null', function() {
-      expect(cheerio.parseHTML()).to.equal(null);
+      expect($.parseHTML()).to.equal(null);
     });
 
     it('(null) : returns null', function() {
-      expect(cheerio.parseHTML(null)).to.equal(null);
+      expect($.parseHTML(null)).to.equal(null);
     });
 
     it('("") : returns null', function() {
-      expect(cheerio.parseHTML('')).to.equal(null);
+      expect($.parseHTML('')).to.equal(null);
     });
 
     it('(largeHtmlString) : parses large HTML strings', function() {
       var html = new Array(10).join('<div></div>');
-      var nodes = cheerio.parseHTML(html);
+      var nodes = $.parseHTML(html);
 
       expect(nodes.length).to.be.greaterThan(4);
       expect(nodes).to.be.an('array');
@@ -152,47 +170,49 @@ describe('cheerio', function() {
 
     it('("<script>") : ignores scripts by default', function() {
       var html = '<script>undefined()</script>';
-      expect(cheerio.parseHTML(html)).to.have.length(0);
+      expect($.parseHTML(html)).to.have.length(0);
     });
 
     it('("<script>", true) : preserves scripts when requested', function() {
       var html = '<script>undefined()</script>';
-      expect(cheerio.parseHTML(html, true)[0].tagName).to.match(/script/i);
+      expect($.parseHTML(html, true)[0].tagName).to.match(/script/i);
     });
 
     it('("scriptAndNonScript) : preserves non-script nodes', function() {
       var html = '<script>undefined()</script><div></div>';
-      expect(cheerio.parseHTML(html)[0].tagName).to.match(/div/i);
+      expect($.parseHTML(html)[0].tagName).to.match(/div/i);
     });
 
     it('(scriptAndNonScript, true) : Preserves script position', function() {
       var html = '<script>undefined()</script><div></div>';
-      expect(cheerio.parseHTML(html, true)[0].tagName).to.match(/script/i);
+      expect($.parseHTML(html, true)[0].tagName).to.match(/script/i);
     });
 
     it('(text) : returns a text node', function() {
-      expect(cheerio.parseHTML('text')[0].type).to.be('text');
+      expect($.parseHTML('text')[0].type).to.be('text');
     });
 
     it('(\\ttext) : preserves leading whitespace', function() {
-      expect(cheerio.parseHTML('\t<div></div>')[0].data).to.equal('\t');
+      expect($.parseHTML('\t<div></div>')[0].data).to.equal('\t');
     });
 
     it('( text) : Leading spaces are treated as text nodes', function() {
-      expect(cheerio.parseHTML(' <div/> ')[0].type).to.be('text');
+      expect($.parseHTML(' <div/> ')[0].type).to.be('text');
     });
 
     it('(html) : should preserve content', function() {
       var html = '<div>test div</div>';
-      expect(cheerio(cheerio.parseHTML(html)[0]).html()).to.equal('test div');
+      expect(cheerio($.parseHTML(html)[0]).html()).to.equal('test div');
     });
 
     it('(malformedHtml) : should not break', function() {
-      expect(cheerio.parseHTML('<span><span>')).to.have.length(1);
+      expect($.parseHTML('<span><span>')).to.have.length(1);
     });
 
     it('(garbageInput) : should not cause an error', function() {
-      expect(cheerio.parseHTML('<#if><tr><p>This is a test.</p></tr><#/if>') || true).to.be.ok();
+      expect(
+        $.parseHTML('<#if><tr><p>This is a test.</p></tr><#/if>') || true
+      ).to.be.ok();
     });
 
     it('(text) : should return an array that is not effected by DOM manipulation methods', function() {
@@ -205,8 +225,24 @@ describe('cheerio', function() {
     });
   });
 
-  describe('.contains', function() {
+  /**
+   * The `.parseHTML` method exported by the Cheerio module is deprecated.
+   *
+   * In order to promote consistency with the jQuery library, users are
+   * encouraged to instead use the static method of the same name as it is
+   * defined on the "loaded" Cheerio factory function. For example:
+   *
+   *     var $ = cheerio.load('');
+   *     $.parseHTML('<b>markup</b>');
+   */
+  describe('.parseHTML - deprecated API', function() {
+    it('(html) : should preserve content', function() {
+      var html = '<div>test div</div>';
+      expect(cheerio(cheerio.parseHTML(html)[0]).html()).to.equal('test div');
+    });
+  });
 
+  describe('.contains', function() {
     var $;
 
     beforeEach(function() {
@@ -233,17 +269,15 @@ describe('cheerio', function() {
       expect($.contains($fruits[0], $fruits[0])).to.equal(false);
       expect($.contains($vegetables[0], $vegetables[0])).to.equal(false);
     });
-
   });
 
   describe('.root', function() {
-
     it('() : should return a cheerio-wrapped root object', function() {
-      var $html = cheerio.load('<div><span>foo</span><span>bar</span></div>');
-      $html.root().append('<div id="test"></div>');
-      expect($html.html()).to.equal('<div><span>foo</span><span>bar</span></div><div id="test"></div>');
+      var $ = cheerio.load('<html><head></head><body>foo</body></html>');
+      $.root().append('<div id="test"></div>');
+      expect($.html()).to.equal(
+        '<html><head></head><body>foo</body></html><div id="test"></div>'
+      );
     });
-
   });
-
 });
diff --git a/test/cheerio.js b/test/cheerio.js
index e477add9d3..a08d8281cf 100644
--- a/test/cheerio.js
+++ b/test/cheerio.js
@@ -1,6 +1,6 @@
 var expect = require('expect.js'),
     htmlparser2 = require('htmlparser2'),
-    $ = require('../'),
+    cheerio = require('../'),
     fixtures = require('./fixtures'),
     fruits = fixtures.fruits,
     food = fixtures.food,
@@ -13,44 +13,43 @@ var script = '<script src="script.js" type="text/javascript"></script>',
     multiclass = '<p><a class="btn primary" href="#">Save</a></p>';
 
 describe('cheerio', function() {
-
   it('should get the version', function() {
-    expect(/\d+\.\d+\.\d+/.test($.version)).to.be.ok();
+    expect(/\d+\.\d+\.\d+/.test(cheerio.version)).to.be.ok();
   });
 
-  it('$(null) should return be empty', function() {
-    expect($(null)).to.be.empty();
+  it('cheerio(null) should return be empty', function() {
+    expect(cheerio(null)).to.be.empty();
   });
 
-  it('$(undefined) should be empty', function() {
-    expect($(undefined)).to.be.empty();
+  it('cheerio(undefined) should be empty', function() {
+    expect(cheerio(undefined)).to.be.empty();
   });
 
-  it('$(null) should be empty', function() {
-    expect($('')).to.be.empty();
+  it('cheerio(null) should be empty', function() {
+    expect(cheerio('')).to.be.empty();
   });
 
-  it('$(selector) with no context or root should be empty', function() {
-    expect($('.h2')).to.be.empty();
-    expect($('#fruits')).to.be.empty();
+  it('cheerio(selector) with no context or root should be empty', function() {
+    expect(cheerio('.h2')).to.be.empty();
+    expect(cheerio('#fruits')).to.be.empty();
   });
 
-  it('$(node) : should override previously-loaded nodes', function() {
-    var C = $.load('<div><span></span></div>');
-    var spanNode = C('span')[0];
-    var $span = C(spanNode);
+  it('cheerio(node) : should override previously-loaded nodes', function() {
+    var $ = cheerio.load('<div><span></span></div>');
+    var spanNode = $('span')[0];
+    var $span = $(spanNode);
     expect($span[0]).to.equal(spanNode);
   });
 
   it('should be able to create html without a root or context', function() {
-    var $h2 = $('<h2>');
+    var $h2 = cheerio('<h2>');
     expect($h2).to.not.be.empty();
     expect($h2).to.have.length(1);
     expect($h2[0].tagName).to.equal('h2');
   });
 
   it('should be able to create complicated html', function() {
-    var $script = $(script);
+    var $script = cheerio(script);
     expect($script).to.not.be.empty();
     expect($script).to.have.length(1);
     expect($script[0].attribs.src).to.equal('script.js');
@@ -69,52 +68,52 @@ describe('cheerio', function() {
   };
 
   it('should be able to select .apple with only a context', function() {
-    var $apple = $('.apple', fruits);
+    var $apple = cheerio('.apple', fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select .apple with a node as context', function() {
-    var $apple = $('.apple', $(fruits)[0]);
+    var $apple = cheerio('.apple', cheerio(fruits)[0]);
     testAppleSelect($apple);
   });
 
   it('should be able to select .apple with only a root', function() {
-    var $apple = $('.apple', null, fruits);
+    var $apple = cheerio('.apple', null, fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select an id', function() {
-    var $fruits = $('#fruits', null, fruits);
+    var $fruits = cheerio('#fruits', null, fruits);
     expect($fruits).to.have.length(1);
     expect($fruits[0].attribs.id).to.equal('fruits');
   });
 
   it('should be able to select a tag', function() {
-    var $ul = $('ul', fruits);
+    var $ul = cheerio('ul', fruits);
     expect($ul).to.have.length(1);
     expect($ul[0].tagName).to.equal('ul');
   });
 
   it('should accept a node reference as a context', function() {
-    var $elems = $('<div><span></span></div>');
-    expect($('span', $elems[0])).to.have.length(1);
+    var $elems = cheerio('<div><span></span></div>');
+    expect(cheerio('span', $elems[0])).to.have.length(1);
   });
 
   it('should accept an array of node references as a context', function() {
-    var $elems = $('<div><span></span></div>');
-    expect($('span', $elems.toArray())).to.have.length(1);
+    var $elems = cheerio('<div><span></span></div>');
+    expect(cheerio('span', $elems.toArray())).to.have.length(1);
   });
 
   it('should select only elements inside given context (Issue #193)', function() {
-    var q = $.load(food),
-        $fruits = q('#fruits'),
-        fruitElements = q('li', $fruits);
+    var $ = cheerio.load(food),
+        $fruits = $('#fruits'),
+        fruitElements = $('li', $fruits);
 
     expect(fruitElements).to.have.length(3);
   });
 
   it('should be able to select multiple tags', function() {
-    var $fruits = $('li', null, fruits);
+    var $fruits = cheerio('li', null, fruits);
     expect($fruits).to.have.length(3);
     var classes = ['apple', 'orange', 'pear'];
     $fruits.each(function(idx, $fruit) {
@@ -122,34 +121,34 @@ describe('cheerio', function() {
     });
   });
 
-  it('should be able to do: $("#fruits .apple")', function() {
-    var $apple = $('#fruits .apple', fruits);
+  it('should be able to do: cheerio("#fruits .apple")', function() {
+    var $apple = cheerio('#fruits .apple', fruits);
     testAppleSelect($apple);
   });
 
-  it('should be able to do: $("li.apple")', function() {
-    var $apple = $('li.apple', fruits);
+  it('should be able to do: cheerio("li.apple")', function() {
+    var $apple = cheerio('li.apple', fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select by attributes', function() {
-    var $apple = $('li[class=apple]', fruits);
+    var $apple = cheerio('li[class=apple]', fruits);
     testAppleSelect($apple);
   });
 
-  it('should be able to select multiple classes: $(".btn.primary")', function() {
-    var $a = $('.btn.primary', multiclass);
+  it('should be able to select multiple classes: cheerio(".btn.primary")', function() {
+    var $a = cheerio('.btn.primary', multiclass);
     expect($a).to.have.length(1);
     expect($a[0].childNodes[0].data).to.equal('Save');
   });
 
   it('should not create a top-level node', function() {
-    var $elem = $('* div', '<div>');
+    var $elem = cheerio('* div', '<div>');
     expect($elem).to.have.length(0);
   });
 
-  it('should be able to select multiple elements: $(".apple, #fruits")', function() {
-    var $elems = $('.apple, #fruits', fruits);
+  it('should be able to select multiple elements: cheerio(".apple, #fruits")', function() {
+    var $elems = cheerio('.apple, #fruits', fruits);
     expect($elems).to.have.length(2);
 
     var $apple = _.filter($elems, function(elem) {
@@ -162,109 +161,109 @@ describe('cheerio', function() {
     expect($fruits[0].attribs.id).to.equal('fruits');
   });
 
-  it('should select first element $(:first)');
-    // var $elem = $(':first', fruits);
-    // var $h2 = $('<h2>fruits</h2>');
-    // console.log($elem.before('hi'));
-    // console.log($elem.before($h2));
+  it('should select first element cheerio(:first)');
+  // var $elem = cheerio(':first', fruits);
+  // var $h2 = cheerio('<h2>fruits</h2>');
+  // console.log($elem.before('hi'));
+  // console.log($elem.before($h2));
 
-  it('should be able to select immediate children: $("#fruits > .pear")', function() {
-    var $food = $(food);
-    $('.pear', $food).append('<li class="pear">Another Pear!</li>');
-    expect($('#fruits .pear', $food)).to.have.length(2);
-    var $elem = $('#fruits > .pear', $food);
+  it('should be able to select immediate children: cheerio("#fruits > .pear")', function() {
+    var $food = cheerio(food);
+    cheerio('.pear', $food).append('<li class="pear">Another Pear!</li>');
+    expect(cheerio('#fruits .pear', $food)).to.have.length(2);
+    var $elem = cheerio('#fruits > .pear', $food);
     expect($elem).to.have.length(1);
     expect($elem.attr('class')).to.equal('pear');
   });
 
-  it('should be able to select immediate children: $(".apple + .pear")', function() {
-    var $elem = $('.apple + li', fruits);
+  it('should be able to select immediate children: cheerio(".apple + .pear")', function() {
+    var $elem = cheerio('.apple + li', fruits);
     expect($elem).to.have.length(1);
-    $elem = $('.apple + .pear', fruits);
+    $elem = cheerio('.apple + .pear', fruits);
     expect($elem).to.have.length(0);
-    $elem = $('.apple + .orange', fruits);
+    $elem = cheerio('.apple + .orange', fruits);
     expect($elem).to.have.length(1);
     expect($elem.attr('class')).to.equal('orange');
   });
 
-  it('should be able to select immediate children: $(".apple ~ .pear")', function() {
-    var $elem = $('.apple ~ li', fruits);
+  it('should be able to select immediate children: cheerio(".apple ~ .pear")', function() {
+    var $elem = cheerio('.apple ~ li', fruits);
     expect($elem).to.have.length(2);
-    $elem = $('.apple ~ .pear', fruits);
+    $elem = cheerio('.apple ~ .pear', fruits);
     expect($elem.attr('class')).to.equal('pear');
   });
 
-  it('should handle wildcards on attributes: $("li[class*=r]")', function() {
-    var $elem = $('li[class*=r]', fruits);
+  it('should handle wildcards on attributes: cheerio("li[class*=r]")', function() {
+    var $elem = cheerio('li[class*=r]', fruits);
     expect($elem).to.have.length(2);
     expect($elem.eq(0).attr('class')).to.equal('orange');
     expect($elem.eq(1).attr('class')).to.equal('pear');
   });
 
-  it('should handle beginning of attr selectors: $("li[class^=o]")', function() {
-    var $elem = $('li[class^=o]', fruits);
+  it('should handle beginning of attr selectors: cheerio("li[class^=o]")', function() {
+    var $elem = cheerio('li[class^=o]', fruits);
     expect($elem).to.have.length(1);
     expect($elem.eq(0).attr('class')).to.equal('orange');
   });
 
-  it('should handle beginning of attr selectors: $("li[class$=e]")', function() {
-    var $elem = $('li[class$=e]', fruits);
+  it('should handle beginning of attr selectors: cheerio("li[class$=e]")', function() {
+    var $elem = cheerio('li[class$=e]', fruits);
     expect($elem).to.have.length(2);
     expect($elem.eq(0).attr('class')).to.equal('apple');
     expect($elem.eq(1).attr('class')).to.equal('orange');
   });
 
   it('should gracefully degrade on complex, unmatched queries', function() {
-    var $elem = $('Eastern States Cup #8-fin&nbsp;<br>Downhill&nbsp;');
+    var $elem = cheerio('Eastern States Cup #8-fin&nbsp;<br>Downhill&nbsp;');
     expect($elem).to.have.length(0); // []
   });
 
   it('(extended Array) should not interfere with prototype methods (issue #119)', function() {
     var extended = [];
     extended.find = extended.children = extended.each = function() {};
-    var $empty = $(extended);
+    var $empty = cheerio(extended);
 
-    expect($empty.find).to.be($.prototype.find);
-    expect($empty.children).to.be($.prototype.children);
-    expect($empty.each).to.be($.prototype.each);
+    expect($empty.find).to.be(cheerio.prototype.find);
+    expect($empty.children).to.be(cheerio.prototype.children);
+    expect($empty.each).to.be(cheerio.prototype.each);
   });
 
   it('should set html(number) as a string', function() {
-    var $elem = $('<div>');
+    var $elem = cheerio('<div>');
     $elem.html(123);
     expect(typeof $elem.text()).to.equal('string');
   });
 
   it('should set text(number) as a string', function() {
-    var $elem = $('<div>');
+    var $elem = cheerio('<div>');
     $elem.text(123);
     expect(typeof $elem.text()).to.equal('string');
   });
 
   describe('.merge', function() {
     var arr1, arr2;
-    beforeEach(function(){
-      arr1 = [1,2,3];
-      arr2 = [4,5,6];
+    beforeEach(function() {
+      arr1 = [1, 2, 3];
+      arr2 = [4, 5, 6];
     });
 
     it('should be a function', function() {
-      expect(typeof $.merge).to.equal('function');
+      expect(typeof cheerio.merge).to.equal('function');
     });
 
     it('(arraylike, arraylike) : should return an array', function() {
-      var ret = $.merge(arr1, arr2);
+      var ret = cheerio.merge(arr1, arr2);
       expect(typeof ret).to.equal('object');
       expect(ret instanceof Array).to.be.ok();
     });
 
     it('(arraylike, arraylike) : should modify the first array', function() {
-      $.merge(arr1, arr2);
+      cheerio.merge(arr1, arr2);
       expect(arr1).to.have.length(6);
     });
 
     it('(arraylike, arraylike) : should not modify the second array', function() {
-      $.merge(arr1, arr2);
+      cheerio.merge(arr1, arr2);
       expect(arr2).to.have.length(3);
     });
 
@@ -279,7 +278,7 @@ describe('cheerio', function() {
       arr2[0] = 'd';
       arr2[1] = 'e';
       arr2[2] = 'f';
-      $.merge(arr1, arr2);
+      cheerio.merge(arr1, arr2);
       expect(arr1).to.have.length(6);
       expect(arr1[3]).to.equal('d');
       expect(arr1[4]).to.equal('e');
@@ -288,100 +287,227 @@ describe('cheerio', function() {
     });
 
     it('(?, ?) : should gracefully reject invalid inputs', function() {
-      var ret = $.merge([4],3);
+      var ret = cheerio.merge([4], 3);
       expect(ret).to.not.be.ok();
-      ret = $.merge({},{});
+      ret = cheerio.merge({}, {});
       expect(ret).to.not.be.ok();
-      ret = $.merge([],{});
+      ret = cheerio.merge([], {});
       expect(ret).to.not.be.ok();
-      ret = $.merge({},[]);
+      ret = cheerio.merge({}, []);
       expect(ret).to.not.be.ok();
-      var fakeArray1 = {length: 3};
+      var fakeArray1 = { length: 3 };
       fakeArray1[0] = 'a';
       fakeArray1[1] = 'b';
       fakeArray1[3] = 'd';
-      ret = $.merge(fakeArray1,[]);
+      ret = cheerio.merge(fakeArray1, []);
       expect(ret).to.not.be.ok();
-      ret = $.merge([], fakeArray1);
+      ret = cheerio.merge([], fakeArray1);
       expect(ret).to.not.be.ok();
       fakeArray1 = {};
       fakeArray1.length = '7';
-      ret = $.merge(fakeArray1, []);
+      ret = cheerio.merge(fakeArray1, []);
       expect(ret).to.not.be.ok();
       fakeArray1.length = -1;
-      ret = $.merge(fakeArray1, []);
+      ret = cheerio.merge(fakeArray1, []);
       expect(ret).to.not.be.ok();
     });
 
     it('(?, ?) : should no-op on invalid inputs', function() {
-      var fakeArray1 = {length: 3};
+      var fakeArray1 = { length: 3 };
       fakeArray1[0] = 'a';
       fakeArray1[1] = 'b';
       fakeArray1[3] = 'd';
-      var ret = $.merge(fakeArray1, []);
+      cheerio.merge(fakeArray1, []);
       expect(fakeArray1).to.have.length(3);
-      expect(fakeArray1[0] = 'a');
-      expect(fakeArray1[1] = 'b');
-      expect(fakeArray1[3] = 'd');
-      ret = $.merge([], fakeArray1);
+      expect(fakeArray1[0]).to.equal('a');
+      expect(fakeArray1[1]).to.equal('b');
+      expect(fakeArray1[3]).to.equal('d');
+      cheerio.merge([], fakeArray1);
       expect(fakeArray1).to.have.length(3);
-      expect(fakeArray1[0] = 'a');
-      expect(fakeArray1[1] = 'b');
-      expect(fakeArray1[3] = 'd');
+      expect(fakeArray1[0]).to.equal('a');
+      expect(fakeArray1[1]).to.equal('b');
+      expect(fakeArray1[3]).to.equal('d');
     });
   });
 
-  describe('.load', function() {
+  /**
+   * The `.html` static method defined on the "loaded" Cheerio factory function
+   * is deprecated.
+   *
+   * In order to promote consistency with the jQuery library, users are
+   * encouraged to instead use the instance method of the same name. For
+   * example:
+   *
+   *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+   *     $('h1').text(); // '<h1>Hello, <span>world</span>.'
+   *
+   * To render the markup of an entire document, invoke the `html` function
+   * exported by the Cheerio module with a "root" selection, e.g.
+   *
+   *     cheerio.html($.root()); // '<html><head></head><body><h1>Hello, <span>world</span>.</h1></body></html>'
+   */
+  describe('.html - deprecated API', function() {
+    it('() : of empty cheerio object should return null', function() {
+      // Note: the direct invocation of the Cheerio constructor function is
+      // also deprecated.
+      var $ = cheerio();
+      expect($.html()).to.be(null);
+    });
+
+    it('(selector) : should return the outerHTML of the selected element', function() {
+      var $ = cheerio.load(fixtures.fruits);
+      expect($.html('.pear')).to.equal('<li class="pear">Pear</li>');
+    });
+  });
+
+  /**
+   * The `.xml` static method defined on the "loaded" Cheerio factory function
+   * is deprecated. Users are encouraged to instead use the `xml` function
+   * exported by the Cheerio module. For example:
+   *
+   *     cheerio.xml($.root());
+   */
+  describe('.xml  - deprecated API', function() {
+    it('() :  renders XML', function() {
+      var $ = cheerio.load('<foo></foo>', { xmlMode: true });
+      expect($.xml()).to.equal('<foo/>');
+    });
+  });
+
+  /**
+   * The `.text` static method defined on the "loaded" Cheerio factory function
+   * is deprecated.
+   *
+   * In order to promote consistency with the jQuery library, users are
+   * encouraged to instead use the instance method of the same name. For
+   * example:
+   *
+   *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+   *     $('h1').text(); // 'Hello, world.'
+   *
+   * To render the text content of an entire document, invoke the `text`
+   * function exported by the Cheerio module with a "root" selection, e.g.
+   *
+   *     cheerio.text($.root()); // 'Hello, world.'
+   */
+  describe('.text  - deprecated API', function() {
+    it('(cheerio object) : should return the text contents of the specified elements', function() {
+      var $ = cheerio.load('<a>This is <em>content</em>.</a>');
+      expect($.text($('a'))).to.equal('This is content.');
+    });
 
+    it('(cheerio object) : should omit comment nodes', function() {
+      var $ = cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
+      expect($.text($('a'))).to.equal('This is  not a comment.');
+    });
+
+    it('(cheerio object) : should include text contents of children recursively', function() {
+      var $ = cheerio.load(
+        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
+      );
+      expect($.text($('a'))).to.equal(
+        'This is a child with another child and  not a comment followed by one last child and some final text.'
+      );
+    });
+
+    it('() : should return the rendered text content of the root', function() {
+      var $ = cheerio.load(
+        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
+      );
+      expect($.text()).to.equal(
+        'This is a child with another child and  not a comment followed by one last child and some final text.'
+      );
+    });
+
+    it('(cheerio object) : should omit script tags', function() {
+      var $ = cheerio.load('<script>console.log("test")</script>');
+      expect($.text()).to.equal('');
+    });
+
+    it('(cheerio object) : should omit style tags', function() {
+      var $ = cheerio.load(
+        '<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>'
+      );
+      expect($.text()).to.equal('');
+    });
+
+    it('(cheerio object) : should include text contents of children omiting style and script tags', function() {
+      var $ = cheerio.load(
+        '<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>'
+      );
+      expect($.text()).to.equal(
+        'Welcome Hello, testing text function,End of messege'
+      );
+    });
+  });
+
+  describe('.load', function() {
     it('should generate selections as proper instances', function() {
-      var q = $.load(fruits);
+      var $ = cheerio.load(fruits);
 
-      expect(q('.apple')).to.be.a(q);
+      expect($('.apple')).to.be.a($);
     });
 
     it('should be able to filter down using the context', function() {
-      var q = $.load(fruits),
-          apple = q('.apple', 'ul'),
-          lis = q('li', 'ul');
+      var $ = cheerio.load(fruits),
+          apple = $('.apple', 'ul'),
+          lis = $('li', 'ul');
 
       expect(apple).to.have.length(1);
       expect(lis).to.have.length(3);
     });
 
+    /**
+     * The `.load` static method defined on the "loaded" Cheerio factory
+     * function is deprecated. Users are encouraged to instead use the `load`
+     * function exported by the Cheerio module. For example:
+     *
+     *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+     */
+    it('should be available as a static method on the "loaded" factory function (deprecated API)', function() {
+      var $1 = cheerio.load(fruits);
+      var $2 = $1.load('<div><p>Some <a>text</a>.</p></div>');
+
+      expect($2('a')).to.have.length(1);
+    });
+
     it('should allow loading a pre-parsed DOM', function() {
       var dom = htmlparser2.parseDOM(food),
-          q = $.load(dom);
+          $ = cheerio.load(dom);
 
-      expect(q('ul')).to.have.length(3);
+      expect($('ul')).to.have.length(3);
     });
 
-    it('should render xml in html() when options.xmlMode = true', function() {
+    it('should render xml in html() when options.xml = true', function() {
       var str = '<MixedCaseTag UPPERCASEATTRIBUTE=""></MixedCaseTag>',
           expected = '<MixedCaseTag UPPERCASEATTRIBUTE=""/>',
-          dom = $.load(str, {xmlMode: true});
+          $ = cheerio.load(str, { xml: true });
 
-      expect(dom('MixedCaseTag').get(0).tagName).to.equal('MixedCaseTag');
-      expect(dom.html()).to.be(expected);
+      expect($('MixedCaseTag').get(0).tagName).to.equal('MixedCaseTag');
+      expect($.html()).to.be(expected);
     });
 
-    it('should render xml in html() when options.xmlMode = true passed to html()', function() {
+    it('should render xml in html() when options.xml = true passed to html()', function() {
       var str = '<MixedCaseTag UPPERCASEATTRIBUTE=""></MixedCaseTag>',
-          // since parsing done without xmlMode flag, all tags converted to lowercase
-          expectedXml = '<mixedcasetag uppercaseattribute=""/>',
-          expectedNoXml = '<mixedcasetag uppercaseattribute=""></mixedcasetag>',
-          dom = $.load(str);
-
-      expect(dom('MixedCaseTag').get(0).tagName).to.equal('mixedcasetag');
-      expect(dom.html()).to.be(expectedNoXml);
-      expect(dom.html({xmlMode: true})).to.be(expectedXml);
+          // since parsing done without xml flag, all tags converted to lowercase
+          expectedXml =
+          '<html><head/><body><mixedcasetag uppercaseattribute=""/></body></html>',
+          expectedNoXml =
+          '<html><head></head><body><mixedcasetag uppercaseattribute=""></mixedcasetag></body></html>',
+          $ = cheerio.load(str);
+
+      expect($('MixedCaseTag').get(0).tagName).to.equal('mixedcasetag');
+      expect($.html()).to.be(expectedNoXml);
+      expect($.html({ xml: true })).to.be(expectedXml);
     });
 
     it('should respect options on the element level', function() {
-      var str = '<!doctype html><html><head><title>Some test</title></head><body><footer><p>Copyright &copy; 2003-2014</p></footer></body></html>',
+      var str =
+          '<!doctype html><html><head><title>Some test</title></head><body><footer><p>Copyright &copy; 2003-2014</p></footer></body></html>',
           expectedHtml = '<p>Copyright &copy; 2003-2014</p>',
-          expectedXml = '<p>Copyright &#xA9; 2003-2014</p>',
-          domNotEncoded = $.load(str, {decodeEntities: false}),
-          domEncoded = $.load(str);
+          expectedXml = '<p>Copyright © 2003-2014</p>',
+          domNotEncoded = cheerio.load(str, { xml: { decodeEntities: false } }),
+          domEncoded = cheerio.load(str);
 
       expect(domNotEncoded('footer').html()).to.be(expectedHtml);
       // TODO: Make it more html friendly, maybe with custom encode tables
@@ -389,51 +515,57 @@ describe('cheerio', function() {
     });
 
     it('should return a fully-qualified Function', function() {
-      var $c = $.load('<div>');
+      var $ = cheerio.load('<div>');
 
-      expect($c).to.be.a(Function);
+      expect($).to.be.a(Function);
     });
 
     describe('prototype extensions', function() {
       it('should honor extensions defined on `prototype` property', function() {
-        var $c = $.load('<div>');
+        var $ = cheerio.load('<div>');
         var $div;
-        $c.prototype.myPlugin = function() {
+        $.prototype.myPlugin = function() {
           return {
             context: this,
             args: arguments
           };
         };
 
-        $div = $c('div');
+        $div = $('div');
 
         expect($div.myPlugin).to.be.a('function');
         expect($div.myPlugin().context).to.be($div);
-        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args))
-          .to.eql([1, 2, 3]);
+        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args)).to.eql([
+          1,
+          2,
+          3
+        ]);
       });
 
       it('should honor extensions defined on `fn` property', function() {
-        var $c = $.load('<div>');
+        var $ = cheerio.load('<div>');
         var $div;
-        $c.fn.myPlugin = function() {
+        $.fn.myPlugin = function() {
           return {
             context: this,
             args: arguments
           };
         };
 
-        $div = $c('div');
+        $div = $('div');
 
         expect($div.myPlugin).to.be.a('function');
         expect($div.myPlugin().context).to.be($div);
-        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args))
-          .to.eql([1, 2, 3]);
+        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args)).to.eql([
+          1,
+          2,
+          3
+        ]);
       });
 
       it('should isolate extensions between loaded functions', function() {
-        var $a = $.load('<div>');
-        var $b = $.load('<div>');
+        var $a = cheerio.load('<div>');
+        var $b = cheerio.load('<div>');
 
         $a.prototype.foo = function() {};
 
diff --git a/test/fixtures.js b/test/fixtures.js
index 0c1a009451..2952796500 100644
--- a/test/fixtures.js
+++ b/test/fixtures.js
@@ -1,41 +1,41 @@
 /* jshint indent: false */
 exports.fruits = [
   '<ul id="fruits">',
-    '<li class="apple">Apple</li>',
-    '<li class="orange">Orange</li>',
-    '<li class="pear">Pear</li>',
+  '<li class="apple">Apple</li>',
+  '<li class="orange">Orange</li>',
+  '<li class="pear">Pear</li>',
   '</ul>'
 ].join('');
 
 exports.vegetables = [
   '<ul id="vegetables">',
-    '<li class="carrot">Carrot</li>',
-    '<li class="sweetcorn">Sweetcorn</li>',
+  '<li class="carrot">Carrot</li>',
+  '<li class="sweetcorn">Sweetcorn</li>',
   '</ul>'
 ].join('');
 
 exports.chocolates = [
   '<ul id="chocolates">',
-    '<li class="linth" data-highlight="Lindor" data-origin="swiss">Linth</li>',
-    '<li class="frey" data-taste="sweet" data-best-collection="Mahony">Frey</li>',
-    '<li class="cailler">Cailler</li>',
+  '<li class="linth" data-highlight="Lindor" data-origin="swiss">Linth</li>',
+  '<li class="frey" data-taste="sweet" data-best-collection="Mahony">Frey</li>',
+  '<li class="cailler">Cailler</li>',
   '</ul>'
 ].join('');
 
 exports.drinks = [
   '<ul id="drinks">',
-    '<li class="beer">Beer</li>',
-    '<li class="juice">Juice</li>',
-    '<li class="milk">Milk</li>',
-    '<li class="water">Water</li>',
-    '<li class="cider">Cider</li>',
+  '<li class="beer">Beer</li>',
+  '<li class="juice">Juice</li>',
+  '<li class="milk">Milk</li>',
+  '<li class="water">Water</li>',
+  '<li class="cider">Cider</li>',
   '</ul>'
 ].join('');
 
 exports.food = [
   '<ul id="food">',
-    exports.fruits,
-    exports.vegetables,
+  exports.fruits,
+  exports.vegetables,
   '</ul>'
 ].join('');
 
diff --git a/test/parse.js b/test/parse.js
index d22bad38f6..90b11bf3fb 100644
--- a/test/parse.js
+++ b/test/parse.js
@@ -1,7 +1,6 @@
 var expect = require('expect.js'),
     parse = require('../lib/parse'),
-    defaultOpts = require('..').prototype.options;
-
+    defaultOpts = require('../lib/options').default;
 
 // Tags
 var basic = '<html></html>';
@@ -21,7 +20,8 @@ var noValueAttribute = '<textarea disabled></textarea>';
 
 // Comments
 var comment = '<!-- sexy -->';
-var conditional = '<!--[if IE 8]><html class="no-js ie8" lang="en"><![endif]-->';
+var conditional =
+  '<!--[if IE 8]><html class="no-js ie8" lang="en"><![endif]-->';
 
 // Text
 var text = 'lorem ipsum';
@@ -37,20 +37,17 @@ var styleEmpty = '<style></style>';
 // Directives
 var directive = '<!doctype html>';
 
-
 describe('parse', function() {
-
   describe('.eval', function() {
-
     it('should parse basic empty tags: ' + basic, function() {
-      var tag = parse.evaluate(basic, defaultOpts)[0];
+      var tag = parse.evaluate(basic, defaultOpts, true)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('html');
-      expect(tag.childNodes).to.be.empty();
+      expect(tag.childNodes).to.have.length(2);
     });
 
     it('should handle sibling tags: ' + siblings, function() {
-      var dom = parse.evaluate(siblings, defaultOpts),
+      var dom = parse.evaluate(siblings, defaultOpts, false),
           h2 = dom[0],
           p = dom[1];
 
@@ -60,66 +57,70 @@ describe('parse', function() {
     });
 
     it('should handle single tags: ' + single, function() {
-      var tag = parse.evaluate(single, defaultOpts)[0];
+      var tag = parse.evaluate(single, defaultOpts, false)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('br');
       expect(tag.childNodes).to.be.empty();
     });
 
     it('should handle malformatted single tags: ' + singleWrong, function() {
-      var tag = parse.evaluate(singleWrong, defaultOpts)[0];
+      var tag = parse.evaluate(singleWrong, defaultOpts, false)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('br');
       expect(tag.childNodes).to.be.empty();
     });
 
     it('should handle tags with children: ' + children, function() {
-      var tag = parse.evaluate(children, defaultOpts)[0];
+      var tag = parse.evaluate(children, defaultOpts, true)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('html');
       expect(tag.childNodes).to.be.ok();
-      expect(tag.childNodes).to.have.length(1);
+      expect(tag.childNodes[1].tagName).to.equal('body');
+      expect(tag.childNodes[1].childNodes).to.have.length(1);
     });
 
     it('should handle tags with children: ' + li, function() {
-      var tag = parse.evaluate(li, defaultOpts)[0];
+      var tag = parse.evaluate(li, defaultOpts, false)[0];
       expect(tag.childNodes).to.have.length(1);
       expect(tag.childNodes[0].data).to.equal('Durian');
     });
 
     it('should handle tags with attributes: ' + attributes, function() {
-      var attrs = parse.evaluate(attributes, defaultOpts)[0].attribs;
+      var attrs = parse.evaluate(attributes, defaultOpts, false)[0].attribs;
       expect(attrs).to.be.ok();
       expect(attrs.src).to.equal('hello.png');
       expect(attrs.alt).to.equal('man waving');
     });
 
     it('should handle value-less attributes: ' + noValueAttribute, function() {
-      var attrs = parse.evaluate(noValueAttribute, defaultOpts)[0].attribs;
+      var attrs = parse.evaluate(noValueAttribute, defaultOpts, false)[0]
+        .attribs;
       expect(attrs).to.be.ok();
       expect(attrs.disabled).to.equal('');
     });
 
     it('should handle comments: ' + comment, function() {
-      var elem = parse.evaluate(comment, defaultOpts)[0];
+      var elem = parse.evaluate(comment, defaultOpts, false)[0];
       expect(elem.type).to.equal('comment');
       expect(elem.data).to.equal(' sexy ');
     });
 
     it('should handle conditional comments: ' + conditional, function() {
-      var elem = parse.evaluate(conditional, defaultOpts)[0];
+      var elem = parse.evaluate(conditional, defaultOpts, false)[0];
       expect(elem.type).to.equal('comment');
-      expect(elem.data).to.equal(conditional.replace('<!--', '').replace('-->', ''));
+      expect(elem.data).to.equal(
+        conditional.replace('<!--', '').replace('-->', '')
+      );
     });
 
     it('should handle text: ' + text, function() {
-      var text_ = parse.evaluate(text, defaultOpts)[0];
+      var text_ = parse.evaluate(text, defaultOpts, false)[0];
       expect(text_.type).to.equal('text');
       expect(text_.data).to.equal('lorem ipsum');
     });
 
     it('should handle script tags: ' + script, function() {
-      var script_ = parse.evaluate(script, defaultOpts)[0];
+      var script_ = parse.evaluate(script, defaultOpts, false)[0];
       expect(script_.type).to.equal('script');
       expect(script_.tagName).to.equal('script');
       expect(script_.attribs.type).to.equal('text/javascript');
@@ -129,7 +130,7 @@ describe('parse', function() {
     });
 
     it('should handle style tags: ' + style, function() {
-      var style_ = parse.evaluate(style, defaultOpts)[0];
+      var style_ = parse.evaluate(style, defaultOpts, false)[0];
       expect(style_.type).to.equal('style');
       expect(style_.tagName).to.equal('style');
       expect(style_.attribs.type).to.equal('text/css');
@@ -139,16 +140,14 @@ describe('parse', function() {
     });
 
     it('should handle directives: ' + directive, function() {
-      var elem = parse.evaluate(directive, defaultOpts)[0];
+      var elem = parse.evaluate(directive, defaultOpts, true)[0];
       expect(elem.type).to.equal('directive');
-      expect(elem.data).to.equal('!doctype html');
+      expect(elem.data).to.equal('!DOCTYPE html');
       expect(elem.tagName).to.equal('!doctype');
     });
-
   });
 
   describe('.parse', function() {
-
     // root test utility
     function rootTest(root) {
       expect(root.tagName).to.equal('root');
@@ -163,14 +162,14 @@ describe('parse', function() {
     }
 
     it('should add root to: ' + basic, function() {
-      var root = parse(basic, defaultOpts);
+      var root = parse(basic, defaultOpts, true);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].tagName).to.equal('html');
     });
 
     it('should add root to: ' + siblings, function() {
-      var root = parse(siblings, defaultOpts);
+      var root = parse(siblings, defaultOpts, false);
       rootTest(root);
       expect(root.childNodes).to.have.length(2);
       expect(root.childNodes[0].tagName).to.equal('h2');
@@ -179,42 +178,46 @@ describe('parse', function() {
     });
 
     it('should add root to: ' + comment, function() {
-      var root = parse(comment, defaultOpts);
+      var root = parse(comment, defaultOpts, false);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('comment');
     });
 
     it('should add root to: ' + text, function() {
-      var root = parse(text, defaultOpts);
+      var root = parse(text, defaultOpts, false);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('text');
     });
 
     it('should add root to: ' + scriptEmpty, function() {
-      var root = parse(scriptEmpty, defaultOpts);
+      var root = parse(scriptEmpty, defaultOpts, false);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('script');
     });
 
     it('should add root to: ' + styleEmpty, function() {
-      var root = parse(styleEmpty, defaultOpts);
+      var root = parse(styleEmpty, defaultOpts, false);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('style');
     });
 
     it('should add root to: ' + directive, function() {
-      var root = parse(directive, defaultOpts);
+      var root = parse(directive, defaultOpts, true);
       rootTest(root);
-      expect(root.childNodes).to.have.length(1);
+      expect(root.childNodes).to.have.length(2);
       expect(root.childNodes[0].type).to.equal('directive');
     });
 
     it('should expose the DOM level 1 API', function() {
-      var root = parse('<div><a></a><span></span><p></p></div>', defaultOpts).childNodes[0];
+      var root = parse(
+        '<div><a></a><span></span><p></p></div>',
+        defaultOpts,
+        false
+      ).childNodes[0];
       var childNodes = root.childNodes;
 
       expect(childNodes).to.have.length(3);
@@ -247,6 +250,130 @@ describe('parse', function() {
       expect(childNodes[2].firstChild).to.be(null);
       expect(childNodes[2].lastChild).to.be(null);
     });
-  });
 
+    it('Should parse less than or equal sign sign', function() {
+      var root = parse('<i>A</i><=<i>B</i>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].tagName).to.be('i');
+      expect(childNodes[0].childNodes[0].data).to.be('A');
+      expect(childNodes[1].data).to.be('<=');
+      expect(childNodes[2].tagName).to.be('i');
+      expect(childNodes[2].childNodes[0].data).to.be('B');
+    });
+
+    it('Should ignore unclosed CDATA', function() {
+      var root = parse(
+        '<a></a><script>foo //<![CDATA[ bar</script><b></b>',
+        defaultOpts,
+        false
+      );
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].tagName).to.be('a');
+      expect(childNodes[1].tagName).to.be('script');
+      expect(childNodes[1].childNodes[0].data).to.be('foo //<![CDATA[ bar');
+      expect(childNodes[2].tagName).to.be('b');
+    });
+
+    it('Should add <head> to documents', function() {
+      var root = parse('<html></html>', defaultOpts, true);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].tagName).to.be('html');
+      expect(childNodes[0].childNodes[0].tagName).to.be('head');
+    });
+
+    it('Should implicitly create <tr> around <td>', function() {
+      var root = parse('<table><td>bar</td></tr></table>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].tagName).to.be('table');
+      expect(childNodes[0].childNodes.length).to.be(1);
+      expect(childNodes[0].childNodes[0].tagName).to.be('tbody');
+      expect(childNodes[0].childNodes[0].childNodes[0].tagName).to.be('tr');
+      expect(
+        childNodes[0].childNodes[0].childNodes[0].childNodes[0].tagName
+      ).to.be('td');
+      expect(
+        childNodes[0].childNodes[0].childNodes[0].childNodes[0].childNodes[0]
+          .data
+      ).to.be('bar');
+    });
+
+    it('Should parse custom tag <line>', function() {
+      var root = parse('<line>test</line>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes.length).to.be(1);
+      expect(childNodes[0].tagName).to.be('line');
+      expect(childNodes[0].childNodes[0].data).to.be('test');
+    });
+
+    it('Should properly parse misnested table tags', function() {
+      var root = parse(
+        '<tr><td>i1</td></tr><tr><td>i2</td></td></tr><tr><td>i3</td></td></tr>',
+        defaultOpts,
+        false
+      );
+      var childNodes = root.childNodes;
+
+      expect(childNodes.length).to.be(3);
+
+      childNodes.forEach(function(child, i) {
+        expect(child.tagName).to.be('tr');
+        expect(child.childNodes[0].tagName).to.be('td');
+        expect(child.childNodes[0].childNodes[0].data).to.be('i' + (i + 1));
+      });
+    });
+
+    it('Should correctly parse data url attributes', function() {
+      var html =
+        '<div style=\'font-family:"butcherman-caps"; src:url(data:font/opentype;base64,AAEA...);\'></div>';
+      var expectedAttr =
+        'font-family:"butcherman-caps"; src:url(data:font/opentype;base64,AAEA...);';
+      var root = parse(html, defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].attribs.style).to.be(expectedAttr);
+    });
+
+    it('Should treat <xmp> tag content as text', function() {
+      var root = parse('<xmp><h2></xmp>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].childNodes[0].data).to.be('<h2>');
+    });
+
+    it('Should correctly parse malformed numbered entities', function() {
+      var root = parse('<p>z&#</p>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes[0].childNodes[0].data).to.be('z&#');
+    });
+
+    it('Should correctly parse mismatched headings', function() {
+      var root = parse('<h2>Test</h3><div></div>', defaultOpts, false);
+      var childNodes = root.childNodes;
+
+      expect(childNodes.length).to.be(2);
+      expect(childNodes[0].tagName).to.be('h2');
+      expect(childNodes[1].tagName).to.be('div');
+    });
+
+    it('Should correctly parse tricky <pre> content', function() {
+      var root = parse(
+        '<pre>\nA <- factor(A, levels = c("c","a","b"))\n</pre>',
+        defaultOpts,
+        false
+      );
+      var childNodes = root.childNodes;
+
+      expect(childNodes.length).to.be(1);
+      expect(childNodes[0].tagName).to.be('pre');
+      expect(childNodes[0].childNodes[0].data).to.be(
+        'A <- factor(A, levels = c("c","a","b"))\n'
+      );
+    });
+  });
 });
diff --git a/test/xml.js b/test/xml.js
index cc23133532..d24e3feb77 100644
--- a/test/xml.js
+++ b/test/xml.js
@@ -5,9 +5,9 @@ var expect = require('expect.js'),
     };
 
 var xml = function(str, options) {
-  options = _.extend({ xmlMode: true }, options);
-  var dom = cheerio.load(str, options);
-  return dom.xml();
+  options = _.extend({ xml: true }, options);
+  var $ = cheerio.load(str, options);
+  return $.xml();
 };
 
 var dom = function(str, options) {
@@ -16,12 +16,13 @@ var dom = function(str, options) {
 };
 
 describe('render', function() {
-
   describe('(xml)', function() {
-
     it('should render <media:thumbnail /> tags correctly', function() {
-      var str = '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />';
-      expect(xml(str)).to.equal('<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>');
+      var str =
+        '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />';
+      expect(xml(str)).to.equal(
+        '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>'
+      );
     });
 
     it('should render <link /> tags (RSS) correctly', function() {
@@ -29,32 +30,34 @@ describe('render', function() {
       expect(xml(str)).to.equal('<link>http://www.github.com/</link>');
     });
 
-    it('should escape entities', function(){
+    it('should escape entities', function() {
       var str = '<tag attr="foo &amp; bar"/>';
       expect(xml(str)).to.equal(str);
     });
-
   });
 
-  describe('(dom)', function () {
-
+  describe('(dom)', function() {
     it('should keep camelCase for new nodes', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      expect(dom(str, {xmlMode: false})).to.equal('<someelem someattribute="something">hello</someelem>');
+      expect(dom(str, { xml: false })).to.equal(
+        '<someelem someattribute="something">hello</someelem>'
+      );
     });
 
     it('should keep camelCase for new nodes', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      expect(dom(str, {xmlMode: true})).to.equal('<someElem someAttribute="something">hello</someElem>');
+      expect(dom(str, { xml: true })).to.equal(
+        '<someElem someAttribute="something">hello</someElem>'
+      );
     });
 
     it('should maintain the parsing options of distinct contexts independently', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      var $x = cheerio.load('', { xmlMode: false });
+      var $ = cheerio.load('', { xml: false });
 
-      expect($x(str).html()).to.equal('<someelem someattribute="something">hello</someelem>');
+      expect($(str).html()).to.equal(
+        '<someelem someattribute="something">hello</someelem>'
+      );
     });
-
   });
-
 });

From df695a4e6cb21f405dfb13bf12c461ff3ee571e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <me@feedic.com>
Date: Wed, 3 Oct 2018 18:04:08 +0100
Subject: [PATCH 09/16] Update Readme.md

Document the current state of master
---
 Readme.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Readme.md b/Readme.md
index c351d8612d..3171f0f6dd 100644
--- a/Readme.md
+++ b/Readme.md
@@ -33,6 +33,10 @@ $.html()
 //=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>
 ```
 
+## Note
+
+We are currently working on the 1.0.0 release of cheerio on the `master` branch. The source code for the last published version, `0.22.0`, can be found [here](https://github.com/cheeriojs/cheerio/tree/aa90399c9c02f12432bfff97b8f1c7d8ece7c307).
+
 ## Installation
 `npm install cheerio`
 

From e2f8436170e56190beb0dbbd284065624ca4d329 Mon Sep 17 00:00:00 2001
From: jugglinmike <mike@mikepennisi.com>
Date: Mon, 8 Oct 2018 15:13:46 -0400
Subject: [PATCH 10/16] Revert "v1.0.0 (#1145)" (#1231)

This reverts commit ca6963c09a38eaf67fbe551634fdbbc6984d3da8.

The `v1.0.0` branch was a long-running feature branch containing a large
amount of disparate commits from many authors. It was squashed into a
single commit prior to being merged to the project's `master` branch.

For the purposes of attribution, reference, and history analysis, the
composite commits should be preserved, and the branch should be
incorporated into `master` via a dedicated merge commit.
---
 .eslintrc.json              |  31 --
 .gitignore                  |   1 -
 .jshintrc                   |  11 +
 .travis.yml                 |   6 +-
 CONTRIBUTING.md             |  56 ++-
 History.md                  |  95 ----
 Makefile                    |  17 +-
 Readme.md                   | 850 +++++++++++++++++++++++++++++++--
 benchmark/.eslintrc.json    |   5 -
 benchmark/benchmark.js      |  26 +-
 benchmark/suite.js          |  14 +-
 jsdoc-config.json           |  11 -
 lib/api/attributes.js       | 307 +++---------
 lib/api/css.js              |  89 ++--
 lib/api/forms.js            |  58 +--
 lib/api/manipulation.js     | 463 +++---------------
 lib/api/traversing.js       | 678 ++++-----------------------
 lib/cheerio.js              |  82 ++--
 lib/options.js              |  18 -
 lib/parse.js                |  36 +-
 lib/static.js               | 148 ++----
 lib/utils.js                |  90 ++--
 package.json                |  50 +-
 scripts/generate_history.sh |  30 --
 scripts/prepublish          |  26 +-
 test/.eslintrc.json         |   5 -
 test/.jshintrc              |   9 +
 test/api/attributes.js      | 160 +++----
 test/api/css.js             |  25 +-
 test/api/forms.js           |  59 +--
 test/api/manipulation.js    | 904 ++++++++----------------------------
 test/api/traversing.js      | 281 +++++------
 test/api/utils.js           | 172 +++----
 test/cheerio.js             | 404 ++++++----------
 test/fixtures.js            |  30 +-
 test/parse.js               | 199 ++------
 test/xml.js                 |  37 +-
 37 files changed, 2059 insertions(+), 3424 deletions(-)
 delete mode 100644 .eslintrc.json
 create mode 100644 .jshintrc
 delete mode 100644 benchmark/.eslintrc.json
 delete mode 100644 jsdoc-config.json
 delete mode 100644 lib/options.js
 delete mode 100755 scripts/generate_history.sh
 delete mode 100644 test/.eslintrc.json
 create mode 100644 test/.jshintrc

diff --git a/.eslintrc.json b/.eslintrc.json
deleted file mode 100644
index 0db30f8ce8..0000000000
--- a/.eslintrc.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "env": {
-    "node": true
-  },
-  "plugins": ["jsdoc"],
-  "extends": ["eslint:recommended", "prettier"],
-  "globals": {},
-  "rules": {
-    "indent": [
-      2,
-      2,
-      {
-        "SwitchCase": 1,
-        "VariableDeclarator": 2
-      }
-    ],
-    "no-eq-null": 0,
-    "no-proto": 2,
-
-    "jsdoc/check-param-names": 2,
-    "jsdoc/check-tag-names": 2,
-    "jsdoc/check-types": 2,
-    "jsdoc/newline-after-description": 2,
-    "jsdoc/require-description-complete-sentence": 2,
-    "jsdoc/require-hyphen-before-param-description": 2,
-    "jsdoc/require-param": 2,
-    "jsdoc/require-param-description": 2,
-    "jsdoc/require-param-name": 2,
-    "jsdoc/require-param-type": 2
-  }
-}
diff --git a/.gitignore b/.gitignore
index 46b866b577..2ae05e1c97 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,3 @@ lib-cov
 cover_html
 .c9revisions
 coverage
-/docs/
diff --git a/.jshintrc b/.jshintrc
new file mode 100644
index 0000000000..28a0ff23f0
--- /dev/null
+++ b/.jshintrc
@@ -0,0 +1,11 @@
+{
+  "indent": 2,
+  "eqnull": true,
+  "laxbreak": true,
+  "proto": true,
+  "undef": true,
+  "unused": true,
+  "node": true,
+  "quotmark": "single",
+  "shadow": "outer"
+}
diff --git a/.travis.yml b/.travis.yml
index 8db0083269..b7d7df23f8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,15 @@
 language: node_js
 node_js:
   - "stable"
-  - "8"
+  - "unstable"
   - "6"
+  - "4"
+  - "0.12"
 script: make travis-test
 matrix:
   fast_finish: true
+  allow_failures:
+    - node_js: unstable
   include:
     - env: BENCHMARK=true
       script: "node benchmark/benchmark.js --regex '^(?!.*highmem)'"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 24f458fdee..cc38bb8dd7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -3,16 +3,16 @@
 Thanks for your interest in contributing to the project! Here's a rundown of
 how we'd like to work with you:
 
-1.  File an issue on GitHub describing the contribution you'd like to make. This
-    will help us to get you started on the right foot.
-2.  Create a single commit that addresses the issue:
-    1.  Follow the project's code style (see below)
-    2.  Add enough unit tests to "prove" that your patch is correct
-    3.  Update the project documentation as needed (see below)
-    4.  Describe your approach with as much detail as necessary in the git
-        commit message
-3.  Open a pull request, and reference the initial issue in the pull request
-    message.
+1. File an issue on GitHub describing the contribution you'd like to make. This
+   will help us to get you started on the right foot.
+2. Create a single commit that addresses the issue:
+    1. Follow the project's code style (see below)
+    2. Add enough unit tests to "prove" that your patch is correct
+    3. Update the project documentation as needed (see below)
+    4. Describe your approach with as much detail as necessary in the git
+       commit message
+3. Open a pull request, and reference the initial issue in the pull request
+   message.
 
 # Documentation
 
@@ -22,16 +22,26 @@ care to note aspects that make Cheerio distinct.
 
 # Code Style
 
-Please make sure commit hooks are run, which will enforce the code style.
-
-When implementing private functionality that isn't part of the jQuery API, please opt for:
-
-* _Static methods_: If the functionality does not require a reference to a
-  Cheerio instance, simply define a named function within the module it is
-  needed.
-* _Instance methods_: If the functionality requires a reference to a Cheerio
-  instance, informally define the method as "private" using the following
-  conventions:
-  * Define the method as a function on the Cheerio prototype
-  * Prefix the method name with an underscore (`_`) character
-  * Include `@api private` in the code comment the documents the method
+This section is by no means complete. For undocumented stylistic choices,
+please try to maintain consistency with the code base.
+
+- Single quotes: `'`
+- Whitespace
+  - Two-space "soft" tabs
+  - Once space following control flow statements (`if (condition) {` rather
+    than `if(condition) {`)
+  - Remove trailing spaces
+  - [End each file with a newline
+    character.](https://github.com/editorconfig/editorconfig/wiki/Newline-at-End-of-File-Support)
+- Terminate every statement with a semicolon
+- Private functionality (for re-using functionality that isn't part of the
+  jQuery API)
+  - *Static methods*: If the functionality does not require a reference to a
+    Cheerio instance, simply define a named function within the module it is
+    needed.
+  - *Instance methods*: If the functionality requires a reference to a Cheerio
+    instance, informally define the method as "private" using the following
+    conventions:
+    - Define the method as a function on the Cheerio prototype
+    - Prefix the method name with an underscore (`_`) character
+    - Include `@api private` in the code comment the documents the method
diff --git a/History.md b/History.md
index 462ae0cf28..c7e38e66a7 100644
--- a/History.md
+++ b/History.md
@@ -1,98 +1,3 @@
-1.0.0-rc.2 / 2017-07-02
-==================
-
-This release changes Cheerio's default parser to [the Parse5 HTML
-parser](https://github.com/inikulin/parse5). Parse5 is an excellent project
-that rigorously conforms to the HTML standard. It does not support XML, so
-Cheerio continues to use [`htmlparser2`](https://github.com/fb55/htmlparser2/)
-when working with XML documents.
-
-This switch addresses many long-standing bugs in Cheerio, but some users may
-experience slower behavior in performance-critical applications. In addition,
-`htmlparser2` is more forgiving of invalid markup which can be useful when
-input sourced from a third party and cannot be corrected. For these reasons,
-the `load` method also accepts a DOM structure as produced by the `htmlparser2`
-library. See the project's "readme" file for more details on this usage
-pattern.
-
-### Migrating from version 0.x
-
-`cheerio.load( html[, options ] )` This method continues to act as a "factory"
-function. It produces functions that define an API that is similar to the
-global `jQuery` function provided by the jQuery library. The generated function
-operates on a DOM structure based on the provided HTML.
-
-In releases prior to version 1.0, the provided HTML was interpreted as a
-document fragment. Following version 1.0, strings provided to the `load` method
-are interpreted as documents. The same example will produce a `$` function that
-operates on a full HTML document, including an `<html>` document element with
-nested `<head>` and `<body>` tags. This mimics web browser behavior much more
-closely, but may require alterations to existing code.
-
-For example, the following code will produce different results between 0.x and
-1.0 releases:
-
-    var $ = cheerio.load('<p>Hello, <b>world</b>!</p>');
-
-    $.root().html();
-
-    //=> In version 0.x: '<p>Hello, <b>world</b>!</p>'
-    //=> In version 1.0: '<html><head></head><body><p>Hello, <b>world</b>!</p></body></html>'
-
-Users wishing to parse, manipulate, and render full documents should not need
-to modify their code. Likewise, code that does not interact with the "root"
-element should not be effected by this change. (In the above example, the
-expression `$('p')` returns the same result across Cheerio versions--a Cheerio
-collection whose only member is a paragraph element.)
-
-However, users wishing to render document fragments should now explicitly
-create a "wrapper" element to contain their input.
-
-    // First, create a Cheerio function "bound" to an empty document (this is
-    // similar to loading an empty page in a web browser)
-    var $ = cheerio.load('');
-    // Next, create a "wrapper" element for the input fragment:
-    var $wrapper = $('<div/>');
-    // Finally, supply the input markup as the content for the wrapper:
-    $wrapper.append('<p>Hello, <b>world</b>!</p>');
-
-    $wrapper.html();
-    //=> '<p>Hello, <b>world</b>!</p>'
-
----
-
-Change log:
-
- * Update History.md (and include migration guide) (Mike Pennisi)
- * Rename `useHtmlParser2` option (Mike Pennisi)
- * Remove documentation for `xmlMode` option (Mike Pennisi)
- * Document advanced usage with htmlparser2 (Mike Pennisi)
- * Correct errors in Readme.md (Mike Pennisi)
- * Improve release process (Mike Pennisi)
- * 1.0.0-rc.1 (Mike Pennisi)
- * Update unit test (Mike Pennisi)
- * Normalize code style (Mike Pennisi)
- * Added support for nested wrapping. (Diane Looney)
- * Add nested wrapping test (Toni Helenius)
- * Added $.merge following the specification at https://api.jquery.com/jquery.merge/ Added test cases for $.merge (Diane Looney)
- * Clarify project scope in README file (Mike Pennisi)
- * .text() ignores script and style tags (#1018) (Haleem Assal)
- * Test suite housekeeping (#1016) (DianeLooney)
- * experiment with a job board (Matthew)
- * Change options format (inikulin)
- * Add test for #997 (inikulin)
- * Update .filter function docs. (Konstantin)
- * Standardise readme on ES6 variable declarations (Dekatron)
- * Use documents via $.load (inikulin)
- * Use parse5 as a default parser (closes #863) (inikulin)
- * Fix small typo in Readme (Darren Scerri)
- * Report test failures in CI (Mike Pennisi)
- * serializeArray should not ignore input elements without value attributes (Ricardo Gladwell)
- * Disallow variable shadowing (Mike Pennisi)
- * Update hasClass method (sufisaid)
- * Added MIT License fixes #902 (Prasanth Vaaheeswaran)
- * chore(package): update dependencies (greenkeeper[bot])
- * Use modular lodash package (#913) (Billy Janitsch)
 
 0.22.0 / 2016-08-23
 ==================
diff --git a/Makefile b/Makefile
index 52edbb40a9..3617d89b23 100644
--- a/Makefile
+++ b/Makefile
@@ -1,9 +1,8 @@
 REPORTER = dot
 XYZ = node_modules/.bin/xyz --message 'Release X.Y.Z' --tag X.Y.Z --repo git@github.com:cheeriojs/cheerio.git --script scripts/prepublish
-UPSTREAM = git@github.com:cheeriojs/cheerio.git
 
 lint:
-	@./node_modules/.bin/eslint --ignore-path .gitignore .
+	@./node_modules/.bin/jshint lib/ test/
 
 test: lint
 	@./node_modules/.bin/mocha --recursive --reporter $(REPORTER)
@@ -37,16 +36,4 @@ release-patch: LEVEL = patch
 release-major release-minor release-patch:
 	@$(XYZ) --increment $(LEVEL)
 
-docs:
-	@./node_modules/.bin/jsdoc --configure jsdoc-config.json
-
-publish-docs: docs
-	@cd docs; \
-		rm -rf .git && \
-		git init && \
-		git add --all . && \
-		git commit -m 'Generate documentation' && \
-		git remote add upstream $(UPSTREAM) && \
-		git push --force upstream master:gh-pages
-
-.PHONY: test build setup subl docs publish-docs
+.PHONY: test build setup subl
diff --git a/Readme.md b/Readme.md
index 3171f0f6dd..8d8fdc325a 100644
--- a/Readme.md
+++ b/Readme.md
@@ -30,7 +30,7 @@ $('h2.title').text('Hello there!')
 $('h2').addClass('welcome')
 
 $.html()
-//=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>
+//=> <h2 class="title welcome">Hello there!</h2>
 ```
 
 ## Note
@@ -48,7 +48,7 @@ __&#991; Blazingly fast:__
 Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient. Preliminary end-to-end benchmarks suggest that cheerio is about __8x__ faster than JSDOM.
 
 __&#10049; Incredibly flexible:__
-Cheerio wraps around [parse5](https://github.com/inikulin/parse5) parser and can optionally use @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.
+Cheerio wraps around @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.
 
 ## Cheerio is not a web browser
 
@@ -126,6 +126,107 @@ Does your company use Cheerio in production? Please consider [sponsoring this pr
 
 ## API
 
+### Table of contents
+
+<details>
+  <summary>Selectors</summary>
+
+  - [$( selector, [context], [root] )](#-selector-context-root-)
+</details>
+<details>
+  <summary>Attributes</summary>
+
+  - [.attr( name, value )](#attr-name-value-)
+  - [.prop( name, value )](#prop-name-value-)
+  - [.data( name, value )](#data-name-value-)
+  - [.val( [value] )](#val-value-)
+  - [.removeAttr( name )](#removeattr-name-)
+  - [.hasClass( className )](#hasclass-classname-)
+  - [.addClass( className )](#addclass-classname-)
+  - [.removeClass( [className] )](#removeclass-classname-)
+  - [.toggleClass( className, [switch] )](#toggleclass-classname-switch-)
+  - [.is( selector )](#is-selector-)
+  - [.is( element )](#is-element-)
+  - [.is( selection )](#is-selection-)
+  - [.is( function(index) )](#is-functionindex-)
+</details>
+<details>
+  <summary>Forms</summary>
+
+  - [.serialize()](#serialize)
+  - [.serializeArray()](#serializearray)
+</details>
+<details>
+  <summary>Traversing</summary>
+
+  - [.find(selector)](#findselector)
+  - [.find(selection)](#findselection)
+  - [.find(node)](#findnode)
+  - [.parent([selector])](#parentselector)
+  - [.parents([selector])](#parentsselector)
+  - [.parentsUntil([selector][,filter])](#parentsuntilselectorfilter)
+  - [.closest(selector)](#closestselector)
+  - [.next([selector])](#nextselector)
+  - [.nextAll([selector])](#nextallselector)
+  - [.nextUntil([selector], [filter])](#nextuntilselector-filter)
+  - [.prev([selector])](#prevselector)
+  - [.prevAll([selector])](#prevallselector)
+  - [.prevUntil([selector], [filter])](#prevuntilselector-filter)
+  - [.slice( start, [end] )](#slice-start-end-)
+  - [.siblings([selector])](#siblingsselector)
+  - [.children([selector])](#childrenselector)
+  - [.contents()](#contents)
+  - [.each( function(index, element) )](#each-functionindex-element-)
+  - [.map( function(index, element) )](#map-functionindex-element-)
+  - [.filter( selector )<br>
+     .filter( selection )<br>
+     .filter( element )<br>
+     .filter( function(index, element) )](#filter-selector---filter-selection---filter-element---filter-functionindex-element-)
+  - [.not( selector )<br>
+     .not( selection )<br>
+     .not( element )<br>
+     .not( function(index, elem) )](#not-selector---not-selection---not-element---not-functionindex-elem-)
+  - [.has( selector )<br>
+     .has( element )](#has-selector---has-element-)
+  - [.first()](#first)
+  - [.last()](#last)
+  - [.eq( i )](#eq-i-)
+  - [.get( [i] )](#get-i-)
+  - [.index()](#index)
+  - [.index( selector )](#index-selector-)
+  - [.index( nodeOrSelection )](#index-nodeorselection-)
+  - [.end()](#end)
+  - [.add( selector [, context] )](#add-selector--context-)
+  - [.add( element )](#add-element-)
+  - [.add( elements )](#add-elements-)
+  - [.add( html )](#add-html-)
+  - [.add( selection )](#add-selection-)
+  - [.addBack( [filter] )](#addback-filter-)
+</details>
+<details>
+  <summary>Manipulation</summary>
+
+  - [.append( content, [content, ...] )](#append-content-content--)
+  - [.appendTo( target )](#appendto-target-)
+  - [.prepend( content, [content, ...] )](#prepend-content-content--)
+  - [.prependTo( target )](#prependto-target-)
+  - [.after( content, [content, ...] )](#after-content-content--)
+  - [.insertAfter( target )](#insertafter-target-)
+  - [.before( content, [content, ...] )](#before-content-content--)
+  - [.insertBefore( target )](#insertbefore-target-)
+  - [.remove( [selector] )](#remove-selector-)
+  - [.replaceWith( content )](#replacewith-content-)
+  - [.empty()](#empty)
+  - [.html( [htmlString] )](#html-htmlstring-)
+  - [.text( [textString] )](#text-textstring-)
+  - [.wrap( content )](#wrap-content-)
+  - [.css( [propertName] )<br>
+     .css( [ propertyNames] )<br>
+     .css( [propertyName], [value] )<br>
+     .css( [propertName], [function] )<br>
+     .css( [properties] )](#css-propertname---css--propertynames---css-propertyname-value---css-propertname-function---css-properties-)
+</details>
+
 ### Markup example we'll be using:
 
 ```html
@@ -162,53 +263,31 @@ const $ = require('cheerio');
 $('li', 'ul', '<ul id="fruits">...</ul>');
 ```
 
-If you need to modify parsing options for XML input, you may pass an extra
-object to `.load()`:
+You can also pass an extra object to `.load()` if you need to modify any
+of the default parsing options:
 
 ```js
 const $ = cheerio.load('<ul id="fruits">...</ul>', {
-    xml: {
-      normalizeWhitespace: true,
-    }
+    normalizeWhitespace: true,
+    xmlMode: true
 });
 ```
 
-The options in the `xml` object are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. The default options are:
+These parsing options are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. The default options are:
 
 ```js
 {
     withDomLvl1: true,
     normalizeWhitespace: false,
-    xmlMode: true,
+    xmlMode: false,
     decodeEntities: true
 }
+
 ```
 
 For a full list of options and their effects, see [this](https://github.com/fb55/DomHandler) and
 [htmlparser2's options](https://github.com/fb55/htmlparser2/wiki/Parser-options).
 
-Some users may wish to parse markup with the `htmlparser2` library, and
-traverse/manipulate the resulting structure with Cheerio. This may be the case
-for those upgrading from pre-1.0 releases of Cheerio (which relied on
-`htmlparser2`), for those dealing with invalid markup (because `htmlparser2` is
-more forgiving), or for those operating in performance-critical situations
-(because `htmlparser2` may be faster in some cases). Note that "more forgiving"
-means `htmlparser2` has error-correcting mechanisms that aren't always a match
-for the standards observed by web browsers. This behavior may be useful when
-parsing non-HTML content.
-
-To support these cases, `load` also accepts a `htmlparser2`-compatible data
-structure as its first argument. Users may install `htmlparser2`, use it to
-parse input, and pass the result to `load`:
-
-```js
-// Usage as of htmlparser2 version 3:
-const htmlparser2 = require('htmlparser2');
-const dom = htmlparser2.parseDOM(document, options);
-
-const $ = cheerio.load(dom);
-```
-
 ### Selectors
 
 Cheerio's selector implementation is nearly identical to jQuery's, so the API is very similar.
@@ -236,6 +315,677 @@ You can select with XML Namespaces but [due to the CSS specification](https://ww
 $('[xml\\:id="main"');
 ```
 
+### Attributes
+Methods for getting and modifying attributes.
+
+#### .attr( name, value )
+Method for getting and setting attributes. Gets the attribute value for only the first element in the matched set. If you set an attribute's value to `null`, you remove that attribute. You may also pass a `map` and `function` like jQuery.
+
+```js
+$('ul').attr('id')
+//=> fruits
+
+$('.apple').attr('id', 'favorite').html()
+//=> <li class="apple" id="favorite">Apple</li>
+```
+
+> See http://api.jquery.com/attr/ for more information
+
+#### .prop( name, value )
+Method for getting and setting properties. Gets the property value for only the first element in the matched set.
+
+```js
+$('input[type="checkbox"]').prop('checked')
+//=> false
+
+$('input[type="checkbox"]').prop('checked', true).val()
+//=> ok
+```
+
+> See http://api.jquery.com/prop/ for more information
+
+#### .data( name, value )
+Method for getting and setting data attributes. Gets or sets the data attribute value for only the first element in the matched set.
+
+```js
+$('<div data-apple-color="red"></div>').data()
+//=> { appleColor: 'red' }
+
+$('<div data-apple-color="red"></div>').data('apple-color')
+//=> 'red'
+
+const apple = $('.apple').data('kind', 'mac')
+apple.data('kind')
+//=> 'mac'
+```
+
+> See http://api.jquery.com/data/ for more information
+
+#### .val( [value] )
+Method for getting and setting the value of input, select, and textarea. Note: Support for `map`, and `function` has not been added yet.
+
+```js
+$('input[type="text"]').val()
+//=> input_text
+
+$('input[type="text"]').val('test').html()
+//=> <input type="text" value="test"/>
+```
+
+#### .removeAttr( name )
+Method for removing attributes by `name`.
+
+```js
+$('.pear').removeAttr('class').html()
+//=> <li>Pear</li>
+```
+
+#### .hasClass( className )
+Check to see if *any* of the matched elements have the given `className`.
+
+```js
+$('.pear').hasClass('pear')
+//=> true
+
+$('apple').hasClass('fruit')
+//=> false
+
+$('li').hasClass('pear')
+//=> true
+```
+
+#### .addClass( className )
+Adds class(es) to all of the matched elements. Also accepts a `function` like jQuery.
+
+```js
+$('.pear').addClass('fruit').html()
+//=> <li class="pear fruit">Pear</li>
+
+$('.apple').addClass('fruit red').html()
+//=> <li class="apple fruit red">Apple</li>
+```
+
+> See http://api.jquery.com/addClass/ for more information.
+
+#### .removeClass( [className] )
+Removes one or more space-separated classes from the selected elements. If no `className` is defined, all classes will be removed. Also accepts a `function` like jQuery.
+
+```js
+$('.pear').removeClass('pear').html()
+//=> <li class="">Pear</li>
+
+$('.apple').addClass('red').removeClass().html()
+//=> <li class="">Apple</li>
+```
+
+> See http://api.jquery.com/removeClass/ for more information.
+
+#### .toggleClass( className, [switch] )
+Add or remove class(es) from the matched elements, depending on either the class's presence or the value of the switch argument. Also accepts a `function` like jQuery.
+
+```js
+$('.apple.green').toggleClass('fruit green red').html()
+//=> <li class="apple fruit red">Apple</li>
+
+$('.apple.green').toggleClass('fruit green red', true).html()
+//=> <li class="apple green fruit red">Apple</li>
+```
+
+> See http://api.jquery.com/toggleClass/ for more information.
+
+#### .is( selector )
+#### .is( element )
+#### .is( selection )
+#### .is( function(index) )
+Checks the current list of elements and returns `true` if _any_ of the elements match the selector. If using an element or Cheerio selection, returns `true` if _any_ of the elements match. If using a predicate function, the function is executed in the context of the selected element, so `this` refers to the current element.
+
+### Forms
+
+#### .serialize()
+
+Encodes a set of form elements as a URL query string.
+
+```js
+$('<form><input name="foo" value="bar" checked /><input name="foo" value="qux" checked /></form>').serialize()
+//=> foo=bar&foo=qux
+```
+
+#### .serializeArray()
+
+Encode a set of form elements as an array of names and values.
+
+```js
+$('<form><input name="foo" value="bar" /></form>').serializeArray()
+//=> [ { name: 'foo', value: 'bar' } ]
+```
+
+### Traversing
+
+#### .find(selector)
+#### .find(selection)
+#### .find(node)
+Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
+
+```js
+$('#fruits').find('li').length
+//=> 3
+$('#fruits').find($('.apple')).length
+//=> 1
+```
+
+#### .parent([selector])
+Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
+
+```js
+$('.pear').parent().attr('id')
+//=> fruits
+```
+
+#### .parents([selector])
+Get a set of parents filtered by `selector` of each element in the current set of match elements.
+```js
+$('.orange').parents().length
+// => 2
+$('.orange').parents('#fruits').length
+// => 1
+```
+
+#### .parentsUntil([selector][,filter])
+Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or cheerio object.
+```js
+$('.orange').parentsUntil('#food').length
+// => 1
+```
+
+#### .closest(selector)
+For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+
+```js
+$('.orange').closest()
+// => []
+$('.orange').closest('.apple')
+// => []
+$('.orange').closest('li')
+// => [<li class="orange">Orange</li>]
+$('.orange').closest('#fruits')
+// => [<ul id="fruits"> ... </ul>]
+```
+
+#### .next([selector])
+Gets the next sibling of the first selected element, optionally filtered by a selector.
+
+```js
+$('.apple').next().hasClass('orange')
+//=> true
+```
+
+#### .nextAll([selector])
+Gets all the following siblings of the first selected element, optionally filtered by a selector.
+
+```js
+$('.apple').nextAll()
+//=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
+$('.apple').nextAll('.orange')
+//=> [<li class="orange">Orange</li>]
+```
+
+#### .nextUntil([selector], [filter])
+Gets all the following siblings up to but not including the element matched by the selector, optionally filtered by another selector.
+
+```js
+$('.apple').nextUntil('.pear')
+//=> [<li class="orange">Orange</li>]
+```
+
+#### .prev([selector])
+Gets the previous sibling of the first selected element optionally filtered by a selector.
+
+```js
+$('.orange').prev().hasClass('apple')
+//=> true
+```
+
+#### .prevAll([selector])
+Gets all the preceding siblings of the first selected element, optionally filtered by a selector.
+
+```js
+$('.pear').prevAll()
+//=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
+$('.pear').prevAll('.orange')
+//=> [<li class="orange">Orange</li>]
+```
+
+#### .prevUntil([selector], [filter])
+Gets all the preceding siblings up to but not including the element matched by the selector, optionally filtered by another selector.
+
+```js
+$('.pear').prevUntil('.apple')
+//=> [<li class="orange">Orange</li>]
+```
+
+#### .slice( start, [end] )
+Gets the elements matching the specified range
+
+```js
+$('li').slice(1).eq(0).text()
+//=> 'Orange'
+
+$('li').slice(1, 2).length
+//=> 1
+```
+
+#### .siblings([selector])
+Gets the first selected element's siblings, excluding itself.
+
+```js
+$('.pear').siblings().length
+//=> 2
+
+$('.pear').siblings('.orange').length
+//=> 1
+
+```
+
+#### .children([selector])
+Gets the children of the first selected element.
+
+```js
+$('#fruits').children().length
+//=> 3
+
+$('#fruits').children('.pear').text()
+//=> Pear
+```
+
+#### .contents()
+Gets the children of each element in the set of matched elements, including text and comment nodes.
+
+```js
+$('#fruits').contents().length
+//=> 3
+```
+
+#### .each( function(index, element) )
+Iterates over a cheerio object, executing a function for each matched element. When the callback is fired, the function is fired in the context of the DOM element, so `this` refers to the current element, which is equivalent to the function parameter `element`. To break out of the `each` loop early, return with `false`.
+
+```js
+const fruits = [];
+
+$('li').each(function(i, elem) {
+  fruits[i] = $(this).text();
+});
+
+fruits.join(', ');
+//=> Apple, Orange, Pear
+```
+
+#### .map( function(index, element) )
+Pass each element in the current matched set through a function, producing a new Cheerio object containing the return values. The function can return an individual data item or an array of data items to be inserted into the resulting set. If an array is returned, the elements inside the array are inserted into the set. If the function returns null or undefined, no element will be inserted.
+
+```js
+$('li').map(function(i, el) {
+  // this === el
+  return $(this).text();
+}).get().join(' ');
+//=> "apple orange pear"
+```
+
+#### .filter( selector ) <br /> .filter( selection ) <br /> .filter( element ) <br /> .filter( function(index, element) )
+
+Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test. When a Cheerio selection is specified, return only the elements contained in that selection. When an element is specified, return only that element (if it is contained in the original selection). If using the function method, the function is executed in the context of the selected element, so `this` refers to the current element.
+
+Selector:
+
+```js
+$('li').filter('.orange').attr('class');
+//=> orange
+```
+
+Function:
+
+```js
+$('li').filter(function(i, el) {
+  // this === el
+  return $(this).attr('class') === 'orange';
+}).attr('class')
+//=> orange
+```
+
+#### .not( selector ) <br /> .not( selection ) <br /> .not( element ) <br /> .not( function(index, elem) )
+
+Remove elements from the set of matched elements. Given a jQuery object that represents a set of DOM elements, the `.not()` method constructs a new jQuery object from a subset of the matching elements. The supplied selector is tested against each element; the elements that don't match the selector will be included in the result. The `.not()` method can take a function as its argument in the same way that `.filter()` does. Elements for which the function returns true are excluded from the filtered set; all other elements are included.
+
+Selector:
+
+```js
+$('li').not('.apple').length;
+//=> 2
+```
+
+Function:
+
+```js
+$('li').not(function(i, el) {
+  // this === el
+  return $(this).attr('class') === 'orange';
+}).length;
+//=> 2
+```
+
+#### .has( selector ) <br /> .has( element )
+
+Filters the set of matched elements to only those which have the given DOM element as a descendant or which have a descendant that matches the given selector. Equivalent to `.filter(':has(selector)')`.
+
+Selector:
+
+```js
+$('ul').has('.pear').attr('id');
+//=> fruits
+```
+
+Element:
+
+```js
+$('ul').has($('.pear')[0]).attr('id');
+//=> fruits
+```
+
+#### .first()
+Will select the first element of a cheerio object
+
+```js
+$('#fruits').children().first().text()
+//=> Apple
+```
+
+#### .last()
+Will select the last element of a cheerio object
+
+```js
+$('#fruits').children().last().text()
+//=> Pear
+```
+
+#### .eq( i )
+Reduce the set of matched elements to the one at the specified index. Use `.eq(-i)` to count backwards from the last selected element.
+
+```js
+$('li').eq(0).text()
+//=> Apple
+
+$('li').eq(-1).text()
+//=> Pear
+```
+
+#### .get( [i] )
+
+Retrieve the DOM elements matched by the Cheerio object. If an index is specified, retrieve one of the elements matched by the Cheerio object:
+
+```js
+$('li').get(0).tagName
+//=> li
+```
+
+If no index is specified, retrieve all elements matched by the Cheerio object:
+
+```js
+$('li').get().length
+//=> 3
+```
+
+#### .index()
+#### .index( selector )
+#### .index( nodeOrSelection )
+
+Search for a given element from among the matched elements.
+
+```js
+$('.pear').index()
+//=> 2
+$('.orange').index('li')
+//=> 1
+$('.apple').index($('#fruit, li'))
+//=> 1
+```
+
+#### .end()
+End the most recent filtering operation in the current chain and return the set of matched elements to its previous state.
+
+```js
+$('li').eq(0).end().length
+//=> 3
+```
+
+#### .add( selector [, context] )
+#### .add( element )
+#### .add( elements )
+#### .add( html )
+#### .add( selection )
+Add elements to the set of matched elements.
+
+```js
+$('.apple').add('.orange').length
+//=> 2
+```
+
+#### .addBack( [filter] )
+
+Add the previous set of elements on the stack to the current set, optionally filtered by a selector.
+
+```js
+$('li').eq(0).addBack('.orange').length
+//=> 2
+```
+
+### Manipulation
+Methods for modifying the DOM structure.
+
+#### .append( content, [content, ...] )
+Inserts content as the *last* child of each of the selected elements.
+
+```js
+$('ul').append('<li class="plum">Plum</li>')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//      <li class="plum">Plum</li>
+//    </ul>
+```
+
+#### .appendTo( target )
+Insert every element in the set of matched elements to the end of the target.
+
+```js
+$('<li class="plum">Plum</li>').appendTo('#fruits')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//      <li class="plum">Plum</li>
+//    </ul>
+```
+
+#### .prepend( content, [content, ...] )
+Inserts content as the *first* child of each of the selected elements.
+
+```js
+$('ul').prepend('<li class="plum">Plum</li>')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="plum">Plum</li>
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .prependTo( target )
+Insert every element in the set of matched elements to the beginning of the target.
+
+```js
+$('<li class="plum">Plum</li>').prependTo('#fruits')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="plum">Plum</li>
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .after( content, [content, ...] )
+Insert content next to each element in the set of matched elements.
+
+```js
+$('.apple').after('<li class="plum">Plum</li>')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="apple">Apple</li>
+//      <li class="plum">Plum</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .insertAfter( target )
+Insert every element in the set of matched elements after the target.
+
+```js
+$('<li class="plum">Plum</li>').insertAfter('.apple')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="apple">Apple</li>
+//      <li class="plum">Plum</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .before( content, [content, ...] )
+Insert content previous to each element in the set of matched elements.
+
+```js
+$('.apple').before('<li class="plum">Plum</li>')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="plum">Plum</li>
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .insertBefore( target )
+Insert every element in the set of matched elements before the target.
+
+```js
+$('<li class="plum">Plum</li>').insertBefore('.apple')
+$.html()
+//=>  <ul id="fruits">
+//      <li class="plum">Plum</li>
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//      <li class="pear">Pear</li>
+//    </ul>
+```
+
+#### .remove( [selector] )
+Removes the set of matched elements from the DOM and all their children. `selector` filters the set of matched elements to be removed.
+
+```js
+$('.pear').remove()
+$.html()
+//=>  <ul id="fruits">
+//      <li class="apple">Apple</li>
+//      <li class="orange">Orange</li>
+//    </ul>
+```
+
+#### .replaceWith( content )
+Replaces matched elements with `content`.
+
+```js
+const plum = $('<li class="plum">Plum</li>')
+$('.pear').replaceWith(plum)
+$.html()
+//=> <ul id="fruits">
+//     <li class="apple">Apple</li>
+//     <li class="orange">Orange</li>
+//     <li class="plum">Plum</li>
+//   </ul>
+```
+
+#### .empty()
+Empties an element, removing all its children.
+
+```js
+$('ul').empty()
+$.html()
+//=>  <ul id="fruits"></ul>
+```
+
+#### .html( [htmlString] )
+Gets an html content string from the first selected element. If `htmlString` is specified, each selected element's content is replaced by the new content.
+
+```js
+$('.orange').html()
+//=> Orange
+
+$('#fruits').html('<li class="mango">Mango</li>').html()
+//=> <li class="mango">Mango</li>
+```
+
+#### .text( [textString] )
+Get the combined text contents of each element in the set of matched elements, including their descendants. If `textString` is specified, each selected element's content is replaced by the new text content.
+
+```js
+$('.orange').text()
+//=> Orange
+
+$('ul').text()
+//=>  Apple
+//    Orange
+//    Pear
+```
+
+#### .wrap( content )
+The .wrap() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. A copy of this structure will be wrapped around each of the elements in the set of matched elements. This method returns the original set of elements for chaining purposes.
+
+```js
+const redFruit = $('<div class="red-fruit"></div>')
+$('.apple').wrap(redFruit)
+
+//=> <ul id="fruits">
+//     <div class="red-fruit">
+//      <li class="apple">Apple</li>
+//     </div>
+//     <li class="orange">Orange</li>
+//     <li class="plum">Plum</li>
+//   </ul>
+
+const healthy = $('<div class="healthy"></div>')
+$('li').wrap(healthy)
+
+//=> <ul id="fruits">
+//     <div class="healthy">
+//       <li class="apple">Apple</li>
+//     </div>
+//     <div class="healthy">
+//       <li class="orange">Orange</li>
+//     </div>
+//     <div class="healthy">
+//        <li class="plum">Plum</li>
+//     </div>
+//   </ul>
+```
+
+#### .css( [propertyName] ) <br /> .css( [ propertyNames] ) <br /> .css( [propertyName], [value] ) <br /> .css( [propertyName], [function] ) <br /> .css( [properties] )
+
+Get the value of a style property for the first element in the set of matched elements or set one or more CSS properties for every matched element.
+
 ### Rendering
 When you're ready to render the document, you can use the `html` utility function:
 
@@ -284,6 +1034,44 @@ cheerio.text($('div'))
 //=> This is content.
 ```
 
+### Miscellaneous
+DOM element methods that don't fit anywhere else
+
+#### .toArray()
+Retrieve all the DOM elements contained in the jQuery set as an array.
+
+```js
+$('li').toArray()
+//=> [ {...}, {...}, {...} ]
+```
+
+#### .clone() ####
+Clone the cheerio object.
+
+```js
+const moreFruit = $('#fruits').clone()
+```
+
+### Utilities
+
+#### $.root
+
+Sometimes you need to work with the top-level root element. To query it, you can use `$.root()`.
+
+```js
+$.root().append('<ul id="vegetables"></ul>').html();
+//=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+```
+
+#### $.contains( container, contained )
+Checks to see if the `contained` DOM element is a descendant of the `container` DOM element.
+
+#### $.parseHTML( data [, context ] [, keepScripts ] )
+Parses a string into an array of DOM nodes. The `context` argument has no meaning for Cheerio, but it is maintained for API compatability.
+
+#### $.load( html[, options ] )
+Load in the HTML. (See the previous section titled "Loading" for more information.)
+
 ### Plugins
 
 Once you have loaded a document, you may extend the prototype or the equivalent `fn` property with custom plugin methods:
diff --git a/benchmark/.eslintrc.json b/benchmark/.eslintrc.json
deleted file mode 100644
index 7753f32e77..0000000000
--- a/benchmark/.eslintrc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "no-console": 0
-  }
-}
diff --git a/benchmark/benchmark.js b/benchmark/benchmark.js
index 1aa0fdf53a..6d1825d94a 100755
--- a/benchmark/benchmark.js
+++ b/benchmark/benchmark.js
@@ -16,14 +16,10 @@ if (process.argv.indexOf('--cheerio-only') >= 0) {
 }
 
 suites.add('Select all', 'jquery.html', {
-  test: function($) {
-    $('*').length;
-  }
+  test: function($) { $('*').length; }
 });
 suites.add('Select some', 'jquery.html', {
-  test: function($) {
-    $('li').length;
-  }
+  test: function($) { $('li').length; }
 });
 
 /*
@@ -79,7 +75,7 @@ suites.add('manipulation - replaceWith', 'jquery.html', {
   setup: function($) {
     $('body').append('<div id="foo">');
   },
-  test: function($) {
+  test: function($, $lis) {
     $('#foo').replaceWith('<div id="foo">');
   }
 });
@@ -111,14 +107,12 @@ suites.add('manipulation - html render', 'jquery.html', {
 });
 suites.add('manipulation - html independent', 'jquery.html', {
   setup: function() {
-    return (
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>' +
-      '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
-    );
+    return '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>'
+        + '<div class="foo"><div id="bar">bat<hr>baz</div> </div>';
   },
   test: function($, content) {
     $(content).html();
@@ -134,6 +128,7 @@ suites.add('manipulation - text', 'jquery.html', {
   }
 });
 
+
 /*
  * Traversing Tests
  */
@@ -266,6 +261,7 @@ suites.add('traversing - Eq', 'jquery.html', {
   }
 });
 
+
 /*
  * Attributes Tests
  */
diff --git a/benchmark/suite.js b/benchmark/suite.js
index b5d2cf863a..da029ad7ec 100644
--- a/benchmark/suite.js
+++ b/benchmark/suite.js
@@ -2,18 +2,15 @@ var fs = require('fs');
 var path = require('path');
 
 var Benchmark = require('benchmark');
-var jsdom = require('jsdom/lib/old-api.js');
+var jsdom = require('jsdom');
 var cheerio = require('..');
 
 var documentDir = path.join(__dirname, 'documents');
-var jQuerySrc = path.join(
-  __dirname,
-  '../node_modules/jquery/dist/jquery.slim.js'
-);
+var jQuerySrc = path.join(__dirname, '../node_modules/jquery/dist/jquery.slim.js');
 var filterRe = /./;
 var cheerioOnly = false;
 
-var Suites = (module.exports = function() {});
+var Suites = module.exports = function() {};
 
 Suites.prototype.filter = function(str) {
   filterRe = new RegExp(str, 'i');
@@ -24,14 +21,15 @@ Suites.prototype.cheerioOnly = function() {
 };
 
 Suites.prototype.add = function(name, fileName, options) {
-  var markup, suite;
+  var markup, suite, testFn;
   if (!filterRe.test(name)) {
     return;
   }
   markup = fs.readFileSync(path.join(documentDir, fileName), 'utf8');
   suite = new Benchmark.Suite(name);
+  testFn = options.test;
 
-  suite.on('start', function() {
+  suite.on('start', function(event) {
     console.log('Test: ' + name + ' (file: ' + fileName + ')');
   });
   suite.on('cycle', function(event) {
diff --git a/jsdoc-config.json b/jsdoc-config.json
deleted file mode 100644
index 01e9af8b19..0000000000
--- a/jsdoc-config.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "opts": {
-    "destination": "./docs",
-    "readme": "Readme.md",
-    "recurse": true
-  },
-  "plugins": ["plugins/markdown"],
-  "source": {
-    "include": ["lib"]
-  }
-}
diff --git a/lib/api/attributes.js b/lib/api/attributes.js
index 3ce6a90706..6abbb2f7dc 100644
--- a/lib/api/attributes.js
+++ b/lib/api/attributes.js
@@ -1,9 +1,4 @@
-/**
- * Methods for getting and modifying attributes.
- *
- * @module attributes
- */
-var text = require('../static').text,
+var $ = require('../static'),
     utils = require('../utils'),
     isTag = utils.isTag,
     domEach = utils.domEach,
@@ -17,17 +12,20 @@ var text = require('../static').text,
       extend: require('lodash/assignIn'),
       some: require('lodash/some')
     },
-    // Lookup table for coercing string data-* attributes to their corresponding
-    // JavaScript primitives
-    primitives = {
-      null: null,
-      true: true,
-      false: false
-    },
-    // Attributes that are booleans
-    rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
-    // Matches strings that look like JSON objects or arrays
-    rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
+
+  // Lookup table for coercing string data-* attributes to their corresponding
+  // JavaScript primitives
+  primitives = {
+    null: null,
+    true: true,
+    false: false
+  },
+
+  // Attributes that are booleans
+  rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+  // Matches strings that look like JSON objects or arrays
+  rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
+
 
 var getAttr = function(elem, name) {
   if (!elem || !isTag(elem)) return;
@@ -48,46 +46,26 @@ var getAttr = function(elem, name) {
 
   // Mimic the DOM and return text content as value for `option's`
   if (elem.name === 'option' && name === 'value') {
-    return text(elem.children);
+    return $.text(elem.children);
   }
 
   // Mimic DOM with default value for radios/checkboxes
-  if (
-    elem.name === 'input' &&
-    (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
-    name === 'value'
-  ) {
+  if (elem.name === 'input' &&
+      (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
+      name === 'value') {
     return 'on';
   }
 };
 
 var setAttr = function(el, name, value) {
+
   if (value === null) {
     removeAttribute(el, name);
   } else {
-    el.attribs[name] = value + '';
+    el.attribs[name] = value+'';
   }
 };
 
-/**
- * Method for getting and setting attributes. Gets the attribute value for only
- * the first element in the matched set. If you set an attribute's value to
- * `null`, you remove that attribute. You may also pass a `map` and `function`
- * like jQuery.
- *
- * @example
- *
- * $('ul').attr('id')
- * //=> fruits
- *
- * $('.apple').attr('id', 'favorite').html()
- * //=> <li class="apple" id="favorite">Apple</li>
- *
- * @param {string} name - Name of the attribute.
- * @param {string} [value] - If specified sets the value of the attribute.
- *
- * @see {@link http://api.jquery.com/attr/}
- */
 exports.attr = function(name, value) {
   // Set the value (with attr map support)
   if (typeof name === 'object' || value !== undefined) {
@@ -112,45 +90,31 @@ exports.attr = function(name, value) {
   return getAttr(this[0], name);
 };
 
-var getProp = function(el, name) {
+var getProp = function (el, name) {
   if (!el || !isTag(el)) return;
 
   return name in el
-    ? el[name]
-    : rboolean.test(name) ? getAttr(el, name) !== undefined : getAttr(el, name);
+      ? el[name]
+      : rboolean.test(name)
+          ? getAttr(el, name) !== undefined
+          : getAttr(el, name);
 };
 
-var setProp = function(el, name, value) {
+var setProp = function (el, name, value) {
   el[name] = rboolean.test(name) ? !!value : value;
 };
 
-/**
- * Method for getting and setting properties. Gets the property value for only
- * the first element in the matched set.
- *
- * @example
- *
- * $('input[type="checkbox"]').prop('checked')
- * //=> false
- *
- * $('input[type="checkbox"]').prop('checked', true).val()
- * //=> ok
- *
- * @param {string} name - Name of the property.
- * @param {any} [value] - If specified set the property to this.
- *
- * @see {@link http://api.jquery.com/prop/}
- */
-exports.prop = function(name, value) {
+exports.prop = function (name, value) {
   var i = 0,
       property;
 
   if (typeof name === 'string' && value === undefined) {
+
     switch (name) {
       case 'style':
         property = this.css();
 
-        _.forEach(property, function(v, p) {
+        _.forEach(property, function (v, p) {
           property[i++] = p;
         });
 
@@ -161,12 +125,6 @@ exports.prop = function(name, value) {
       case 'nodeName':
         property = this[0].name.toUpperCase();
         break;
-      case 'outerHTML':
-        property = this.clone()
-          .wrap('<container />')
-          .parent()
-          .html();
-        break;
       default:
         property = getProp(this[0], name);
     }
@@ -175,6 +133,7 @@ exports.prop = function(name, value) {
   }
 
   if (typeof name === 'object' || value !== undefined) {
+
     if (typeof value === 'function') {
       return domEach(this, function(j, el) {
         setProp(el, name, value.call(el, j, getProp(el, name)));
@@ -185,13 +144,16 @@ exports.prop = function(name, value) {
       if (!isTag(el)) return;
 
       if (typeof name === 'object') {
+
         _.forEach(name, function(val, key) {
           setProp(el, key, val);
         });
+
       } else {
         setProp(el, name, value);
       }
     });
+
   }
 };
 
@@ -239,9 +201,7 @@ var readData = function(el, name) {
       } else if (rbrace.test(value)) {
         try {
           value = JSON.parse(value);
-        } catch (e) {
-          /* ignore */
-        }
+        } catch(e){ }
       }
 
       el.data[jsName] = value;
@@ -251,27 +211,6 @@ var readData = function(el, name) {
   return readAll ? el.data : value;
 };
 
-/**
- * Method for getting and setting data attributes. Gets or sets the data
- * attribute value for only the first element in the matched set.
- *
- * @example
- *
- * $('<div data-apple-color="red"></div>').data()
- * //=> { appleColor: 'red' }
- *
- * $('<div data-apple-color="red"></div>').data('apple-color')
- * //=> 'red'
- *
- * const apple = $('.apple').data('kind', 'mac')
- * apple.data('kind')
- * //=> 'mac'
- *
- * @param {string} name - Name of the attribute.
- * @param {any} [value] - If specified new value.
- *
- * @see {@link http://api.jquery.com/data/}
- */
 exports.data = function(name, value) {
   var elem = this[0];
 
@@ -300,47 +239,38 @@ exports.data = function(name, value) {
 };
 
 /**
- * Method for getting and setting the value of input, select, and textarea.
- * Note: Support for `map`, and `function` has not been added yet.
- *
- * @example
- *
- * $('input[type="text"]').val()
- * //=> input_text
- *
- * $('input[type="text"]').val('test').html()
- * //=> <input type="text" value="test"/>
- *
- * @param {string} [value] - If specified new value.
- *
- * @see {@link http://api.jquery.com/val/}
+ * Get the value of an element
  */
+
 exports.val = function(value) {
   var querying = arguments.length === 0,
       element = this[0];
 
-  if (!element) return;
+  if(!element) return;
 
   switch (element.name) {
     case 'textarea':
       return this.text(value);
     case 'input':
-      if (this.attr('type') === 'radio') {
-        if (querying) {
-          return this.attr('value');
-        }
-
-        this.attr('value', value);
-        return this;
+      switch (this.attr('type')) {
+        case 'radio':
+          if (querying) {
+            return this.attr('value');
+          } else {
+            this.attr('value', value);
+            return this;
+          }
+          break;
+        default:
+          return this.attr('value', value);
       }
-
-      return this.attr('value', value);
+      return;
     case 'select':
       var option = this.find('option:selected'),
           returnValue;
       if (option === undefined) return undefined;
       if (!querying) {
-        if (!hasOwn.call(this.attr(), 'multiple') && typeof value == 'object') {
+        if (!this.attr().hasOwnProperty('multiple') && typeof value == 'object') {
           return this;
         }
         if (typeof value != 'object') {
@@ -353,7 +283,7 @@ exports.val = function(value) {
         return this;
       }
       returnValue = option.attr('value');
-      if (hasOwn.call(this.attr(), 'multiple')) {
+      if (this.attr().hasOwnProperty('multiple')) {
         returnValue = [];
         domEach(option, function(__, el) {
           returnValue.push(getAttr(el, 'value'));
@@ -370,30 +300,17 @@ exports.val = function(value) {
 };
 
 /**
- * Remove an attribute.
- *
- * @private
- * @param {node} elem - Node to remove attribute from.
- * @param {string} name - Name of the attribute to remove.
+ * Remove an attribute
  */
+
 var removeAttribute = function(elem, name) {
-  if (!elem.attribs || !hasOwn.call(elem.attribs, name)) return;
+  if (!elem.attribs || !hasOwn.call(elem.attribs, name))
+    return;
 
   delete elem.attribs[name];
 };
 
-/**
- * Method for removing attributes by `name`.
- *
- * @example
- *
- * $('.pear').removeAttr('class').html()
- * //=> <li>Pear</li>
- *
- * @param {string} name - Name of the attribute.
- *
- * @see {@link http://api.jquery.com/removeAttr/}
- */
+
 exports.removeAttr = function(name) {
   domEach(this, function(i, elem) {
     removeAttribute(elem, name);
@@ -402,24 +319,6 @@ exports.removeAttr = function(name) {
   return this;
 };
 
-/**
- * Check to see if *any* of the matched elements have the given `className`.
- *
- * @example
- *
- * $('.pear').hasClass('pear')
- * //=> true
- *
- * $('apple').hasClass('fruit')
- * //=> false
- *
- * $('li').hasClass('pear')
- * //=> true
- *
- * @param {string} className - Name of the class.
- *
- * @see {@link http://api.jquery.com/hasClass/}
- */
 exports.hasClass = function(className) {
   return _.some(this, function(elem) {
     var attrs = elem.attribs,
@@ -428,13 +327,11 @@ exports.hasClass = function(className) {
         end;
 
     if (clazz && className.length) {
-      while ((idx = clazz.indexOf(className, idx + 1)) > -1) {
+      while ((idx = clazz.indexOf(className, idx+1)) > -1) {
         end = idx + className.length;
 
-        if (
-          (idx === 0 || rspace.test(clazz[idx - 1])) &&
-          (end === clazz.length || rspace.test(clazz[end]))
-        ) {
+        if ((idx === 0 || rspace.test(clazz[idx-1]))
+            && (end === clazz.length || rspace.test(clazz[end]))) {
           return true;
         }
       }
@@ -442,22 +339,6 @@ exports.hasClass = function(className) {
   });
 };
 
-/**
- * Adds class(es) to all of the matched elements. Also accepts a `function`
- * like jQuery.
- *
- * @example
- *
- * $('.pear').addClass('fruit').html()
- * //=> <li class="pear fruit">Pear</li>
- *
- * $('.apple').addClass('fruit red').html()
- * //=> <li class="apple fruit red">Apple</li>
- *
- * @param {string} value - Name of new class.
- *
- * @see {@link http://api.jquery.com/addClass/}
- */
 exports.addClass = function(value) {
   // Support functions
   if (typeof value === 'function') {
@@ -473,6 +354,7 @@ exports.addClass = function(value) {
   var classNames = value.split(rspace),
       numElements = this.length;
 
+
   for (var i = 0; i < numElements; i++) {
     // If selected element isn't a tag, move on
     if (!isTag(this[i])) continue;
@@ -491,7 +373,8 @@ exports.addClass = function(value) {
       // Check if class already exists
       for (var j = 0; j < numClasses; j++) {
         var appendClass = classNames[j] + ' ';
-        if (setClass.indexOf(' ' + appendClass) < 0) setClass += appendClass;
+        if (setClass.indexOf(' ' + appendClass) < 0)
+          setClass += appendClass;
       }
 
       setAttr(this[i], 'class', setClass.trim());
@@ -505,31 +388,16 @@ var splitClass = function(className) {
   return className ? className.trim().split(rspace) : [];
 };
 
-/**
- * Removes one or more space-separated classes from the selected elements. If
- * no `className` is defined, all classes will be removed. Also accepts a
- * `function` like jQuery.
- *
- * @example
- *
- * $('.pear').removeClass('pear').html()
- * //=> <li class="">Pear</li>
- *
- * $('.apple').addClass('red').removeClass().html()
- * //=> <li class="">Apple</li>
- * @param {string} value - Name of the class.
- *
- * @see {@link http://api.jquery.com/removeClass/}
- */
 exports.removeClass = function(value) {
-  var classes, numClasses, removeAll;
+  var classes,
+      numClasses,
+      removeAll;
 
   // Handle if value is a function
   if (typeof value === 'function') {
     return domEach(this, function(i, el) {
       exports.removeClass.call(
-        [el],
-        value.call(el, i, el.attribs['class'] || '')
+        [el], value.call(el, i, el.attribs['class'] || '')
       );
     });
   }
@@ -568,24 +436,6 @@ exports.removeClass = function(value) {
   });
 };
 
-/**
- * Add or remove class(es) from the matched elements, depending on either the
- * class's presence or the value of the switch argument. Also accepts a
- * `function` like jQuery.
- *
- * @example
- *
- * $('.apple.green').toggleClass('fruit green red').html()
- * //=> <li class="apple fruit red">Apple</li>
- *
- * $('.apple.green').toggleClass('fruit green red', true).html()
- * //=> <li class="apple green fruit red">Apple</li>
- *
- * @param {(string|Function)} value - Name of the class. Can also be a function.
- * @param {boolean} [stateVal] - If specified the state of the class.
- *
- * @see {@link http://api.jquery.com/toggleClass/}
- */
 exports.toggleClass = function(value, stateVal) {
   // Support functions
   if (typeof value === 'function') {
@@ -602,11 +452,11 @@ exports.toggleClass = function(value, stateVal) {
   if (!value || typeof value !== 'string') return this;
 
   var classNames = value.split(rspace),
-      numClasses = classNames.length,
-      state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0,
-      numElements = this.length,
-      elementClasses,
-      index;
+    numClasses = classNames.length,
+    state = typeof stateVal === 'boolean' ? stateVal ? 1 : -1 : 0,
+    numElements = this.length,
+    elementClasses,
+    index;
 
   for (var i = 0; i < numElements; i++) {
     // If selected element isn't a tag, move on
@@ -634,18 +484,7 @@ exports.toggleClass = function(value, stateVal) {
   return this;
 };
 
-/**
- * Checks the current list of elements and returns `true` if _any_ of the
- * elements match the selector. If using an element or Cheerio selection,
- * returns `true` if _any_ of the elements match. If using a predicate
- * function, the function is executed in the context of the selected element,
- * so `this` refers to the current element.
- *
- * @param {string|Function|cheerio|node} selector - Selector for the selection.
- *
- * @see {@link http://api.jquery.com/is/}
- */
-exports.is = function(selector) {
+exports.is = function (selector) {
   if (selector) {
     return this.filter(selector).length > 0;
   }
diff --git a/lib/api/css.js b/lib/api/css.js
index 990cb973b8..d9ffae6cfa 100644
--- a/lib/api/css.js
+++ b/lib/api/css.js
@@ -1,30 +1,23 @@
-/**
- * @module css
- */
 var domEach = require('../utils').domEach,
     _ = {
-      pick: require('lodash/pick')
+      pick: require('lodash/pick'),
     };
 
 var toString = Object.prototype.toString;
 
 /**
- * Get the value of a style property for the first element in the set of
- * matched elements or set one or more CSS properties for every matched
- * element.
+ * Set / Get css.
  *
- * @param {string|Object} prop - The name of the property.
- * @param {string} [val] - If specified the new value.
- * @returns {self}
- *
- * @see {@link http://api.jquery.com/css/}
+ * @param {String|Object} prop
+ * @param {String} val
+ * @return {self}
+ * @api public
  */
+
 exports.css = function(prop, val) {
-  if (
-    arguments.length === 2 ||
+  if (arguments.length === 2 ||
     // When `prop` is a "plain" object
-    toString.call(prop) === '[object Object]'
-  ) {
+    (toString.call(prop) === '[object Object]')) {
     return domEach(this, function(idx, el) {
       setCss(el, prop, val, idx);
     });
@@ -36,13 +29,13 @@ exports.css = function(prop, val) {
 /**
  * Set styles of all elements.
  *
- * @param {Object} el - Element to set style of.
- * @param {string|Object} prop - Name of property.
- * @param {string} val - Value to set property to.
- * @param {number} [idx] - Optional index within the selection.
- * @returns {self}
- * @private
+ * @param {String|Object} prop
+ * @param {String} val
+ * @param {Number} idx - optional index within the selection
+ * @return {self}
+ * @api private
  */
+
 function setCss(el, prop, val, idx) {
   if ('string' == typeof prop) {
     var styles = getCss(el);
@@ -58,7 +51,7 @@ function setCss(el, prop, val, idx) {
 
     el.attribs.style = stringify(styles);
   } else if ('object' == typeof prop) {
-    Object.keys(prop).forEach(function(k) {
+    Object.keys(prop).forEach(function(k){
       setCss(el, k, prop[k]);
     });
   }
@@ -67,11 +60,11 @@ function setCss(el, prop, val, idx) {
 /**
  * Get parsed styles of the first element.
  *
- * @param {node} el - Element to get styles from.
- * @param {string} prop - Name of the prop.
- * @returns {Object}
- * @private
+ * @param {String} prop
+ * @return {Object}
+ * @api private
  */
+
 function getCss(el, prop) {
   var styles = parse(el.attribs.style);
   if (typeof prop === 'string') {
@@ -86,33 +79,43 @@ function getCss(el, prop) {
 /**
  * Stringify `obj` to styles.
  *
- * @param {Object} obj - Object to stringify.
- * @returns {Object}
- * @private
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
  */
+
 function stringify(obj) {
-  return Object.keys(obj || {}).reduce(function(str, prop) {
-    return (str += '' + (str ? ' ' : '') + prop + ': ' + obj[prop] + ';');
-  }, '');
+  return Object.keys(obj || {})
+    .reduce(function(str, prop){
+      return str += ''
+        + (str ? ' ' : '')
+        + prop
+        + ': '
+        + obj[prop]
+        + ';';
+    }, '');
 }
 
 /**
  * Parse `styles`.
  *
- * @param {string} styles - Styles to be parsed.
- * @returns {Object}
- * @private
+ * @param {String} styles
+ * @return {Object}
+ * @api private
  */
+
 function parse(styles) {
   styles = (styles || '').trim();
 
   if (!styles) return {};
 
-  return styles.split(';').reduce(function(obj, str) {
-    var n = str.indexOf(':');
-    // skip if there is no :, or if it is the first/last character
-    if (n < 1 || n === str.length - 1) return obj;
-    obj[str.slice(0, n).trim()] = str.slice(n + 1).trim();
-    return obj;
-  }, {});
+  return styles
+    .split(';')
+    .reduce(function(obj, str){
+      var n = str.indexOf(':');
+      // skip if there is no :, or if it is the first/last character
+      if (n < 1 || n === str.length-1) return obj;
+      obj[str.slice(0,n).trim()] = str.slice(n+1).trim();
+      return obj;
+    }, {});
 }
diff --git a/lib/api/forms.js b/lib/api/forms.js
index ade2adaded..b66f162cd9 100644
--- a/lib/api/forms.js
+++ b/lib/api/forms.js
@@ -1,6 +1,3 @@
-/**
- * @module forms
- */
 // https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
 // https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
 var submittableSelector = 'input,select,textarea,keygen',
@@ -10,11 +7,6 @@ var submittableSelector = 'input,select,textarea,keygen',
       map: require('lodash/map')
     };
 
-/**
- * Encode a set of form elements as a string for submission.
- *
- * @see {@link http://api.jquery.com/serialize/}
- */
 exports.serialize = function() {
   // Convert form elements into name/value objects
   var arr = this.serializeArray();
@@ -28,37 +20,26 @@ exports.serialize = function() {
   return retArr.join('&').replace(r20, '+');
 };
 
-/**
- * Encode a set of form elements as an array of names and values.
- *
- * @example
- * $('<form><input name="foo" value="bar" /></form>').serializeArray()
- * //=> [ { name: 'foo', value: 'bar' } ]
- *
- * @see {@link http://api.jquery.com/serializeArray/}
- */
 exports.serializeArray = function() {
   // Resolve all form elements from either forms or collections of form elements
   var Cheerio = this.constructor;
   return this.map(function() {
-    var elem = this;
-    var $elem = Cheerio(elem);
-    if (elem.name === 'form') {
-      return $elem.find(submittableSelector).toArray();
-    } else {
-      return $elem.filter(submittableSelector).toArray();
-    }
-  })
-    .filter(
-      // Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
-      '[name!=""]:not(:disabled)' +
+      var elem = this;
+      var $elem = Cheerio(elem);
+      if (elem.name === 'form') {
+        return $elem.find(submittableSelector).toArray();
+      } else {
+        return $elem.filter(submittableSelector).toArray();
+      }
+    }).filter(
+        // Verify elements have a name (`attr.name`) and are not disabled (`:disabled`)
+        '[name!=""]:not(:disabled)'
         // and cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
-        ':not(:submit, :button, :image, :reset, :file)' +
+        + ':not(:submit, :button, :image, :reset, :file)'
         // and are either checked/don't have a checkable state
-        ':matches([checked], :not(:checkbox, :radio))'
-      // Convert each of the elements to its value(s)
-    )
-    .map(function(i, elem) {
+        + ':matches([checked], :not(:checkbox, :radio))'
+    // Convert each of the elements to its value(s)
+    ).map(function(i, elem) {
       var $elem = Cheerio(elem);
       var name = $elem.attr('name');
       var value = $elem.val();
@@ -73,13 +54,12 @@ exports.serializeArray = function() {
         return _.map(value, function(val) {
           // We trim replace any line endings (e.g. `\r` or `\r\n` with `\r\n`) to guarantee consistency across platforms
           //   These can occur inside of `<textarea>'s`
-          return { name: name, value: val.replace(rCRLF, '\r\n') };
+          return {name: name, value: val.replace( rCRLF, '\r\n' )};
         });
-        // Otherwise (e.g. `<input type="text">`, return only one key/value pair
+      // Otherwise (e.g. `<input type="text">`, return only one key/value pair
       } else {
-        return { name: name, value: value.replace(rCRLF, '\r\n') };
+        return {name: name, value: value.replace( rCRLF, '\r\n' )};
       }
-      // Convert our result to an array
-    })
-    .get();
+    // Convert our result to an array
+    }).get();
 };
diff --git a/lib/api/manipulation.js b/lib/api/manipulation.js
index fb47943648..09b9b43725 100644
--- a/lib/api/manipulation.js
+++ b/lib/api/manipulation.js
@@ -1,11 +1,5 @@
-/**
- * Methods for modifying the DOM structure.
- *
- * @module manipulation
- */
 var parse = require('../parse'),
-    html = require('../static').html,
-    text = require('../static').text,
+    $ = require('../static'),
     updateDOM = parse.update,
     evaluate = parse.evaluate,
     utils = require('../utils'),
@@ -19,27 +13,19 @@ var parse = require('../parse'),
       forEach: require('lodash/forEach')
     };
 
-/**
- * Create an array of nodes, recursing into arrays and parsing strings if
- * necessary.
- *
- * @param {cheerio|string|cheerio[]|string[]} [elem] - Elements to make an array of.
- * @param {boolean} [clone] - Optionally clone nodes.
- * @private
- */
+// Create an array of nodes, recursing into arrays and parsing strings if
+// necessary
 exports._makeDomArray = function makeDomArray(elem, clone) {
   if (elem == null) {
     return [];
   } else if (elem.cheerio) {
     return clone ? cloneDom(elem.get(), elem.options) : elem.get();
   } else if (Array.isArray(elem)) {
-    return _.flatten(
-      elem.map(function(el) {
-        return this._makeDomArray(el, clone);
-      }, this)
-    );
+    return _.flatten(elem.map(function(el) {
+      return this._makeDomArray(el, clone);
+    }, this));
   } else if (typeof elem === 'string') {
-    return evaluate(elem, this.options, false);
+    return evaluate(elem, this.options);
   } else {
     return clone ? cloneDom([elem]) : [elem];
   }
@@ -54,7 +40,7 @@ var _insert = function(concatenator) {
       var dom, domSrc;
 
       if (typeof elems[0] === 'function') {
-        domSrc = elems[0].call(el, i, html(el.children));
+        domSrc = elems[0].call(el, i, $.html(el.children));
       } else {
         domSrc = elems;
       }
@@ -74,7 +60,7 @@ var _insert = function(concatenator) {
  * @param {Number} spliceCount Number of elements to remove from the array.
  * @param {Array} newElems Elements to insert into the array.
  *
- * @private
+ * @api private
  */
 var uniqueSplice = function(array, spliceIdx, spliceCount, newElems, parent) {
   var spliceArgs = [spliceIdx, spliceCount].concat(newElems),
@@ -120,33 +106,9 @@ var uniqueSplice = function(array, spliceIdx, spliceCount, newElems, parent) {
   return array.splice.apply(array, spliceArgs);
 };
 
-/**
- * Insert every element in the set of matched elements to the end of the
- * target.
- *
- * @param {string|cheerio} target - Element to append elements to.
- *
- * @example
- *
- * $('<li class="plum">Plum</li>').appendTo('#fruits')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //      <li class="plum">Plum</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/appendTo/}
- */
 exports.appendTo = function(target) {
   if (!target.cheerio) {
-    target = this.constructor.call(
-      this.constructor,
-      target,
-      null,
-      this._originalRoot
-    );
+    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
   }
 
   target.append(this);
@@ -154,33 +116,9 @@ exports.appendTo = function(target) {
   return this;
 };
 
-/**
- * Insert every element in the set of matched elements to the beginning of the
- * target.
- *
- * @param {string|cheerio} target - Element to prepend elements to.
- *
- * @example
- *
- * $('<li class="plum">Plum</li>').prependTo('#fruits')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="plum">Plum</li>
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/prependTo/}
- */
 exports.prependTo = function(target) {
   if (!target.cheerio) {
-    target = this.constructor.call(
-      this.constructor,
-      target,
-      null,
-      this._originalRoot
-    );
+    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
   }
 
   target.prepend(this);
@@ -188,166 +126,65 @@ exports.prependTo = function(target) {
   return this;
 };
 
-/**
- * Inserts content as the *last* child of each of the selected elements.
- *
- * @method
- *
- * @example
- *
- * $('ul').append('<li class="plum">Plum</li>')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //      <li class="plum">Plum</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/append/}
- */
 exports.append = _insert(function(dom, children, parent) {
   uniqueSplice(children, children.length, 0, dom, parent);
 });
 
-/**
- * Inserts content as the *first* child of each of the selected elements.
- *
- * @method
- *
- * @example
- *
- * $('ul').prepend('<li class="plum">Plum</li>')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="plum">Plum</li>
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/prepend/}
- */
 exports.prepend = _insert(function(dom, children, parent) {
   uniqueSplice(children, 0, 0, dom, parent);
 });
 
-/**
- * The .wrap() function can take any string or object that could be passed to
- * the $() factory function to specify a DOM structure. This structure may be
- * nested several levels deep, but should contain only one inmost element. A
- * copy of this structure will be wrapped around each of the elements in the
- * set of matched elements. This method returns the original set of elements
- * for chaining purposes.
- *
- * @param {cheerio} wrapper - The DOM structure to wrap around each element in the selection.
- *
- * @example
- *
- * const redFruit = $('<div class="red-fruit"></div>')
- * $('.apple').wrap(redFruit)
- *
- * //=> <ul id="fruits">
- * //     <div class="red-fruit">
- * //      <li class="apple">Apple</li>
- * //     </div>
- * //     <li class="orange">Orange</li>
- * //     <li class="plum">Plum</li>
- * //   </ul>
- *
- * const healthy = $('<div class="healthy"></div>')
- * $('li').wrap(healthy)
- *
- * //=> <ul id="fruits">
- * //     <div class="healthy">
- * //       <li class="apple">Apple</li>
- * //     </div>
- * //     <div class="healthy">
- * //       <li class="orange">Orange</li>
- * //     </div>
- * //     <div class="healthy">
- * //        <li class="plum">Plum</li>
- * //     </div>
- * //   </ul>
- *
- * @see {@link http://api.jquery.com/wrap/}
- */
 exports.wrap = function(wrapper) {
   var wrapperFn = typeof wrapper === 'function' && wrapper,
       lastIdx = this.length - 1;
 
-  _.forEach(
-    this,
-    _.bind(function(el, i) {
-      var parent = el.parent || el.root,
-          siblings = parent.children,
-          wrapperDom,
-          elInsertLocation,
-          j,
-          index;
-
-      if (!parent) {
-        return;
-      }
+  _.forEach(this, _.bind(function(el, i) {
+    var parent = el.parent || el.root,
+        siblings = parent.children,
+        wrapperDom, elInsertLocation, j, index;
 
-      if (wrapperFn) {
-        wrapper = wrapperFn.call(el, i);
-      }
+    if (!parent) {
+      return;
+    }
+
+    if (wrapperFn) {
+      wrapper = wrapperFn.call(el, i);
+    }
+
+    if (typeof wrapper === 'string' && !isHtml(wrapper)) {
+      wrapper = this.parents().last().find(wrapper).clone();
+    }
+
+    wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
+    elInsertLocation = wrapperDom[0];
+    // Find the deepest child. Only consider the first tag child of each node
+    // (ignore text); stop if no children are found.
+    j = 0;
 
-      if (typeof wrapper === 'string' && !isHtml(wrapper)) {
-        wrapper = this.parents()
-          .last()
-          .find(wrapper)
-          .clone();
+    while (elInsertLocation && elInsertLocation.children) {
+      if (j >= elInsertLocation.children.length) {
+        break;
       }
 
-      wrapperDom = this._makeDomArray(wrapper, i < lastIdx).slice(0, 1);
-      elInsertLocation = wrapperDom[0];
-      // Find the deepest child. Only consider the first tag child of each node
-      // (ignore text); stop if no children are found.
-      j = 0;
-
-      while (elInsertLocation && elInsertLocation.children) {
-        if (j >= elInsertLocation.children.length) {
-          break;
-        }
-
-        if (elInsertLocation.children[j].type === 'tag') {
-          elInsertLocation = elInsertLocation.children[j];
-          j = 0;
-        } else {
-          j++;
-        }
+      if (elInsertLocation.children[j].type === 'tag') {
+        elInsertLocation = elInsertLocation.children[j];
+        j=0;
+      } else {
+        j++;
       }
-      index = siblings.indexOf(el);
+    }
+    index = siblings.indexOf(el);
 
-      updateDOM([el], elInsertLocation);
-      // The previous operation removed the current element from the `siblings`
-      // array, so the `dom` array can be inserted without removing any
-      // additional elements.
-      uniqueSplice(siblings, index, 0, wrapperDom, parent);
-    }, this)
-  );
+    updateDOM([el], elInsertLocation);
+    // The previous operation removed the current element from the `siblings`
+    // array, so the `dom` array can be inserted without removing any
+    // additional elements.
+    uniqueSplice(siblings, index, 0, wrapperDom, parent);
+  }, this));
 
   return this;
 };
 
-/**
- * Insert content next to each element in the set of matched elements.
- *
- * @example
- *
- * $('.apple').after('<li class="plum">Plum</li>')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="apple">Apple</li>
- * //      <li class="plum">Plum</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/after/}
- */
 exports.after = function() {
   var elems = slice.call(arguments),
       lastIdx = this.length - 1;
@@ -360,14 +197,13 @@ exports.after = function() {
 
     var siblings = parent.children,
         index = siblings.indexOf(el),
-        domSrc,
-        dom;
+        domSrc, dom;
 
     // If not found, move on
     if (index < 0) return;
 
     if (typeof elems[0] === 'function') {
-      domSrc = elems[0].call(el, i, html(el.children));
+      domSrc = elems[0].call(el, i, $.html(el.children));
     } else {
       domSrc = elems;
     }
@@ -380,34 +216,11 @@ exports.after = function() {
   return this;
 };
 
-/**
- * Insert every element in the set of matched elements after the target.
- *
- * @example
- *
- * $('<li class="plum">Plum</li>').insertAfter('.apple')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="apple">Apple</li>
- * //      <li class="plum">Plum</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @param {string|cheerio} target - Element to insert elements after.
- *
- * @see {@link http://api.jquery.com/insertAfter/}
- */
 exports.insertAfter = function(target) {
   var clones = [],
       self = this;
   if (typeof target === 'string') {
-    target = this.constructor.call(
-      this.constructor,
-      target,
-      null,
-      this._originalRoot
-    );
+    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
   }
   target = this._makeDomArray(target);
   self.remove();
@@ -431,22 +244,6 @@ exports.insertAfter = function(target) {
   return this.constructor.call(this.constructor, this._makeDomArray(clones));
 };
 
-/**
- * Insert content previous to each element in the set of matched elements.
- *
- * @example
- *
- * $('.apple').before('<li class="plum">Plum</li>')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="plum">Plum</li>
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @see {@link http://api.jquery.com/before/}
- */
 exports.before = function() {
   var elems = slice.call(arguments),
       lastIdx = this.length - 1;
@@ -459,14 +256,13 @@ exports.before = function() {
 
     var siblings = parent.children,
         index = siblings.indexOf(el),
-        domSrc,
-        dom;
+        domSrc, dom;
 
     // If not found, move on
     if (index < 0) return;
 
     if (typeof elems[0] === 'function') {
-      domSrc = elems[0].call(el, i, html(el.children));
+      domSrc = elems[0].call(el, i, $.html(el.children));
     } else {
       domSrc = elems;
     }
@@ -480,34 +276,11 @@ exports.before = function() {
   return this;
 };
 
-/**
- * Insert every element in the set of matched elements before the target.
- *
- * @example
- *
- * $('<li class="plum">Plum</li>').insertBefore('.apple')
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="plum">Plum</li>
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //      <li class="pear">Pear</li>
- * //    </ul>
- *
- * @param {string|cheerio} target - Element to insert elements before.
- *
- * @see {@link http://api.jquery.com/insertBefore/}
- */
 exports.insertBefore = function(target) {
   var clones = [],
       self = this;
   if (typeof target === 'string') {
-    target = this.constructor.call(
-      this.constructor,
-      target,
-      null,
-      this._originalRoot
-    );
+    target = this.constructor.call(this.constructor, target, null, this._originalRoot);
   }
   target = this._makeDomArray(target);
   self.remove();
@@ -531,28 +304,15 @@ exports.insertBefore = function(target) {
   return this.constructor.call(this.constructor, this._makeDomArray(clones));
 };
 
-/**
- * Removes the set of matched elements from the DOM and all their children.
- * `selector` filters the set of matched elements to be removed.
- *
- * @example
- *
- * $('.pear').remove()
- * $.html()
- * //=>  <ul id="fruits">
- * //      <li class="apple">Apple</li>
- * //      <li class="orange">Orange</li>
- * //    </ul>
- *
- * @param {string} [selector] - Optional selector for elements to remove.
- *
- * @see {@link http://api.jquery.com/remove/}
- */
+/*
+  remove([selector])
+*/
 exports.remove = function(selector) {
   var elems = this;
 
   // Filter if we have selector
-  if (selector) elems = elems.filter(selector);
+  if (selector)
+    elems = elems.filter(selector);
 
   domEach(elems, function(i, el) {
     var parent = el.parent || el.root;
@@ -578,24 +338,6 @@ exports.remove = function(selector) {
   return this;
 };
 
-/**
- * Replaces matched elements with `content`.
- *
- * @example
- *
- * const plum = $('<li class="plum">Plum</li>')
- * $('.pear').replaceWith(plum)
- * $.html()
- * //=> <ul id="fruits">
- * //     <li class="apple">Apple</li>
- * //     <li class="orange">Orange</li>
- * //     <li class="plum">Plum</li>
- * //   </ul>
- *
- * @param {cheerio|Function} content - Replacement for matched elements.
- *
- * @see {@link http://api.jquery.com/replaceWith/}
- */
 exports.replaceWith = function(content) {
   var self = this;
 
@@ -606,9 +348,7 @@ exports.replaceWith = function(content) {
     }
 
     var siblings = parent.children,
-        dom = self._makeDomArray(
-          typeof content === 'function' ? content.call(el, i, el) : content
-        ),
+        dom = self._makeDomArray(typeof content === 'function' ? content.call(el, i, el) : content),
         index;
 
     // In the case that `dom` contains nodes that already exist in other
@@ -625,17 +365,6 @@ exports.replaceWith = function(content) {
   return this;
 };
 
-/**
- * Empties an element, removing all its children.
- *
- * @example
- *
- * $('ul').empty()
- * $.html()
- * //=>  <ul id="fruits"></ul>
- *
- * @see {@link http://api.jquery.com/empty/}
- */
 exports.empty = function() {
   domEach(this, function(i, el) {
     _.forEach(el.children, function(child) {
@@ -648,26 +377,12 @@ exports.empty = function() {
 };
 
 /**
- * Gets an HTML content string from the first selected element. If `htmlString`
- * is specified, each selected element's content is replaced by the new
- * content.
- *
- * @param {string} str - If specified used to replace selection's contents.
- *
- * @example
- *
- * $('.orange').html()
- * //=> Orange
- *
- * $('#fruits').html('<li class="mango">Mango</li>').html()
- * //=> <li class="mango">Mango</li>
- *
- * @see {@link http://api.jquery.com/html/}
+ * Set/Get the HTML
  */
 exports.html = function(str) {
   if (str === undefined) {
     if (!this[0] || !this[0].children) return null;
-    return html(this[0].children, this.options);
+    return $.html(this[0].children, this.options);
   }
 
   var opts = this.options;
@@ -677,9 +392,7 @@ exports.html = function(str) {
       child.next = child.prev = child.parent = null;
     });
 
-    var content = str.cheerio
-      ? str.clone().get()
-      : evaluate('' + str, opts, false);
+    var content = str.cheerio ? str.clone().get() : evaluate('' + str, opts);
 
     updateDOM(content, el);
   });
@@ -688,66 +401,42 @@ exports.html = function(str) {
 };
 
 exports.toString = function() {
-  return html(this, this.options);
+  return $.html(this, this.options);
 };
 
-/**
- * Get the combined text contents of each element in the set of matched
- * elements, including their descendants. If `textString` is specified, each
- * selected element's content is replaced by the new text content.
- *
- * @param {string} [str] - If specified replacement for the selected element's contents.
- *
- * @example
- *
- * $('.orange').text()
- * //=> Orange
- *
- * $('ul').text()
- * //=>  Apple
- * //    Orange
- * //    Pear
- *
- * @see {@link http://api.jquery.com/text/}
- */
 exports.text = function(str) {
   // If `str` is undefined, act as a "getter"
   if (str === undefined) {
-    return text(this);
+    return $.text(this);
   } else if (typeof str === 'function') {
     // Function support
-    var self = this;
     return domEach(this, function(i, el) {
-      return exports.text.call(self._make(el), str.call(el, i, text([el])));
+      var $el = [el];
+      return exports.text.call($el, str.call(el, i, $.text($el)));
     });
   }
 
-  var opts = this.options;
-
   // Append text node to each selected elements
   domEach(this, function(i, el) {
     _.forEach(el.children, function(child) {
       child.next = child.prev = child.parent = null;
     });
 
-    var textNode = evaluate(' ', opts)[0];
-    textNode.data = str;
+    var elem = {
+      data: '' + str,
+      type: 'text',
+      parent: el,
+      prev: null,
+      next: null,
+      children: []
+    };
 
-    updateDOM(textNode, el);
+    updateDOM(elem, el);
   });
 
   return this;
 };
 
-/**
- * Clone the cheerio object.
- *
- * @example
- *
- * const moreFruit = $('#fruits').clone()
- *
- * @see {@link http://api.jquery.com/clone/}
- */
 exports.clone = function() {
   return this._make(cloneDom(this.get(), this.options));
 };
diff --git a/lib/api/traversing.js b/lib/api/traversing.js
index 2ee1d84477..6722361d1a 100644
--- a/lib/api/traversing.js
+++ b/lib/api/traversing.js
@@ -1,8 +1,3 @@
-/**
- * Methods for traversing the DOM structure.
- *
- * @module traversing
- */
 var select = require('css-select'),
     utils = require('../utils'),
     domEach = utils.domEach,
@@ -16,29 +11,10 @@ var select = require('css-select'),
       reduce: require('lodash/reduce')
     };
 
-/**
- * Get the descendants of each element in the current set of matched elements,
- * filtered by a selector, jQuery object, or element.
- *
- * @example
- *
- * $('#fruits').find('li').length
- * //=> 3
- * $('#fruits').find($('.apple')).length
- * //=> 1
- *
- * @param {string|cheerio|node} selectorOrHaystack  - Element to look for.
- *
- * @see {@link http://api.jquery.com/find/}
- */
 exports.find = function(selectorOrHaystack) {
-  var elems = _.reduce(
-    this,
-    function(memo, elem) {
-      return memo.concat(_.filter(elem.children, isTag));
-    },
-    []
-  );
+  var elems = _.reduce(this, function(memo, elem) {
+    return memo.concat(_.filter(elem.children, isTag));
+  }, []);
   var contains = this.constructor.contains;
   var haystack;
 
@@ -49,36 +25,23 @@ exports.find = function(selectorOrHaystack) {
       haystack = [selectorOrHaystack];
     }
 
-    return this._make(
-      haystack.filter(function(elem) {
-        var idx, len;
-        for (idx = 0, len = this.length; idx < len; ++idx) {
-          if (contains(this[idx], elem)) {
-            return true;
-          }
+    return this._make(haystack.filter(function(elem) {
+      var idx, len;
+      for (idx = 0, len = this.length; idx < len; ++idx) {
+        if (contains(this[idx], elem)) {
+          return true;
         }
-      }, this)
-    );
+      }
+    }, this));
   }
 
-  var options = { __proto__: this.options, context: this.toArray() };
+  var options = {__proto__: this.options, context: this.toArray()};
 
   return this._make(select(selectorOrHaystack, elems, options));
 };
 
-/**
- * Get the parent of each element in the current set of matched elements,
- * optionally filtered by a selector.
- *
- * @example
- *
- * $('.pear').parent().attr('id')
- * //=> fruits
- *
- * @param {string} [selector] - If specified filter for parent.
- *
- * @see {@link http://api.jquery.com/parent/}
- */
+// Get the parent of each element in the current set of matched elements,
+// optionally filtered by a selector.
 exports.parent = function(selector) {
   var set = [];
 
@@ -96,61 +59,27 @@ exports.parent = function(selector) {
   return this._make(set);
 };
 
-/**
- * Get a set of parents filtered by `selector` of each element in the current
- * set of match elements.
- *
- * @example
- *
- * $('.orange').parents().length
- * // => 2
- * $('.orange').parents('#fruits').length
- * // => 1
- *
- * @param {string} [selector] - If specified filter for parents.
- *
- * @see {@link http://api.jquery.com/parents/}
- */
 exports.parents = function(selector) {
   var parentNodes = [];
 
   // When multiple DOM elements are in the original set, the resulting set will
   // be in *reverse* order of the original elements as well, with duplicates
   // removed.
-  this.get()
-    .reverse()
-    .forEach(function(elem) {
-      traverseParents(this, elem.parent, selector, Infinity).forEach(function(
-        node
-      ) {
+  this.get().reverse().forEach(function(elem) {
+    traverseParents(this, elem.parent, selector, Infinity)
+      .forEach(function(node) {
         if (parentNodes.indexOf(node) === -1) {
           parentNodes.push(node);
         }
-      });
-    }, this);
+      }
+    );
+  }, this);
 
   return this._make(parentNodes);
 };
 
-/**
- * Get the ancestors of each element in the current set of matched elements, up
- * to but not including the element matched by the selector, DOM node, or
- * cheerio object.
- *
- * @example
- *
- * $('.orange').parentsUntil('#food').length
- * // => 1
- *
- * @param {string|node|cheerio} selector - Selector for element to stop at.
- * @param {string|Function} [filter] - Optional filter for parents.
- *
- * @see {@link http://api.jquery.com/parentsUntil/}
- */
 exports.parentsUntil = function(selector, filter) {
-  var parentNodes = [],
-      untilNode,
-      untilNodes;
+  var parentNodes = [], untilNode, untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.parents().toArray(), this.options)[0];
@@ -164,49 +93,24 @@ exports.parentsUntil = function(selector, filter) {
   // be in *reverse* order of the original elements as well, with duplicates
   // removed.
 
-  this.toArray()
-    .reverse()
-    .forEach(function(elem) {
-      while ((elem = elem.parent)) {
-        if (
-          (untilNode && elem !== untilNode) ||
-          (untilNodes && untilNodes.indexOf(elem) === -1) ||
-          (!untilNode && !untilNodes)
-        ) {
-          if (isTag(elem) && parentNodes.indexOf(elem) === -1) {
-            parentNodes.push(elem);
-          }
-        } else {
-          break;
-        }
+  this.toArray().reverse().forEach(function(elem) {
+    while ((elem = elem.parent)) {
+      if ((untilNode && elem !== untilNode) ||
+        (untilNodes && untilNodes.indexOf(elem) === -1) ||
+        (!untilNode && !untilNodes)) {
+        if (isTag(elem) && parentNodes.indexOf(elem) === -1) { parentNodes.push(elem); }
+      } else {
+        break;
       }
-    }, this);
+    }
+  }, this);
 
-  return this._make(
-    filter ? select(filter, parentNodes, this.options) : parentNodes
-  );
+  return this._make(filter ? select(filter, parentNodes, this.options) : parentNodes);
 };
 
-/**
- * For each element in the set, get the first element that matches the selector
- * by testing the element itself and traversing up through its ancestors in
- * the DOM tree.
- *
- * @example
- *
- * $('.orange').closest()
- * // => []
- * $('.orange').closest('.apple')
- * // => []
- * $('.orange').closest('li')
- * // => [<li class="orange">Orange</li>]
- * $('.orange').closest('#fruits')
- * // => [<ul id="fruits"> ... </ul>]
- *
- * @param {string} [selector] - Selector for the element to find.
- *
- * @see {@link http://api.jquery.com/closest/}
- */
+// For each element in the set, get the first element that matches the selector
+// by testing the element itself and traversing up through its ancestors in the
+// DOM tree.
 exports.closest = function(selector) {
   var set = [];
 
@@ -214,38 +118,20 @@ exports.closest = function(selector) {
     return this._make(set);
   }
 
-  domEach(
-    this,
-    function(idx, elem) {
-      var closestElem = traverseParents(this, elem, selector, 1)[0];
+  domEach(this, function(idx, elem) {
+    var closestElem = traverseParents(this, elem, selector, 1)[0];
 
-      // Do not add duplicate elements to the set
-      if (closestElem && set.indexOf(closestElem) < 0) {
-        set.push(closestElem);
-      }
-    }.bind(this)
-  );
+    // Do not add duplicate elements to the set
+    if (closestElem && set.indexOf(closestElem) < 0) {
+      set.push(closestElem);
+    }
+  }.bind(this));
 
   return this._make(set);
 };
 
-/**
- * Gets the next sibling of the first selected element, optionally filtered by
- * a selector.
- *
- * @example
- *
- * $('.apple').next().hasClass('orange')
- * //=> true
- *
- * @param {string} [selector] - If specified filter for sibling.
- *
- * @see {@link http://api.jquery.com/next/}
- */
 exports.next = function(selector) {
-  if (!this[0]) {
-    return this;
-  }
+  if (!this[0]) { return this; }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -257,30 +143,13 @@ exports.next = function(selector) {
     }
   });
 
-  return selector
-    ? exports.filter.call(elems, selector, this)
-    : this._make(elems);
+  return selector ?
+    exports.filter.call(elems, selector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets all the following siblings of the first selected element, optionally
- * filtered by a selector.
- *
- * @example
- *
- * $('.apple').nextAll()
- * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
- * $('.apple').nextAll('.orange')
- * //=> [<li class="orange">Orange</li>]
- *
- * @param {string} [selector] - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/nextAll/}
- */
 exports.nextAll = function(selector) {
-  if (!this[0]) {
-    return this;
-  }
+  if (!this[0]) { return this; }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -291,32 +160,14 @@ exports.nextAll = function(selector) {
     }
   });
 
-  return selector
-    ? exports.filter.call(elems, selector, this)
-    : this._make(elems);
+  return selector ?
+    exports.filter.call(elems, selector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets all the following siblings up to but not including the element matched
- * by the selector, optionally filtered by another selector.
- *
- * @example
- *
- * $('.apple').nextUntil('.pear')
- * //=> [<li class="orange">Orange</li>]
- *
- * @param {string|cheerio|node} selector - Selector for element to stop at.
- * @param {string} [filterSelector]  - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/nextUntil/}
- */
 exports.nextUntil = function(selector, filterSelector) {
-  if (!this[0]) {
-    return this;
-  }
-  var elems = [],
-      untilNode,
-      untilNodes;
+  if (!this[0]) { return this; }
+  var elems = [], untilNode, untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.nextAll().get(), this.options)[0];
@@ -328,11 +179,9 @@ exports.nextUntil = function(selector, filterSelector) {
 
   _.forEach(this, function(elem) {
     while ((elem = elem.next)) {
-      if (
-        (untilNode && elem !== untilNode) ||
+      if ((untilNode && elem !== untilNode) ||
         (untilNodes && untilNodes.indexOf(elem) === -1) ||
-        (!untilNode && !untilNodes)
-      ) {
+        (!untilNode && !untilNodes)) {
         if (isTag(elem) && elems.indexOf(elem) === -1) {
           elems.push(elem);
         }
@@ -342,28 +191,13 @@ exports.nextUntil = function(selector, filterSelector) {
     }
   });
 
-  return filterSelector
-    ? exports.filter.call(elems, filterSelector, this)
-    : this._make(elems);
+  return filterSelector ?
+    exports.filter.call(elems, filterSelector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets the previous sibling of the first selected element optionally filtered
- * by a selector.
- *
- * @example
- *
- * $('.orange').prev().hasClass('apple')
- * //=> true
- *
- * @param {string} [selector]  - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/prev/}
- */
 exports.prev = function(selector) {
-  if (!this[0]) {
-    return this;
-  }
+  if (!this[0]) { return this; }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -375,30 +209,13 @@ exports.prev = function(selector) {
     }
   });
 
-  return selector
-    ? exports.filter.call(elems, selector, this)
-    : this._make(elems);
+  return selector ?
+    exports.filter.call(elems, selector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets all the preceding siblings of the first selected element, optionally
- * filtered by a selector.
- *
- * @example
- *
- * $('.pear').prevAll()
- * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
- * $('.pear').prevAll('.orange')
- * //=> [<li class="orange">Orange</li>]
- *
- * @param {string} [selector]  - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/prevAll/}
- */
 exports.prevAll = function(selector) {
-  if (!this[0]) {
-    return this;
-  }
+  if (!this[0]) { return this; }
   var elems = [];
 
   _.forEach(this, function(elem) {
@@ -409,32 +226,14 @@ exports.prevAll = function(selector) {
     }
   });
 
-  return selector
-    ? exports.filter.call(elems, selector, this)
-    : this._make(elems);
+  return selector ?
+    exports.filter.call(elems, selector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets all the preceding siblings up to but not including the element matched
- * by the selector, optionally filtered by another selector.
- *
- * @example
- *
- * $('.pear').prevUntil('.apple')
- * //=> [<li class="orange">Orange</li>]
- *
- * @param {string|cheerio|node} selector - Selector for element to stop at.
- * @param {string} [filterSelector]  - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/prevUntil/}
- */
 exports.prevUntil = function(selector, filterSelector) {
-  if (!this[0]) {
-    return this;
-  }
-  var elems = [],
-      untilNode,
-      untilNodes;
+  if (!this[0]) { return this; }
+  var elems = [], untilNode, untilNodes;
 
   if (typeof selector === 'string') {
     untilNode = select(selector, this.prevAll().get(), this.options)[0];
@@ -446,11 +245,9 @@ exports.prevUntil = function(selector, filterSelector) {
 
   _.forEach(this, function(elem) {
     while ((elem = elem.prev)) {
-      if (
-        (untilNode && elem !== untilNode) ||
+      if ((untilNode && elem !== untilNode) ||
         (untilNodes && untilNodes.indexOf(elem) === -1) ||
-        (!untilNode && !untilNodes)
-      ) {
+        (!untilNode && !untilNodes)) {
         if (isTag(elem) && elems.indexOf(elem) === -1) {
           elems.push(elem);
         }
@@ -460,34 +257,17 @@ exports.prevUntil = function(selector, filterSelector) {
     }
   });
 
-  return filterSelector
-    ? exports.filter.call(elems, filterSelector, this)
-    : this._make(elems);
+  return filterSelector ?
+    exports.filter.call(elems, filterSelector, this) :
+    this._make(elems);
 };
 
-/**
- * Gets the first selected element's siblings, excluding itself.
- *
- * @example
- *
- * $('.pear').siblings().length
- * //=> 2
- *
- * $('.pear').siblings('.orange').length
- * //=> 1
- *
- * @param {string} [selector]  - If specified filter for siblings.
- *
- * @see {@link http://api.jquery.com/siblings/}
- */
 exports.siblings = function(selector) {
   var parent = this.parent();
 
   var elems = _.filter(
     parent ? parent.children() : this.siblingsAndMe(),
-    _.bind(function(elem) {
-      return isTag(elem) && !this.is(elem);
-    }, this)
+    _.bind(function(elem) { return isTag(elem) && !this.is(elem); }, this)
   );
 
   if (selector !== undefined) {
@@ -497,119 +277,35 @@ exports.siblings = function(selector) {
   }
 };
 
-/**
- * Gets the children of the first selected element.
- *
- * @example
- *
- * $('#fruits').children().length
- * //=> 3
- *
- * $('#fruits').children('.pear').text()
- * //=> Pear
- *
- * @param {string} [selector]  - If specified filter for children.
- *
- * @see {@link http://api.jquery.com/children/}
- */
 exports.children = function(selector) {
-  var elems = _.reduce(
-    this,
-    function(memo, elem) {
-      return memo.concat(_.filter(elem.children, isTag));
-    },
-    []
-  );
+
+  var elems = _.reduce(this, function(memo, elem) {
+    return memo.concat(_.filter(elem.children, isTag));
+  }, []);
 
   if (selector === undefined) return this._make(elems);
 
   return exports.filter.call(elems, selector, this);
 };
 
-/**
- * Gets the children of each element in the set of matched elements, including
- * text and comment nodes.
- *
- * @example
- *
- * $('#fruits').contents().length
- * //=> 3
- *
- * @see {@link http://api.jquery.com/contents/}
- */
 exports.contents = function() {
-  return this._make(
-    _.reduce(
-      this,
-      function(all, elem) {
-        all.push.apply(all, elem.children);
-        return all;
-      },
-      []
-    )
-  );
+  return this._make(_.reduce(this, function(all, elem) {
+    all.push.apply(all, elem.children);
+    return all;
+  }, []));
 };
 
-/**
- * Iterates over a cheerio object, executing a function for each matched
- * element. When the callback is fired, the function is fired in the context of
- * the DOM element, so `this` refers to the current element, which is
- * equivalent to the function parameter `element`. To break out of the `each`
- * loop early, return with `false`.
- *
- * @example
- *
- * const fruits = [];
- *
- * $('li').each(function(i, elem) {
- *   fruits[i] = $(this).text();
- * });
- *
- * fruits.join(', ');
- * //=> Apple, Orange, Pear
- *
- * @param {Function} fn  - Function to execute.
- *
- * @see {@link http://api.jquery.com/each/}
- */
 exports.each = function(fn) {
-  var i = 0,
-      len = this.length;
+  var i = 0, len = this.length;
   while (i < len && fn.call(this[i], i, this[i]) !== false) ++i;
   return this;
 };
 
-/**
- * Pass each element in the current matched set through a function, producing a
- * new Cheerio object containing the return values. The function can return an
- * individual data item or an array of data items to be inserted into the
- * resulting set. If an array is returned, the elements inside the array are
- * inserted into the set. If the function returns null or undefined, no element
- * will be inserted.
- *
- * @example
- *
- * $('li').map(function(i, el) {
- *   // this === el
- *   return $(this).text();
- * }).get().join(' ');
- * //=> "apple orange pear"
- *
- * @param {Function} fn  - Function to execute.
- *
- * @see {@link http://api.jquery.com/map/}
- */
 exports.map = function(fn) {
-  return this._make(
-    _.reduce(
-      this,
-      function(memo, el, i) {
-        var val = fn.call(el, i, el);
-        return val == null ? memo : memo.concat(val);
-      },
-      []
-    )
-  );
+  return this._make(_.reduce(this, function(memo, el, i) {
+    var val = fn.call(el, i, el);
+    return val == null ? memo : memo.concat(val);
+  }, []));
 };
 
 var makeFilterMethod = function(filterFn) {
@@ -635,82 +331,9 @@ var makeFilterMethod = function(filterFn) {
   };
 };
 
-/**
- * Iterates over a cheerio object, reducing the set of selector elements to
- * those that match the selector or pass the function's test. When a Cheerio
- * selection is specified, return only the elements contained in that
- * selection. When an element is specified, return only that element (if it is
- * contained in the original selection). If using the function method, the
- * function is executed in the context of the selected element, so `this`
- * refers to the current element.
- *
- * @method
- *
- * @example <caption>Selector</caption>
- *
- * $('li').filter('.orange').attr('class');
- * //=> orange
- *
- * @example <caption>Function</caption>
- *
- * $('li').filter(function(i, el) {
- *   // this === el
- *   return $(this).attr('class') === 'orange';
- * }).attr('class')
- * //=> orange
- *
- * @see {@link http://api.jquery.com/filter/}
- */
 exports.filter = makeFilterMethod(_.filter);
-
-/**
- * Remove elements from the set of matched elements. Given a jQuery object that
- * represents a set of DOM elements, the `.not()` method constructs a new
- * jQuery object from a subset of the matching elements. The supplied selector
- * is tested against each element; the elements that don't match the selector
- * will be included in the result. The `.not()` method can take a function as
- * its argument in the same way that `.filter()` does. Elements for which the
- * function returns true are excluded from the filtered set; all other elements
- * are included.
- *
- * @method
- *
- * @example <caption>Selector</caption>
- *
- * $('li').not('.apple').length;
- * //=> 2
- *
- * @example <caption>Function</caption>
- *
- * $('li').not(function(i, el) {
- *   // this === el
- *   return $(this).attr('class') === 'orange';
- * }).length;
- * //=> 2
- *
- * @see {@link http://api.jquery.com/not/}
- */
 exports.not = makeFilterMethod(_.reject);
 
-/**
- * Filters the set of matched elements to only those which have the given DOM
- * element as a descendant or which have a descendant that matches the given
- * selector. Equivalent to `.filter(':has(selector)')`.
- *
- * @example <caption>Selector</caption>
- *
- * $('ul').has('.pear').attr('id');
- * //=> fruits
- *
- * @example <caption>Element</caption>
- *
- * $('ul').has($('.pear')[0]).attr('id');
- * //=> fruits
- *
- * @param {string|cheerio|node} selectorOrHaystack  - Element to look for.
- *
- * @see {@link http://api.jquery.com/has/}
- */
 exports.has = function(selectorOrHaystack) {
   var that = this;
   return exports.filter.call(this, function() {
@@ -718,50 +341,15 @@ exports.has = function(selectorOrHaystack) {
   });
 };
 
-/**
- * Will select the first element of a cheerio object.
- *
- * @example
- *
- * $('#fruits').children().first().text()
- * //=> Apple
- *
- * @see {@link http://api.jquery.com/first/}
- */
 exports.first = function() {
   return this.length > 1 ? this._make(this[0]) : this;
 };
 
-/**
- * Will select the last element of a cheerio object.
- *
- * @example
- *
- * $('#fruits').children().last().text()
- * //=> Pear
- *
- * @see {@link http://api.jquery.com/last/}
- */
 exports.last = function() {
   return this.length > 1 ? this._make(this[this.length - 1]) : this;
 };
 
-/**
- * Reduce the set of matched elements to the one at the specified index. Use
- * `.eq(-i)` to count backwards from the last selected element.
- *
- * @example
- *
- * $('li').eq(0).text()
- * //=> Apple
- *
- * $('li').eq(-1).text()
- * //=> Pear
- *
- * @param {number} i - Index of the element to select.
- *
- * @see {@link http://api.jquery.com/eq/}
- */
+// Reduce the set of matched elements to the one at the specified index.
 exports.eq = function(i) {
   i = +i;
 
@@ -772,50 +360,16 @@ exports.eq = function(i) {
   return this[i] ? this._make(this[i]) : this._make([]);
 };
 
-/**
- * Retrieve the DOM elements matched by the Cheerio object. If an index is
- * specified, retrieve one of the elements matched by the Cheerio object.
- *
- * @example
- *
- * $('li').get(0).tagName
- * //=> li
- *
- * If no index is specified, retrieve all elements matched by the Cheerio object:
- *
- * @example
- *
- * $('li').get().length
- * //=> 3
- *
- * @param {number} [i] - Element to retrieve.
- *
- * @see {@link http://api.jquery.com/get/}
- */
+// Retrieve the DOM elements matched by the jQuery object.
 exports.get = function(i) {
   if (i == null) {
     return Array.prototype.slice.call(this);
   } else {
-    return this[i < 0 ? this.length + i : i];
+    return this[i < 0 ? (this.length + i) : i];
   }
 };
 
-/**
- * Search for a given element from among the matched elements.
- *
- * @example
- *
- * $('.pear').index()
- * //=> 2
- * $('.orange').index('li')
- * //=> 1
- * $('.apple').index($('#fruit, li'))
- * //=> 1
- *
- * @param {string|cheerio|node} [selectorOrNeedle]  - Element to look for.
- *
- * @see {@link http://api.jquery.com/index/}
- */
+// Search for a given element from among the matched elements.
 exports.index = function(selectorOrNeedle) {
   var $haystack, needle;
 
@@ -833,19 +387,6 @@ exports.index = function(selectorOrNeedle) {
   return $haystack.get().indexOf(needle);
 };
 
-/**
- * Gets the elements matching the specified range.
- *
- * @example
- *
- * $('li').slice(1).eq(0).text()
- * //=> 'Orange'
- *
- * $('li').slice(1, 2).length
- * //=> 1
- *
- * @see {@link http://api.jquery.com/slice/}
- */
 exports.slice = function() {
   return this._make([].slice.apply(this, arguments));
 };
@@ -861,34 +402,12 @@ function traverseParents(self, elem, selector, limit) {
   return elems;
 }
 
-/**
- * End the most recent filtering operation in the current chain and return the
- * set of matched elements to its previous state.
- *
- * @example
- *
- * $('li').eq(0).end().length
- * //=> 3
- *
- * @see {@link http://api.jquery.com/end/}
- */
+// End the most recent filtering operation in the current chain and return the
+// set of matched elements to its previous state.
 exports.end = function() {
   return this.prevObject || this._make([]);
 };
 
-/**
- * Add elements to the set of matched elements.
- *
- * @example
- *
- * $('.apple').add('.orange').length
- * //=> 2
- *
- * @param {string|cheerio} other - Elements to add.
- * @param {cheerio} [context] - Optionally the context of the new selection.
- *
- * @see {@link http://api.jquery.com/add/}
- */
 exports.add = function(other, context) {
   var selection = this._make(other, context);
   var contents = uniqueSort(selection.get().concat(this.get()));
@@ -901,19 +420,8 @@ exports.add = function(other, context) {
   return selection;
 };
 
-/**
- * Add the previous set of elements on the stack to the current set, optionally
- * filtered by a selector.
- *
- * @example
- *
- * $('li').eq(0).addBack('.orange').length
- * //=> 2
- *
- * @param {string} selector - Selector for the elements to add.
- *
- * @see {@link http://api.jquery.com/addBack/}
- */
+// Add the previous set of elements on the stack to the current set, optionally
+// filtered by a selector.
 exports.addBack = function(selector) {
   return this.add(
     arguments.length ? this.prevObject.filter(selector) : this.prevObject
diff --git a/lib/cheerio.js b/lib/cheerio.js
index e742567e76..a4195104e2 100644
--- a/lib/cheerio.js
+++ b/lib/cheerio.js
@@ -1,11 +1,8 @@
-/*global Symbol*/
 /*
   Module dependencies
 */
 
 var parse = require('./parse'),
-    defaultOptions = require('./options').default,
-    flattenOptions = require('./options').flatten,
     isHtml = require('./utils').isHtml,
     _ = {
       extend: require('lodash/assignIn'),
@@ -17,6 +14,7 @@ var parse = require('./parse'),
 /*
  * The API
  */
+
 var api = [
   require('./api/attributes'),
   require('./api/traversing'),
@@ -25,31 +23,20 @@ var api = [
   require('./api/forms')
 ];
 
-/**
- * Instance of cheerio. Methods are specified in the modules.
- * Usage of this constructor is not recommended. Please use $.load instead.
- *
- * @class
- * @param {string|cheerio|node|node[]} selector - The new selection.
- * @param {string|cheerio|node|node[]} [context] - Context of the selection.
- * @param {string|cheerio|node|node[]} [root] - Sets the root node.
- * @param {Object} [options] - Options for the instance.
+/*
+ * Instance of cheerio
  */
-var Cheerio = (module.exports = function(selector, context, root, options) {
-  if (!(this instanceof Cheerio))
-    return new Cheerio(selector, context, root, options);
 
-  this.options = _.defaults(
-    flattenOptions(options),
-    this.options,
-    defaultOptions
-  );
+var Cheerio = module.exports = function(selector, context, root, options) {
+  if (!(this instanceof Cheerio)) return new Cheerio(selector, context, root, options);
+
+  this.options = _.defaults(options || {}, this.options);
 
   // $(), $(null), $(undefined), $(false)
   if (!selector) return this;
 
   if (root) {
-    if (typeof root === 'string') root = parse(root, this.options, false);
+    if (typeof root === 'string') root = parse(root, this.options);
     this._root = Cheerio.call(this, root);
   }
 
@@ -57,23 +44,21 @@ var Cheerio = (module.exports = function(selector, context, root, options) {
   if (selector.cheerio) return selector;
 
   // $(dom)
-  if (isNode(selector)) selector = [selector];
+  if (isNode(selector))
+    selector = [selector];
 
   // $([dom])
   if (Array.isArray(selector)) {
-    _.forEach(
-      selector,
-      _.bind(function(elem, idx) {
-        this[idx] = elem;
-      }, this)
-    );
+    _.forEach(selector, _.bind(function(elem, idx) {
+      this[idx] = elem;
+    }, this));
     this.length = selector.length;
     return this;
   }
 
   // $(<html>)
   if (typeof selector === 'string' && isHtml(selector)) {
-    return Cheerio.call(this, parse(selector, this.options, false).children);
+    return Cheerio.call(this, parse(selector, this.options).children);
   }
 
   // If we don't have a context, maybe we have a root, from loading
@@ -82,15 +67,15 @@ var Cheerio = (module.exports = function(selector, context, root, options) {
   } else if (typeof context === 'string') {
     if (isHtml(context)) {
       // $('li', '<ul>...</ul>')
-      context = parse(context, this.options, false);
+      context = parse(context, this.options);
       context = Cheerio.call(this, context);
     } else {
       // $('li', 'ul')
       selector = [context, selector].join(' ');
       context = this._root;
     }
+  // $('li', node), $('li', [nodes])
   } else if (!context.cheerio) {
-    // $('li', node), $('li', [nodes])
     context = Cheerio.call(this, context);
   }
 
@@ -99,29 +84,44 @@ var Cheerio = (module.exports = function(selector, context, root, options) {
 
   // #id, .class, tag
   return context.find(selector);
-});
+};
 
 /**
  * Mix in `static`
  */
+
 _.extend(Cheerio, require('./static'));
 
 /*
  * Set a signature of the object
  */
+
 Cheerio.prototype.cheerio = '[cheerio object]';
 
+/*
+ * Cheerio default options
+ */
+
+Cheerio.prototype.options = {
+  withDomLvl1: true,
+  normalizeWhitespace: false,
+  xmlMode: false,
+  decodeEntities: true
+};
+
 /*
  * Make cheerio an array-like object
  */
+
 Cheerio.prototype.length = 0;
 Cheerio.prototype.splice = Array.prototype.splice;
 
 /*
  * Make a cheerio object
  *
- * @private
+ * @api private
  */
+
 Cheerio.prototype._make = function(dom, context) {
   var cheerio = new this.constructor(dom, context, this._root, this.options);
   cheerio.prevObject = this;
@@ -129,22 +129,16 @@ Cheerio.prototype._make = function(dom, context) {
 };
 
 /**
- * Retrieve all the DOM elements contained in the jQuery set as an array.
- *
- * @example
- * $('li').toArray()
- * //=> [ {...}, {...}, {...} ]
+ * Turn a cheerio object into an array
  */
+
 Cheerio.prototype.toArray = function() {
   return this.get();
 };
 
-// Support for (const element of $(...)) iteration:
-if (typeof Symbol !== 'undefined') {
-  Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
-}
-
-// Plug in the API
+/**
+ * Plug in the API
+ */
 api.forEach(function(mod) {
   _.extend(Cheerio.prototype, mod);
 });
diff --git a/lib/options.js b/lib/options.js
deleted file mode 100644
index fc7c3af8b0..0000000000
--- a/lib/options.js
+++ /dev/null
@@ -1,18 +0,0 @@
-var assign = require('lodash/assign');
-
-/*
- * Cheerio default options
- */
-
-exports.default = {
-  withDomLvl1: true,
-  normalizeWhitespace: false,
-  xml: false,
-  decodeEntities: true
-};
-
-exports.flatten = function(options) {
-  return options && options.xml
-    ? assign({ xmlMode: true }, options.xml)
-    : options;
-};
diff --git a/lib/parse.js b/lib/parse.js
index 298be39b52..b06245d5e8 100644
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -2,18 +2,16 @@
   Module Dependencies
 */
 var htmlparser = require('htmlparser2');
-var parse5 = require('parse5');
 
 /*
   Parser
 */
-exports = module.exports = function(content, options, isDocument) {
-  var dom = exports.evaluate(content, options, isDocument);
-  // Generic root element
-  var root = exports.evaluate('<root></root>', options, false)[0];
+exports = module.exports = function(content, options) {
+  var dom = exports.evaluate(content, options),
+      // Generic root element
+      root = exports.evaluate('<root></root>', options)[0];
 
   root.type = 'root';
-  root.parent = null;
 
   // Update the dom using the root
   exports.update(dom, root);
@@ -21,29 +19,13 @@ exports = module.exports = function(content, options, isDocument) {
   return root;
 };
 
-function parseWithParse5(content, options, isDocument) {
-  var parse = isDocument ? parse5.parse : parse5.parseFragment;
-  var root = parse(content, {
-    treeAdapter: parse5.treeAdapters.htmlparser2,
-    locationInfo: options.locationInfo
-  });
-
-  return root.children;
-}
-
-exports.evaluate = function(content, options, isDocument) {
+exports.evaluate = function(content, options) {
   // options = options || $.fn.options;
 
   var dom;
 
-  if (Buffer.isBuffer(content)) content = content.toString();
-
-  if (typeof content === 'string') {
-    var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
-
-    dom = useHtmlParser2
-      ? htmlparser.parseDOM(content, options)
-      : parseWithParse5(content, options, isDocument);
+  if (typeof content === 'string' || Buffer.isBuffer(content)) {
+    dom = htmlparser.parseDOM(content, options);
   } else {
     dom = content;
   }
@@ -70,8 +52,8 @@ exports.update = function(arr, parent) {
     var node = arr[i];
 
     // Cleanly remove existing nodes from their previous structures.
-    var oldParent = node.parent || node.root;
-    var oldSiblings = oldParent && oldParent.children;
+    var oldParent = node.parent || node.root,
+        oldSiblings = oldParent && oldParent.children;
     if (oldSiblings && oldSiblings !== arr) {
       oldSiblings.splice(oldSiblings.indexOf(node), 1);
       if (node.prev) {
diff --git a/lib/static.js b/lib/static.js
index 29f7cdf0de..6056cb7a30 100644
--- a/lib/static.js
+++ b/lib/static.js
@@ -1,40 +1,25 @@
 /**
- * @module static
+ * Module dependencies
  */
-var serialize = require('dom-serializer');
-var defaultOptions = require('./options').default;
-var flattenOptions = require('./options').flatten;
-var select = require('css-select');
-var parse5 = require('parse5');
-var parse = require('./parse');
-var _ = {
-  merge: require('lodash/merge'),
-  defaults: require('lodash/defaults')
-};
+
+var serialize = require('dom-serializer'),
+    select = require('css-select'),
+    parse = require('./parse'),
+    _ = {
+      merge: require('lodash/merge'),
+      defaults: require('lodash/defaults')
+    };
 
 /**
- * Create a querying function, bound to a document created from the provided
- * markup. Note that similar to web browser contexts, this operation may
- * introduce `<html>`, `<head>`, and `<body>` elements. See the previous
- * section titled "Loading" for usage information.
- *
- * @param {string} content - Markup to be loaded.
- * @param {Object} [options] - Options for the created instance.
- * @param {boolean} [isDocument] - Allows parser to be switched to fragment mode.
- *
+ * $.load(str)
  */
-exports.load = function(content, options, isDocument) {
-  if (content === null || content === undefined) {
-    throw new Error('cheerio.load() expects a string');
-  }
 
+exports.load = function(content, options) {
   var Cheerio = require('./cheerio');
 
-  options = _.defaults(flattenOptions(options || {}), defaultOptions);
+  options = _.defaults(options || {}, Cheerio.prototype.options);
 
-  if (isDocument === void 0) isDocument = true;
-
-  var root = parse(content, options, isDocument);
+  var root = parse(content, options);
 
   var initialize = function(selector, context, r, opts) {
     if (!(this instanceof initialize)) {
@@ -82,66 +67,47 @@ function render(that, dom, options) {
     dom = select(dom, that._root, options);
   }
 
-  var useHtmlParser2 = options.xmlMode || options._useHtmlParser2;
-
-  return useHtmlParser2
-    ? serialize(dom, options)
-    : parse5.serialize(
-      { children: 'length' in dom ? dom : [dom] },
-      {
-        treeAdapter: parse5.treeAdapters.htmlparser2
-      }
-    );
+  return serialize(dom, options);
 }
 
 /**
- * Renders the document.
- *
- * @param {string|cheerio|node} [dom] - Element to render.
- * @param {Object} [options] - Options for the renderer.
+ * $.html([selector | dom], [options])
  */
+
 exports.html = function(dom, options) {
+  var Cheerio = require('./cheerio');
+
   // be flexible about parameters, sometimes we call html(),
   // with options as only parameter
   // check dom argument for dom element specific properties
   // assume there is no 'length' or 'type' properties in the options object
-  if (
-    Object.prototype.toString.call(dom) === '[object Object]' &&
-    !options &&
-    !('length' in dom) &&
-    !('type' in dom)
-  ) {
+  if (Object.prototype.toString.call(dom) === '[object Object]' && !options && !('length' in dom) && !('type' in dom))
+  {
     options = dom;
     dom = undefined;
   }
 
   // sometimes $.html() used without preloading html
   // so fallback non existing options to the default ones
-  options = _.defaults(
-    flattenOptions(options || {}),
-    this._options,
-    defaultOptions
-  );
+  options = _.defaults(options || {}, this._options, Cheerio.prototype.options);
 
   return render(this, dom, options);
 };
 
 /**
- * Render the document as XML.
- *
- * @param {string|cheerio|node} [dom] - Element to render.
+ * $.xml([selector | dom])
  */
+
 exports.xml = function(dom) {
-  var options = _.defaults({ xml: true }, this._options);
+  var options = _.defaults({xmlMode: true}, this._options);
 
   return render(this, dom, options);
 };
 
 /**
- * Render the document as text.
- *
- * @param {string|cheerio|node} [elems] - Elements to render.
+ * $.text(dom)
  */
+
 exports.text = function(elems) {
   if (!elems) {
     elems = this.root();
@@ -154,12 +120,7 @@ exports.text = function(elems) {
   for (var i = 0; i < len; i++) {
     elem = elems[i];
     if (elem.type === 'text') ret += elem.data;
-    else if (
-      elem.children &&
-      elem.type !== 'comment' &&
-      elem.tagName !== 'script' &&
-      elem.tagName !== 'style'
-    ) {
+    else if (elem.children && elem.type !== 'comment' && elem.tagName !== 'script' && elem.tagName !== 'style') {
       ret += exports.text(elem.children);
     }
   }
@@ -168,14 +129,9 @@ exports.text = function(elems) {
 };
 
 /**
+ * $.parseHTML(data [, context ] [, keepScripts ])
  * Parses a string into an array of DOM nodes. The `context` argument has no
  * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
- *
- * @param {string} data - Markup that will be parsed.
- * @param {any|boolean} [context] - Will be ignored. If it is a boolean it will be used as the value of `keepScripts`.
- * @param {boolean} [keepScripts] - If false all scripts will be removed.
- *
- * @see {@link https://api.jquery.com/jQuery.parseHTML/}
  */
 exports.parseHTML = function(data, context, keepScripts) {
   var parsed;
@@ -188,7 +144,7 @@ exports.parseHTML = function(data, context, keepScripts) {
     keepScripts = context;
   }
 
-  parsed = this.load(data, defaultOptions, false);
+  parsed = this.load(data);
   if (!keepScripts) {
     parsed('script').remove();
   }
@@ -202,29 +158,17 @@ exports.parseHTML = function(data, context, keepScripts) {
 };
 
 /**
- * Sometimes you need to work with the top-level root element. To query it, you
- * can use `$.root()`.
- *
- * @example
- * ```js
- * $.root().append('<ul id="vegetables"></ul>').html();
- * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
- * ```
+ * $.root()
  */
 exports.root = function() {
   return this(this._root);
 };
 
 /**
- * Checks to see if the `contained` DOM element is a descendant of the
- * `container` DOM element.
- *
- * @param {node} container - Potential parent node.
- * @param {node} contained - Potential child node.
- *
- * @see {@link https://api.jquery.com/jQuery.contains}
+ * $.contains()
  */
 exports.contains = function(container, contained) {
+
   // According to the jQuery API, an element does not "contain" itself
   if (contained === container) {
     return false;
@@ -243,20 +187,16 @@ exports.contains = function(container, contained) {
 };
 
 /**
- * $.merge().
- *
- * @param {Array|cheerio} arr1 - First array.
- * @param {Array|cheerio} arr2 - Second array.
- *
- * @see {@link https://api.jquery.com/jQuery.merge}
+ * $.merge()
  */
+
 exports.merge = function(arr1, arr2) {
-  if (!(isArrayLike(arr1) && isArrayLike(arr2))) {
+  if(!(isArrayLike(arr1) && isArrayLike(arr2))){
     return;
   }
   var newLength = arr1.length + arr2.length;
   var i = 0;
-  while (i < arr2.length) {
+  while(i < arr2.length){
     arr1[i + arr1.length] = arr2[i];
     i++;
   }
@@ -264,25 +204,25 @@ exports.merge = function(arr1, arr2) {
   return arr1;
 };
 
-function isArrayLike(item) {
-  if (Array.isArray(item)) {
+function isArrayLike(item){
+  if(Array.isArray(item)){
     return true;
   }
-  if (typeof item !== 'object') {
+  if(typeof item !== 'object'){
     return false;
   }
-  if (!item.hasOwnProperty('length')) {
+  if(!item.hasOwnProperty('length')){
     return false;
   }
-  if (typeof item.length !== 'number') {
+  if(typeof item.length !== 'number') {
     return false;
   }
-  if (item.length < 0) {
+  if(item.length < 0){
     return false;
   }
   var i = 0;
-  while (i < item.length) {
-    if (!(i in item)) {
+  while(i < item.length){
+    if(!(i in item)){
       return false;
     }
     i++;
diff --git a/lib/utils.js b/lib/utils.js
index b1a18ac090..baa62fc616 100644
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -1,17 +1,18 @@
-var cloneDeepWith = require('lodash/cloneDeepWith');
+var parse = require('./parse'),
+    render = require('dom-serializer');
+
+/**
+ * HTML Tags
+ */
 
-// HTML Tags
 var tags = { tag: true, script: true, style: true };
 
 /**
- * Check if the DOM element is a tag.
+ * Check if the DOM element is a tag
  *
- * `isTag(type)` includes `<script>` and `<style>` tags.
- *
- * @param {node} type - DOM node to check.
- *
- * @private
+ * isTag(type) includes <script> and <style> tags
  */
+
 exports.isTag = function(type) {
   if (type.type) type = type.type;
   return tags[type] || false;
@@ -19,12 +20,10 @@ exports.isTag = function(type) {
 
 /**
  * Convert a string to camel case notation.
- *
- * @param  {string} str - String to be converted.
- * @returns {string}      String in camel case notation.
- *
- * @private
+ * @param  {String} str String to be converted.
+ * @return {String}     String in camel case notation.
  */
+
 exports.camelCase = function(str) {
   return str.replace(/[_.-](\w|$)/g, function(_, x) {
     return x.toUpperCase();
@@ -34,72 +33,49 @@ exports.camelCase = function(str) {
 /**
  * Convert a string from camel case to "CSS case", where word boundaries are
  * described by hyphens ("-") and all characters are lower-case.
- *
- * @param  {string} str - String to be converted.
- * @returns {string}      String in "CSS case".
- *
- * @private
+ * @param  {String} str String to be converted.
+ * @return {string}     String in "CSS case".
  */
 exports.cssCase = function(str) {
   return str.replace(/[A-Z]/g, '-$&').toLowerCase();
 };
 
-// Iterate over each DOM element without creating intermediary Cheerio
-// instances.
-//
-// This is indented for use internally to avoid otherwise unnecessary memory
-// pressure introduced by _make.
+/**
+ * Iterate over each DOM element without creating intermediary Cheerio instances.
+ *
+ * This is indented for use internally to avoid otherwise unnecessary memory pressure introduced
+ * by _make.
+ */
+
 exports.domEach = function(cheerio, fn) {
-  var i = 0,
-      len = cheerio.length;
+  var i = 0, len = cheerio.length;
   while (i < len && fn.call(cheerio, i, cheerio[i]) !== false) ++i;
   return cheerio;
 };
 
 /**
- * Create a deep copy of the given DOM structure.
- * Sets the parents of the copies of the passed nodes to `null`.
+ * Create a deep copy of the given DOM structure by first rendering it to a
+ * string and then parsing the resultant markup.
  *
- * @param {Object} dom - The htmlparser2-compliant DOM structure.
- * @private
+ * @argument {Object} dom - The htmlparser2-compliant DOM structure
+ * @argument {Object} options - The parsing/rendering options
  */
-exports.cloneDom = function(dom) {
-  var parents =
-    'length' in dom
-      ? Array.prototype.map.call(dom, function(el) {
-        return el.parent;
-      })
-      : [dom.parent];
-
-  function filterOutParent(node) {
-    if (parents.indexOf(node) > -1) {
-      return null;
-    }
-  }
-
-  return cloneDeepWith(dom, filterOutParent);
+exports.cloneDom = function(dom, options) {
+  return parse(render(dom, options), options).children;
 };
 
 /*
  * A simple way to check for HTML strings or ID strings
  */
-var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w-]*)$)/;
 
-/**
- * Check if string is HTML.
- *
- * @param {string} str - String to check.
- *
- * @private
+var quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/;
+
+/*
+ * Check if string is HTML
  */
 exports.isHtml = function(str) {
   // Faster than running regex, if str starts with `<` and ends with `>`, assume it's HTML
-  if (
-    str.charAt(0) === '<' &&
-    str.charAt(str.length - 1) === '>' &&
-    str.length >= 3
-  )
-    return true;
+  if (str.charAt(0) === '<' && str.charAt(str.length - 1) === '>' && str.length >= 3) return true;
 
   // Run the regex
   var match = quickExpr.exec(str);
diff --git a/package.json b/package.json
index 0c323de6d5..91d4e0aa34 100644
--- a/package.json
+++ b/package.json
@@ -1,56 +1,48 @@
 {
   "name": "cheerio",
-  "version": "1.0.0-rc.2",
-  "description":
-    "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
+  "version": "0.22.0",
+  "description": "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
   "author": "Matt Mueller <mattmuelle@gmail.com> (mat.io)",
   "license": "MIT",
-  "keywords": ["htmlparser", "jquery", "selector", "scraper", "parser", "html"],
+  "keywords": [
+    "htmlparser",
+    "jquery",
+    "selector",
+    "scraper",
+    "parser",
+    "html"
+  ],
   "repository": {
     "type": "git",
     "url": "git://github.com/cheeriojs/cheerio.git"
   },
   "main": "./index.js",
-  "files": ["index.js", "lib"],
+  "files": [
+    "index.js",
+    "lib"
+  ],
   "engines": {
     "node": ">= 0.6"
   },
   "dependencies": {
-    "css-select": "~2.0.0",
+    "css-select": "~1.2.0",
     "dom-serializer": "~0.1.0",
     "entities": "~1.1.1",
     "htmlparser2": "^3.9.1",
-    "lodash": "^4.17.5",
-    "parse5": "^3.0.1"
+    "lodash": "^4.15.0"
   },
   "devDependencies": {
     "benchmark": "^2.1.0",
-    "coveralls": "^3.0.0",
-    "eslint": "^4.18.1",
-    "eslint-config-prettier": "^2.9.0",
-    "eslint-plugin-jsdoc": "^3.5.0",
+    "coveralls": "^2.11.9",
     "expect.js": "~0.3.1",
-    "husky": "^0.14.3",
     "istanbul": "^0.4.3",
+    "jsdom": "^9.2.1",
     "jquery": "^3.0.0",
-    "jsdoc": "^3.5.5",
-    "jsdom": "^11.6.2",
-    "lint-staged": "^7.0.0",
-    "mocha": "^5.0.4",
-    "prettier": "^1.11.0",
+    "jshint": "^2.9.2",
+    "mocha": "^3.1.2",
     "xyz": "~1.1.0"
   },
   "scripts": {
-    "test": "npm run test:lint && npm run test:mocha",
-    "test:mocha": "mocha --recursive --reporter dot",
-    "test:lint": "eslint --ignore-path .gitignore .",
-    "precommit": "lint-staged"
-  },
-  "prettier": {
-    "singleQuote": true
-  },
-  "lint-staged": {
-    "*.js": ["prettier --write", "eslint --fix", "git add"],
-    "*.json": ["prettier --write", "git add"]
+    "test": "jshint lib/ test/ && mocha --recursive --reporter dot"
   }
 }
diff --git a/scripts/generate_history.sh b/scripts/generate_history.sh
deleted file mode 100755
index cd04b946e6..0000000000
--- a/scripts/generate_history.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-function error {
-  echo Cheerio "generate_history.sh" script: $1 >&2
-  false
-}
-
-if [ "$VERSION" == "" ] ; then
-  error 'VERSION environment variable unset.'
-fi
-
-if [ "$PREVIOUS_VERSION" == "" ] ; then
-  error 'PREVIOUS_VERSION environment variable unset.'
-fi
-
-tmp="$(mktemp -t "$(basename "$0").XXXXXXXXXX")"
-
-log="$(git --no-pager log --no-merges --pretty="format: * %s (%an)" $PREVIOUS_VERSION..)"
-
-printf "
-$VERSION / $(date +"%Y-%m-%d")
-==================
-
-$log
-" >"$tmp"
-
-cat History.md >>"$tmp"
-
-mv "$tmp" History.md
diff --git a/scripts/prepublish b/scripts/prepublish
index 7198f7174f..e24c7a22c1 100755
--- a/scripts/prepublish
+++ b/scripts/prepublish
@@ -1,23 +1,17 @@
 #!/usr/bin/env bash
 set -e
 
-function error {
-  echo Cheerio "prepublish" script: $1 >&2
-  false
-}
+tmp="$(mktemp -t "$(basename "$0").XXXXXXXXXX")"
 
-if [ "$VERSION" == "" ] ; then
-  error 'VERSION environment variable unset.'
-fi
+log="$(git --no-pager log --no-merges --pretty="format: * %s (%an)" $PREVIOUS_VERSION..)"
 
-if [ "$PREVIOUS_VERSION" == "" ] ; then
-  error 'PREVIOUS_VERSION environment variable unset.'
-fi
+printf "
+$VERSION / $(date +"%Y-%m-%d")
+==================
 
-if ! grep -E "^$VERSION / [0-9]{4}-[0-9]{2}-[0-9]{2}" History.md > /dev/null; then
-  error "No entry for version $VERSION found in History.md file. (This may be seeded with the generate_history.sh script.)"
-fi
+$log
+" >"$tmp"
 
-if ! git diff-index --quiet HEAD -- History.md; then
-  error 'History.md file contains untracked changes. Commit them prior to publication.'
-fi
+cat History.md >>"$tmp"
+mv "$tmp" History.md
+git add History.md
diff --git a/test/.eslintrc.json b/test/.eslintrc.json
deleted file mode 100644
index 7eeefc33b6..0000000000
--- a/test/.eslintrc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "env": {
-    "mocha": true
-  }
-}
diff --git a/test/.jshintrc b/test/.jshintrc
new file mode 100644
index 0000000000..7b01de5f58
--- /dev/null
+++ b/test/.jshintrc
@@ -0,0 +1,9 @@
+{
+  "extends": "../.jshintrc",
+  "globals": {
+    "expect": true,
+    "it": true,
+    "describe": true,
+    "beforeEach": true
+  }
+}
diff --git a/test/api/attributes.js b/test/api/attributes.js
index 129d8e2b0f..61072dd9b9 100644
--- a/test/api/attributes.js
+++ b/test/api/attributes.js
@@ -16,6 +16,7 @@ describe('$(...)', function() {
   });
 
   describe('.attr', function() {
+
     it('() : should get all the attributes', function() {
       var attrs = $('ul').attr();
       expect(attrs.id).to.equal('fruits');
@@ -81,18 +82,10 @@ describe('$(...)', function() {
 
     it('(key, value) : should correctly encode then decode unsafe values', function() {
       var $apple = $('.apple');
-      $apple.attr(
-        'href',
-        'http://github.com/"><script>alert("XSS!")</script><br'
-      );
-      expect($apple.attr('href')).to.equal(
-        'http://github.com/"><script>alert("XSS!")</script><br'
-      );
-
-      $apple.attr(
-        'href',
-        'http://github.com/"><script>alert("XSS!")</script><br'
-      );
+      $apple.attr('href', 'http://github.com/"><script>alert("XSS!")</script><br');
+      expect($apple.attr('href')).to.equal('http://github.com/"><script>alert("XSS!")</script><br');
+
+      $apple.attr('href', 'http://github.com/"><script>alert("XSS!")</script><br');
       expect($apple.html()).to.not.contain('<script>alert("XSS!")</script>');
     });
 
@@ -127,22 +120,19 @@ describe('$(...)', function() {
     });
 
     it('(map) : should remove attributes with null values', function() {
-      var $pear = $('.pear').attr({
-        autofocus: 'autofocus',
-        style: 'color:red'
-      });
+      var $pear = $('.pear').attr({'autofocus': 'autofocus', 'style': 'color:red'});
       expect($pear.attr('autofocus')).to.equal('autofocus');
       expect($pear.attr('style')).to.equal('color:red');
-      $pear.attr({ autofocus: null, style: 'color:blue' });
+      $pear.attr({'autofocus': null, 'style': 'color:blue'});
       expect($pear.attr('autofocus')).to.be(undefined);
       expect($pear.attr('style')).to.equal('color:blue');
     });
   });
 
-  describe('.prop', function() {
+  describe('.prop', function () {
     var checkbox, selectMenu;
 
-    beforeEach(function() {
+    beforeEach(function () {
       $ = cheerio.load(inputs);
       selectMenu = $('select');
       checkbox = $('input[name=checkbox_on]');
@@ -192,18 +182,11 @@ describe('$(...)', function() {
     it('(key, value) : should support chaining after setting props', function() {
       expect(checkbox.prop('checked', false)).to.equal(checkbox);
     });
-
+    
     it('(invalid element/tag) : prop should return undefined', function() {
       expect($(undefined).prop('prop')).to.be(undefined);
       expect($(null).prop('prop')).to.be(undefined);
     });
-
-    it('("outerHTML") : should render properly', function() {
-      var outerHtml = "<div><a></a></div>";
-      var $a = $(outerHtml);
-
-      expect($a.prop("outerHTML")).to.be(outerHtml);
-    });
     
     it('(inherited properties) : prop should support inherited properties', function() {
       expect(selectMenu.prop('childNodes')).to.equal(selectMenu[0].childNodes);
@@ -211,6 +194,7 @@ describe('$(...)', function() {
   });
 
   describe('.data', function() {
+
     beforeEach(function() {
       $ = cheerio.load(chocolates);
     });
@@ -263,9 +247,7 @@ describe('$(...)', function() {
     });
 
     it('(key) : should translate camel-cased key values to hyphen-separated versions', function() {
-      var $el = cheerio(
-        '<div data--three-word-attribute="a" data-foo-Bar_BAZ-="b">'
-      );
+      var $el = cheerio('<div data--three-word-attribute="a" data-foo-Bar_BAZ-="b">');
 
       expect($el.data('ThreeWordAttribute')).to.be('a');
       expect($el.data('fooBar_baz-')).to.be('b');
@@ -283,7 +265,7 @@ describe('$(...)', function() {
     it('(key) : should parse JSON data derived from the markup', function() {
       var $el = cheerio('<div data-json="[1, 2, 3]">');
 
-      expect($el.data('json')).to.eql([1, 2, 3]);
+      expect($el.data('json')).to.eql([1,2,3]);
     });
 
     it('(key) : should not parse JSON data set via the `data` API', function() {
@@ -305,9 +287,9 @@ describe('$(...)', function() {
     });
 
     it('(key) : should recover from malformed JSON', function() {
-      var $el = cheerio('<div data-custom="{{templatevar}}">');
+        var $el = cheerio('<div data-custom="{{templatevar}}">');
 
-      expect($el.data('custom')).to.be('{{templatevar}}');
+        expect($el.data('custom')).to.be('{{templatevar}}');
     });
 
     it('(hyphen key) : data addribute with hyphen should be camelized ;-)', function() {
@@ -333,21 +315,9 @@ describe('$(...)', function() {
     it('(key, value) : should set data for all elements in the selection', function() {
       $('li').data('foo', 'bar');
 
-      expect(
-        $('li')
-          .eq(0)
-          .data('foo')
-      ).to.eql('bar');
-      expect(
-        $('li')
-          .eq(1)
-          .data('foo')
-      ).to.eql('bar');
-      expect(
-        $('li')
-          .eq(2)
-          .data('foo')
-      ).to.eql('bar');
+      expect($('li').eq(0).data('foo')).to.eql('bar');
+      expect($('li').eq(1).data('foo')).to.eql('bar');
+      expect($('li').eq(2).data('foo')).to.eql('bar');
     });
 
     it('(map) : object map should set multiple data attributes', function() {
@@ -394,10 +364,14 @@ describe('$(...)', function() {
         var $el = cheerio('<div data-array="[1, 2, 3]">');
         expect($el.data('array')).to.eql([1, 2, 3]);
       });
+
     });
+
   });
 
+
   describe('.val', function() {
+
     beforeEach(function() {
       $ = cheerio.load(inputs);
     });
@@ -419,9 +393,7 @@ describe('$(...)', function() {
       expect(val).to.equal('Option selected');
     });
     it('(): on option should get value', function() {
-      var val = $('select#one option')
-        .eq(0)
-        .val();
+      var val = $('select#one option').eq(0).val();
       expect(val).to.equal('option_not_selected');
     });
     it('(): on text input should get value', function() {
@@ -473,9 +445,7 @@ describe('$(...)', function() {
       expect(element.val()).to.equal('option_not_selected');
     });
     it('(value): on option should set value', function() {
-      var element = $('select#one option')
-        .eq(0)
-        .val('option_changed');
+      var element = $('select#one option').eq(0).val('option_changed');
       expect(element.val()).to.equal('option_changed');
     });
     it('(value): on radio should set value', function() {
@@ -493,6 +463,7 @@ describe('$(...)', function() {
   });
 
   describe('.removeAttr', function() {
+
     it('(key) : should remove a single attr', function() {
       var $fruits = $('#fruits');
       expect($fruits.attr('id')).to.not.be(undefined);
@@ -504,6 +475,7 @@ describe('$(...)', function() {
       var obj = $('ul').removeAttr('id');
       expect(obj).to.be.a($);
     });
+
   });
 
   describe('.hasClass', function() {
@@ -537,26 +509,19 @@ describe('$(...)', function() {
 
       // Remove one and test again
       $('.apple').removeClass('apple');
-      expect(
-        $('li')
-          .eq(0)
-          .hasClass('apple')
-      ).to.not.be.ok();
+      expect($('li').eq(0).hasClass('apple')).to.not.be.ok();
       // expect($('li', $fruits).eq(0).hasClass('red')).to.be.ok();
     });
 
     it('(empty string argument) : should return false', function() {
       expect(test('foo').hasClass('')).to.not.be.ok();
       expect(test('foo bar').hasClass('')).to.not.be.ok();
-      expect(
-        test('foo bar')
-          .removeClass('foo')
-          .hasClass('')
-      ).to.not.be.ok();
+      expect(test('foo bar').removeClass('foo').hasClass('')).to.not.be.ok();
     });
   });
 
   describe('.addClass', function() {
+
     it('(first class) : should add the class to the element', function() {
       var $fruits = $('#fruits');
       $fruits.addClass('fruits');
@@ -597,16 +562,26 @@ describe('$(...)', function() {
         return toAdd[idx];
       });
 
-      expect(args).to.eql([[0, 'apple'], [1, 'orange'], [2, 'pear']]);
-      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(args).to.eql([
+        [0, 'apple'],
+        [1, 'orange'],
+        [2, 'pear']
+      ]);
+      expect(thisVals).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
       expect($fruits.eq(0).hasClass('apple')).to.be.ok();
       expect($fruits.eq(0).hasClass('red')).to.be.ok();
       expect($fruits.eq(1).hasClass('orange')).to.be.ok();
       expect($fruits.eq(2).hasClass('pear')).to.be.ok();
     });
+
   });
 
   describe('.removeClass', function() {
+
     it('() : should remove all the classes', function() {
       $('.pear').addClass('fruit');
       $('.pear').removeClass();
@@ -629,7 +604,8 @@ describe('$(...)', function() {
 
       expect(function() {
         $('li', $vegetables).removeClass('vegetable');
-      }).to.not.throwException();
+      })
+      .to.not.throwException();
     });
 
     it('(single class) : should remove a single class from the element', function() {
@@ -683,24 +659,34 @@ describe('$(...)', function() {
         return toAdd[idx];
       });
 
-      expect(args).to.eql([[0, 'apple'], [1, 'orange'], [2, 'pear']]);
-      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(args).to.eql([
+        [0, 'apple'],
+        [1, 'orange'],
+        [2, 'pear']
+      ]);
+      expect(thisVals).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
       expect($fruits.eq(0).hasClass('apple')).to.not.be.ok();
       expect($fruits.eq(0).hasClass('red')).to.not.be.ok();
       expect($fruits.eq(1).hasClass('orange')).to.be.ok();
       expect($fruits.eq(2).hasClass('pear')).to.be.ok();
     });
 
-    it('(fn) : should no op elements without attributes', function() {
+    it('(fn) : should no op elements without attributes', function(){
       var $inputs = $(inputs);
       var val = $inputs.removeClass(function() {
         return 'tasty';
       });
       expect(val).to.have.length(15);
     });
+
   });
 
   describe('.toggleClass', function() {
+
     it('(class class) : should toggle multiple classes from the element', function() {
       $('.apple').addClass('fruit');
       expect($('.apple').hasClass('apple')).to.be.ok();
@@ -725,14 +711,10 @@ describe('$(...)', function() {
       expect($('.fruit').hasClass('fruit')).to.be.ok();
     });
 
-    it('(class true) : should add only one instance of class', function() {
+    it('(class true) : should add only one instance of class', function () {
       $('.apple').toggleClass('tasty', true);
       $('.apple').toggleClass('tasty', true);
-      expect(
-        $('.apple')
-          .attr('class')
-          .match(/tasty/g).length
-      ).to.equal(1);
+      expect($('.apple').attr('class').match(/tasty/g).length).to.equal(1);
     });
 
     it('(class class, false) : should remove multiple classes from the element', function() {
@@ -762,11 +744,7 @@ describe('$(...)', function() {
       expect($('.sweetcorn').hasClass('vegetable')).to.not.be.ok();
 
       $('li').toggleClass(function() {
-        return $(this)
-          .parent()
-          .is('#fruits')
-          ? 'fruit'
-          : 'vegetable';
+        return $(this).parent().is('#fruits') ? 'fruit' : 'vegetable';
       });
       expect($('.apple').hasClass('fruit')).to.not.be.ok();
       expect($('.apple').hasClass('vegetable')).to.not.be.ok();
@@ -781,15 +759,13 @@ describe('$(...)', function() {
     it('(fn) : should work with no initial class attribute', function() {
       var $inputs = cheerio.load(inputs);
       $inputs('input, select').toggleClass(function() {
-        return $inputs(this).get(0).tagName === 'select'
-          ? 'selectable'
-          : 'inputable';
+        return $inputs(this).get(0).tagName === 'select' ? 'selectable' : 'inputable';
       });
       expect($inputs('.selectable')).to.have.length(6);
       expect($inputs('.inputable')).to.have.length(9);
     });
 
-    it('(invalid) : should be a no-op for invalid inputs', function() {
+    it('(invalid) : should be a no-op for invalid inputs', function(){
       var original = $('.apple');
       var testAgainst = original.attr('class');
       expect(original.toggleClass().attr('class')).to.be.eql(testAgainst);
@@ -800,9 +776,10 @@ describe('$(...)', function() {
       expect(original.toggleClass(1).attr('class')).to.be.eql(testAgainst);
       expect(original.toggleClass({}).attr('class')).to.be.eql(testAgainst);
     });
+
   });
 
-  describe('.is', function() {
+  describe('.is', function () {
     it('() : should return false', function() {
       expect($('li.apple').is()).to.be(false);
     });
@@ -844,13 +821,12 @@ describe('$(...)', function() {
       expect(result).to.be(true);
     });
 
-    it('(false predicate) : should return false', function() {
-      var result = $('li')
-        .last()
-        .is(function() {
-          return this.tagName === 'ul';
-        });
+    it('(false predicate) : should return false', function () {
+      var result = $('li').last().is(function() {
+        return this.tagName === 'ul';
+      });
       expect(result).to.be(false);
     });
   });
+
 });
diff --git a/test/api/css.js b/test/api/css.js
index a037fff77d..9e394c44f0 100644
--- a/test/api/css.js
+++ b/test/api/css.js
@@ -2,6 +2,7 @@ var expect = require('expect.js');
 var cheerio = require('../..');
 
 describe('$(...)', function() {
+
   describe('.css', function() {
     it('(prop): should return a css property value', function() {
       var el = cheerio('<li style="hai: there">');
@@ -10,10 +11,7 @@ describe('$(...)', function() {
 
     it('([prop1, prop2]): should return the specified property values as an object', function() {
       var el = cheerio('<li style="margin: 1px; padding: 2px; color: blue;">');
-      expect(el.css(['margin', 'color'])).to.eql({
-        margin: '1px',
-        color: 'blue'
-      });
+      expect(el.css(['margin', 'color'])).to.eql({ margin: '1px', color: 'blue' });
     });
 
     it('(prop, val): should set a css property', function() {
@@ -30,29 +28,23 @@ describe('$(...)', function() {
     });
 
     it('(prop): should not mangle embedded urls', function() {
-      var el = cheerio(
-        '<li style="background-image:url(http://example.com/img.png);">'
-      );
-      expect(el.css('background-image')).to.equal(
-        'url(http://example.com/img.png)'
-      );
+      var el = cheerio('<li style="background-image:url(http://example.com/img.png);">');
+      expect(el.css('background-image')).to.equal('url(http://example.com/img.png)');
     });
 
     it('(prop): should ignore blank properties', function() {
       var el = cheerio('<li style=":#ccc;color:#aaa;">');
-      expect(el.css()).to.eql({ color: '#aaa' });
+      expect(el.css()).to.eql({color:'#aaa'});
     });
 
     it('(prop): should ignore blank values', function() {
       var el = cheerio('<li style="color:;position:absolute;">');
-      expect(el.css()).to.eql({ position: 'absolute' });
+      expect(el.css()).to.eql({position:'absolute'});
     });
 
     describe('(prop, function):', function() {
       beforeEach(function() {
-        this.$el = cheerio(
-          '<div style="margin: 0px;"></div><div style="margin: 1px;"></div><div style="margin: 2px;">'
-        );
+        this.$el = cheerio('<div style="margin: 0px;"></div><div style="margin: 1px;"></div><div style="margin: 2px;">');
       });
 
       it('should iterate over the selection', function() {
@@ -85,11 +77,12 @@ describe('$(...)', function() {
       expect(el.eq(1).attr('style')).to.equal('foo: 0;');
     });
 
-    describe('parser', function() {
+    describe('parser', function(){
       it('should allow any whitespace between declarations', function() {
         var el = cheerio('<li style="one \t:\n 0;\n two \f\r:\v 1">');
         expect(el.css(['one', 'two'])).to.eql({ one: 0, two: 1 });
       });
     });
   });
+
 });
diff --git a/test/api/forms.js b/test/api/forms.js
index 6ba31018b5..a94f4a9365 100644
--- a/test/api/forms.js
+++ b/test/api/forms.js
@@ -1,8 +1,9 @@
 var expect = require('expect.js'),
-    cheerio = require('../..'),
-    forms = require('../fixtures').forms;
+  cheerio = require('../..'),
+  forms = require('../fixtures').forms;
 
 describe('$(...)', function() {
+
   var $;
 
   beforeEach(function() {
@@ -10,6 +11,7 @@ describe('$(...)', function() {
   });
 
   describe('.serializeArray', function() {
+
     it('() : should get form controls', function() {
       expect($('form#simple').serializeArray()).to.eql([
         {
@@ -22,7 +24,7 @@ describe('$(...)', function() {
     it('() : should get nested form controls', function() {
       expect($('form#nested').serializeArray()).to.have.length(2);
       var data = $('form#nested').serializeArray();
-      data.sort(function(a, b) {
+      data.sort(function (a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -71,7 +73,7 @@ describe('$(...)', function() {
     it('() : should get multiple selected options', function() {
       expect($('form#multiple').serializeArray()).to.have.length(2);
       var data = $('form#multiple').serializeArray();
-      data.sort(function(a, b) {
+      data.sort(function (a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -88,7 +90,7 @@ describe('$(...)', function() {
 
     it('() : should get individually selected elements', function() {
       var data = $('form#nested input').serializeArray();
-      data.sort(function(a, b) {
+      data.sort(function (a, b) {
         return a.value - b.value;
       });
       expect(data).to.eql([
@@ -101,6 +103,7 @@ describe('$(...)', function() {
           value: 'Carrot'
         }
       ]);
+
     });
 
     it('() : should standardize line breaks', function() {
@@ -112,38 +115,36 @@ describe('$(...)', function() {
       ]);
     });
 
-    it("() : shouldn't serialize the empty string", function() {
-      expect($('<input value=pineapple>').serializeArray()).to.eql([]);
-      expect($('<input name="" value=pineapple>').serializeArray()).to.eql([]);
-      expect($('<input name="fruit" value=pineapple>').serializeArray()).to.eql(
-        [
-          {
-            name: 'fruit',
-            value: 'pineapple'
-          }
-        ]
-      );
+    it('() : shouldn\'t serialize the empty string', function() {
+        expect($('<input value=pineapple>').serializeArray()).to.eql([]);
+        expect($('<input name="" value=pineapple>').serializeArray()).to.eql([]);
+        expect($('<input name="fruit" value=pineapple>').serializeArray()).to.eql([
+            {
+                name: 'fruit',
+                value: 'pineapple'
+            }
+        ]);
     });
 
     it('() : should serialize inputs without value attributes', function() {
-      expect($('<input name="fruit">').serializeArray()).to.eql([
-        {
-          name: 'fruit',
-          value: ''
-        }
-      ]);
+        expect($('<input name="fruit">').serializeArray()).to.eql([
+            {
+                name: 'fruit',
+                value: ''
+            }
+        ]);
     });
+
   });
 
   describe('.serialize', function() {
+
     it('() : should get form controls', function() {
       expect($('form#simple').serialize()).to.equal('fruit=Apple');
     });
 
     it('() : should get nested form controls', function() {
-      expect($('form#nested').serialize()).to.equal(
-        'fruit=Apple&vegetable=Carrot'
-      );
+      expect($('form#nested').serialize()).to.equal('fruit=Apple&vegetable=Carrot');
     });
 
     it('() : should not get disabled form controls', function() {
@@ -151,13 +152,13 @@ describe('$(...)', function() {
     });
 
     it('() : should get multiple selected options', function() {
-      expect($('form#multiple').serialize()).to.equal(
-        'fruit=Apple&fruit=Orange'
-      );
+      expect($('form#multiple').serialize()).to.equal('fruit=Apple&fruit=Orange');
     });
 
-    it("() : should encode spaces as +'s", function() {
+    it('() : should encode spaces as +\'s', function() {
       expect($('form#spaces').serialize()).to.equal('fruit=Blood+orange');
     });
+
   });
+
 });
diff --git a/test/api/manipulation.js b/test/api/manipulation.js
index 500cd82d32..b6eaaaf9d0 100644
--- a/test/api/manipulation.js
+++ b/test/api/manipulation.js
@@ -4,6 +4,7 @@ var expect = require('expect.js'),
     toArray = Function.call.bind(Array.prototype.slice);
 
 describe('$(...)', function() {
+
   var $, $fruits;
 
   beforeEach(function() {
@@ -16,30 +17,15 @@ describe('$(...)', function() {
       var $redFruits = $('<div class="red-fruits"></div>');
       $('.apple').wrap($redFruits);
 
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('red-fruits')
-      ).to.be.ok();
-      expect(
-        $('.red-fruits')
-          .children()
-          .eq(0)
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('orange')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('red-fruits')).to.be.ok();
+      expect($('.red-fruits').children().eq(0).hasClass('apple')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('orange')).to.be.ok();
       expect($redFruits.children()).to.have.length(1);
     });
 
-    it('(element) : should wrap the base element correctly', function() {
+    it('(element) : should wrap the base element correctly', function(){
       $('ul').wrap('<a></a>');
-      expect($('body').children()[0].tagName).to.equal('a');
+      expect($.root().children()[0].tagName).to.equal('a');
     });
 
     it('(element) : should insert the element and add selected element(s) as its child', function() {
@@ -54,24 +40,9 @@ describe('$(...)', function() {
 
     it('(html) : should insert the markup and add selected element(s) as its child', function() {
       $('.apple').wrap('<div class="red-fruits"> </div>');
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('red-fruits')
-      ).to.be.ok();
-      expect(
-        $('.red-fruits')
-          .children()
-          .eq(0)
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('orange')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('red-fruits')).to.be.ok();
+      expect($('.red-fruits').children().eq(0).hasClass('apple')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('orange')).to.be.ok();
       expect($('.red-fruits').children()).to.have.length(1);
     });
 
@@ -82,29 +53,12 @@ describe('$(...)', function() {
     });
 
     it('(html) : wraps with nested elements', function() {
-      var $orangeFruits = $(
-        '<div class="orange-fruits"><div class="and-stuff"></div></div>'
-      );
+      var $orangeFruits = $('<div class="orange-fruits"><div class="and-stuff"></div></div>');
       $('.orange').wrap($orangeFruits);
 
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('orange-fruits')
-      ).to.be.ok();
-      expect(
-        $('.orange-fruits')
-          .children()
-          .eq(0)
-          .hasClass('and-stuff')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('pear')
-      ).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('orange-fruits')).to.be.ok();
+      expect($('.orange-fruits').children().eq(0).hasClass('and-stuff')).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('pear')).to.be.ok();
       expect($('.orange-fruits').children()).to.have.length(1);
     });
 
@@ -139,8 +93,16 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([[0], [1], [2]]);
-      expect(thisValues).to.eql([$children[0], $children[1], $children[2]]);
+      expect(args).to.eql([
+        [0],
+        [1],
+        [2]
+      ]);
+      expect(thisValues).to.eql([
+        $children[0],
+        $children[1],
+        $children[2]
+      ]);
     });
 
     it('(fn) : should use the returned HTML to wrap each element', function() {
@@ -159,9 +121,7 @@ describe('$(...)', function() {
       expect($fruits.find('span')).to.have.length(1);
       expect($fruits.find('span')[0]).to.be($fruits.children()[1]);
       expect($fruits.find('.orange')).to.have.length(1);
-      expect($fruits.find('.orange').parent()[0]).to.be(
-        $fruits.find('span')[0]
-      );
+      expect($fruits.find('.orange').parent()[0]).to.be($fruits.find('span')[0]);
 
       expect($fruits.find('p')).to.have.length(1);
       expect($fruits.find('p')[0]).to.be($fruits.children()[2]);
@@ -196,86 +156,36 @@ describe('$(...)', function() {
     it('($(...)) : for each element it should add a wrapper elment and add the selected element as its child', function() {
       var $fruitDecorator = $('<div class="fruit-decorator"></div>');
       $('li').wrap($fruitDecorator);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('fruit-decorator')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .children()
-          .eq(0)
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('fruit-decorator')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .children()
-          .eq(0)
-          .hasClass('orange')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('fruit-decorator')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .children()
-          .eq(0)
-          .hasClass('pear')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('fruit-decorator')).to.be.ok();
+      expect($fruits.children().eq(0).children().eq(0).hasClass('apple')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('fruit-decorator')).to.be.ok();
+      expect($fruits.children().eq(1).children().eq(0).hasClass('orange')).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('fruit-decorator')).to.be.ok();
+      expect($fruits.children().eq(2).children().eq(0).hasClass('pear')).to.be.ok();
     });
-  });
+   });
 
   describe('.append', function() {
+
     it('() : should do nothing', function() {
       expect($('#fruits').append()[0].tagName).to.equal('ul');
     });
 
     it('(html) : should add element as last child', function() {
       $fruits.append('<li class="plum">Plum</li>');
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('($(...)) : should add element as last child', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $fruits.append($plum);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add element as last child', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $fruits.append(plum);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('(existing Node) : should remove node from previous location', function() {
@@ -331,49 +241,23 @@ describe('$(...)', function() {
 
       $apple.remove();
       $fruits.append($apple);
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('apple')
-      ).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('apple')).to.be.ok();
     });
 
     it('($(...), html) : should add multiple elements as last children', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $fruits.append($plum, grape);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(4)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(4).hasClass('grape')).to.be.ok();
     });
 
     it('(Array) : should append all elements in the array', function() {
-      var more = $(
-        '<li class="plum">Plum</li><li class="grape">Grape</li>'
-      ).get();
+      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
+        .get();
       $fruits.append(more);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(4)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(4).hasClass('grape')).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -386,8 +270,16 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(args).to.eql([
+        [0, 'Apple'],
+        [1, 'Orange'],
+        [2, 'Pear']
+      ]);
+      expect(thisValues).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
     });
 
     it('(fn) : should add returned string as last child', function() {
@@ -462,40 +354,26 @@ describe('$(...)', function() {
   });
 
   describe('.prepend', function() {
+
     it('() : should do nothing', function() {
       expect($('#fruits').prepend()[0].tagName).to.equal('ul');
     });
 
     it('(html) : should add element as first child', function() {
       $fruits.prepend('<li class="plum">Plum</li>');
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('($(...)) : should add element as first child', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $fruits.prepend($plum);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add node as first child', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $fruits.prepend(plum);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -535,49 +413,23 @@ describe('$(...)', function() {
 
       $apple.remove();
       $fruits.prepend($apple);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('apple')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('apple')).to.be.ok();
     });
 
     it('(Array) : should add all elements in the array as inital children', function() {
-      var more = $(
-        '<li class="plum">Plum</li><li class="grape">Grape</li>'
-      ).get();
+      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
+        .get();
       $fruits.prepend(more);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
     });
 
     it('(html, $(...), html) : should add multiple elements as first children', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $fruits.prepend($plum, grape);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -590,8 +442,16 @@ describe('$(...)', function() {
         thisValues.push(this);
       });
 
-      expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(args).to.eql([
+        [0, 'Apple'],
+        [1, 'Orange'],
+        [2, 'Pear']
+      ]);
+      expect(thisValues).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
     });
 
     it('(fn) : should add returned string as first child', function() {
@@ -645,6 +505,7 @@ describe('$(...)', function() {
       expect($pear.find('.third')[0]).to.equal($pear.contents()[0]);
     });
 
+
     it('($(...)) : should remove from root element', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var root = $plum[0].root;
@@ -657,130 +518,67 @@ describe('$(...)', function() {
   });
 
   describe('.appendTo', function() {
+
     it('(html) : should add element as last child', function() {
       var $plum = $('<li class="plum">Plum</li>').appendTo(fruits);
-      expect(
-        $plum
-          .parent()
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($plum.parent().children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('($(...)) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo($fruits);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo($fruits[0]);
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('(selector) : should add element as last child', function() {
       $('<li class="plum">Plum</li>').appendTo('#fruits');
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('plum')).to.be.ok();
     });
 
     it('(Array) : should add element as last child of all elements in the array', function() {
       var $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>');
       $('<li class="plum">Plum</li>').appendTo($multiple.get());
-      expect(
-        $multiple
-          .first()
-          .children()
-          .eq(1)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $multiple
-          .last()
-          .children()
-          .eq(1)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($multiple.first().children().eq(1).hasClass('plum')).to.be.ok();
+      expect($multiple.last().children().eq(1).hasClass('plum')).to.be.ok();
     });
   });
 
   describe('.prependTo', function() {
+
     it('(html) : should add element as first child', function() {
       var $plum = $('<li class="plum">Plum</li>').prependTo(fruits);
-      expect(
-        $plum
-          .parent()
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($plum.parent().children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('($(...)) : should add element as first child', function() {
       $('<li class="plum">Plum</li>').prependTo($fruits);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add node as first child', function() {
       $('<li class="plum">Plum</li>').prependTo($fruits[0]);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('(selector) : should add element as first child', function() {
       $('<li class="plum">Plum</li>').prependTo('#fruits');
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
     });
 
     it('(Array) : should add element as first child of all elements in the array', function() {
       var $multiple = $('<ul><li>Apple</li></ul><ul><li>Orange</li></ul>');
       $('<li class="plum">Plum</li>').prependTo($multiple.get());
-      expect(
-        $multiple
-          .first()
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $multiple
-          .last()
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($multiple.first().children().eq(0).hasClass('plum')).to.be.ok();
+      expect($multiple.last().children().eq(0).hasClass('plum')).to.be.ok();
     });
   });
 
   describe('.after', function() {
+
     it('() : should do nothing', function() {
       expect($('#fruits').after()[0].tagName).to.equal('ul');
     });
@@ -788,50 +586,27 @@ describe('$(...)', function() {
     it('(html) : should add element as next sibling', function() {
       var grape = '<li class="grape">Grape</li>';
       $('.apple').after(grape);
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('grape')).to.be.ok();
     });
 
     it('(Array) : should add all elements in the array as next sibling', function() {
-      var more = $(
-        '<li class="plum">Plum</li><li class="grape">Grape</li>'
-      ).get();
+      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
+        .get();
       $('.apple').after(more);
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should add element as next sibling', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.apple').after($plum);
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add element as next sibling', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $('.apple').after(plum);
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('plum')).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -856,26 +631,10 @@ describe('$(...)', function() {
       $('.orange, .pear').after($originalApple);
 
       expect($('.apple')).to.have.length(2);
-      expect(
-        $('.apple')
-          .eq(0)
-          .prev()[0]
-      ).to.be($('.orange')[0]);
-      expect(
-        $('.apple')
-          .eq(0)
-          .next()[0]
-      ).to.be($('.pear')[0]);
-      expect(
-        $('.apple')
-          .eq(1)
-          .prev()[0]
-      ).to.be($('.pear')[0]);
-      expect(
-        $('.apple')
-          .eq(1)
-          .next()
-      ).to.have.length(0);
+      expect($('.apple').eq(0).prev()[0]).to.be($('.orange')[0]);
+      expect($('.apple').eq(0).next()[0]).to.be($('.pear')[0]);
+      expect($('.apple').eq(1).prev()[0]).to.be($('.pear')[0]);
+      expect($('.apple').eq(1).next()).to.have.length(0);
       expect($('.apple')[0]).to.not.eql($originalApple[0]);
       expect($('.apple')[1]).to.eql($originalApple[0]);
     });
@@ -893,16 +652,8 @@ describe('$(...)', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $('.apple').after($plum, grape);
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $('.plum')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('plum')).to.be.ok();
+      expect($('.plum').next().hasClass('grape')).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -916,7 +667,11 @@ describe('$(...)', function() {
       });
 
       expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(thisValues).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
     });
 
     it('(fn) : should add returned string as next sibling', function() {
@@ -967,144 +722,67 @@ describe('$(...)', function() {
   });
 
   describe('.insertAfter', function() {
+
     it('(selector) : should create element and add as next sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter('.apple');
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('grape')).to.be.ok();
     });
 
     it('(selector) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter('.apple, .pear');
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('grape')).to.be.ok();
+      expect($('.pear').next().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter($('.apple'));
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertAfter($('.apple, .pear'));
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .next()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('grape')).to.be.ok();
+      expect($('.pear').next().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create all elements in the array and add as next siblings', function() {
       var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>');
       more.insertAfter($('.apple'));
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('apple')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('grape')).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
       $('.orange').insertAfter('.pear');
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('orange')
-      ).to.not.be.ok();
+      expect($fruits.children().eq(1).hasClass('orange')).to.not.be.ok();
       expect($fruits.children().length).to.be(3);
       expect($('.orange').length).to.be(1);
     });
 
     it('(existing Node) : should update original direct siblings', function() {
       $('.orange').insertAfter('.pear');
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('pear')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .prev()
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .next()
-          .hasClass('orange')
-      ).to.be.ok();
+      expect($('.apple').next().hasClass('pear')).to.be.ok();
+      expect($('.pear').prev().hasClass('apple')).to.be.ok();
+      expect($('.pear').next().hasClass('orange')).to.be.ok();
       expect($('.orange').next()).to.be.empty();
     });
 
     it('(existing Node) : should update original direct siblings of multiple elements', function() {
       $('.apple').insertAfter('.orange, .pear');
       expect($('.orange').prev()).to.be.empty();
-      expect(
-        $('.orange')
-          .next()
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .next()
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .prev()
-          .hasClass('apple')
-      ).to.be.ok();
+      expect($('.orange').next().hasClass('apple')).to.be.ok();
+      expect($('.pear').next().hasClass('apple')).to.be.ok();
+      expect($('.pear').prev().hasClass('apple')).to.be.ok();
       expect($fruits.children().length).to.be(4);
       var apples = $('.apple');
       expect(apples.length).to.be(2);
-      expect(
-        apples
-          .eq(0)
-          .prev()
-          .hasClass('orange')
-      ).to.be.ok();
-      expect(
-        apples
-          .eq(1)
-          .prev()
-          .hasClass('pear')
-      ).to.be.ok();
+      expect(apples.eq(0).prev().hasClass('orange')).to.be.ok();
+      expect(apples.eq(1).prev().hasClass('pear')).to.be.ok();
     });
 
     it('(elem) : should handle if removed', function() {
@@ -1124,9 +802,7 @@ describe('$(...)', function() {
     });
 
     it('(single) should return the new elements for chaining', function() {
-      var $purple = $(
-        '<li class="grape">Grape</li><li class="plum">Plum</li>'
-      ).insertAfter('.apple');
+      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertAfter('.apple');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(2);
@@ -1135,9 +811,7 @@ describe('$(...)', function() {
     });
 
     it('(multiple) should return the new elements for chaining', function() {
-      var $purple = $(
-        '<li class="grape">Grape</li><li class="plum">Plum</li>'
-      ).insertAfter('.apple, .pear');
+      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertAfter('.apple, .pear');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(4);
@@ -1175,9 +849,11 @@ describe('$(...)', function() {
       expect($things.eq(2).hasClass('apple')).to.be.ok();
       expect($things.eq(3).hasClass('orange')).to.be.ok();
     });
+
   });
 
   describe('.before', function() {
+
     it('() : should do nothing', function() {
       expect($('#fruits').before()[0].tagName).to.equal('ul');
     });
@@ -1185,31 +861,19 @@ describe('$(...)', function() {
     it('(html) : should add element as previous sibling', function() {
       var grape = '<li class="grape">Grape</li>';
       $('.apple').before(grape);
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should add element as previous sibling', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.apple').before($plum);
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('plum')).to.be.ok();
     });
 
     it('(Node) : should add element as previous sibling', function() {
       var plum = $('<li class="plum">Plum</li>')[0];
       $('.apple').before(plum);
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('plum')).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
@@ -1234,26 +898,10 @@ describe('$(...)', function() {
       $('.apple, .orange').before($originalPear);
 
       expect($('.pear')).to.have.length(2);
-      expect(
-        $('.pear')
-          .eq(0)
-          .prev()
-      ).to.have.length(0);
-      expect(
-        $('.pear')
-          .eq(0)
-          .next()[0]
-      ).to.be($('.apple')[0]);
-      expect(
-        $('.pear')
-          .eq(1)
-          .prev()[0]
-      ).to.be($('.apple')[0]);
-      expect(
-        $('.pear')
-          .eq(1)
-          .next()[0]
-      ).to.be($('.orange')[0]);
+      expect($('.pear').eq(0).prev()).to.have.length(0);
+      expect($('.pear').eq(0).next()[0]).to.be($('.apple')[0]);
+      expect($('.pear').eq(1).prev()[0]).to.be($('.apple')[0]);
+      expect($('.pear').eq(1).next()[0]).to.be($('.orange')[0]);
       expect($('.pear')[0]).to.not.eql($originalPear[0]);
       expect($('.pear')[1]).to.eql($originalPear[0]);
     });
@@ -1268,38 +916,19 @@ describe('$(...)', function() {
     });
 
     it('(Array) : should add all elements in the array as previous sibling', function() {
-      var more = $(
-        '<li class="plum">Plum</li><li class="grape">Grape</li>'
-      ).get();
+      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
+        .get();
       $('.apple').before(more);
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
     });
 
     it('($(...), html) : should add multiple elements as previous siblings', function() {
       var $plum = $('<li class="plum">Plum</li>');
       var grape = '<li class="grape">Grape</li>';
       $('.apple').before($plum, grape);
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $('.grape')
-          .prev()
-          .hasClass('plum')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect($('.grape').prev().hasClass('plum')).to.be.ok();
     });
 
     it('(fn) : should invoke the callback with the correct arguments and context', function() {
@@ -1313,7 +942,11 @@ describe('$(...)', function() {
       });
 
       expect(args).to.eql([[0, 'Apple'], [1, 'Orange'], [2, 'Pear']]);
-      expect(thisValues).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(thisValues).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
     });
 
     it('(fn) : should add returned string as previous sibling', function() {
@@ -1364,144 +997,67 @@ describe('$(...)', function() {
   });
 
   describe('.insertBefore', function() {
+
     it('(selector) : should create element and add as prev sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore('.apple');
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
     });
 
     it('(selector) : should create element and add as prev sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore('.apple, .pear');
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect($('.pear').prev().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create element and add as prev sibling', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore($('.apple'));
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create element and add as next sibling of multiple elements', function() {
       var grape = $('<li class="grape">Grape</li>');
       grape.insertBefore($('.apple, .pear'));
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .prev()
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('grape')).to.be.ok();
+      expect($('.pear').prev().hasClass('grape')).to.be.ok();
     });
 
     it('($(...)) : should create all elements in the array and add as prev siblings', function() {
       var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>');
       more.insertBefore($('.apple'));
-      expect(
-        $fruits
-          .children()
-          .eq(0)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(1)
-          .hasClass('grape')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('apple')
-      ).to.be.ok();
+      expect($fruits.children().eq(0).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(1).hasClass('grape')).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('apple')).to.be.ok();
     });
 
     it('(existing Node) : should remove existing nodes from previous locations', function() {
       $('.pear').insertBefore('.apple');
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('pear')
-      ).to.not.be.ok();
+      expect($fruits.children().eq(2).hasClass('pear')).to.not.be.ok();
       expect($fruits.children().length).to.be(3);
       expect($('.pear').length).to.be(1);
     });
 
     it('(existing Node) : should update original direct siblings', function() {
       $('.pear').insertBefore('.apple');
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('pear')
-      ).to.be.ok();
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('orange')
-      ).to.be.ok();
-      expect(
-        $('.pear')
-          .next()
-          .hasClass('apple')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('pear')).to.be.ok();
+      expect($('.apple').next().hasClass('orange')).to.be.ok();
+      expect($('.pear').next().hasClass('apple')).to.be.ok();
       expect($('.pear').prev()).to.be.empty();
     });
 
     it('(existing Node) : should update original direct siblings of multiple elements', function() {
       $('.pear').insertBefore('.apple, .orange');
-      expect(
-        $('.apple')
-          .prev()
-          .hasClass('pear')
-      ).to.be.ok();
-      expect(
-        $('.apple')
-          .next()
-          .hasClass('pear')
-      ).to.be.ok();
-      expect(
-        $('.orange')
-          .prev()
-          .hasClass('pear')
-      ).to.be.ok();
+      expect($('.apple').prev().hasClass('pear')).to.be.ok();
+      expect($('.apple').next().hasClass('pear')).to.be.ok();
+      expect($('.orange').prev().hasClass('pear')).to.be.ok();
       expect($('.orange').next()).to.be.empty();
       expect($fruits.children().length).to.be(4);
       var pears = $('.pear');
       expect(pears.length).to.be(2);
-      expect(
-        pears
-          .eq(0)
-          .next()
-          .hasClass('apple')
-      ).to.be.ok();
-      expect(
-        pears
-          .eq(1)
-          .next()
-          .hasClass('orange')
-      ).to.be.ok();
+      expect(pears.eq(0).next().hasClass('apple')).to.be.ok();
+      expect(pears.eq(1).next().hasClass('orange')).to.be.ok();
     });
 
     it('(elem) : should handle if removed', function() {
@@ -1522,9 +1078,7 @@ describe('$(...)', function() {
     });
 
     it('(single) should return the new elements for chaining', function() {
-      var $purple = $(
-        '<li class="grape">Grape</li><li class="plum">Plum</li>'
-      ).insertBefore('.apple');
+      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertBefore('.apple');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(2);
@@ -1533,9 +1087,7 @@ describe('$(...)', function() {
     });
 
     it('(multiple) should return the new elements for chaining', function() {
-      var $purple = $(
-        '<li class="grape">Grape</li><li class="plum">Plum</li>'
-      ).insertBefore('.apple, .pear');
+      var $purple = $('<li class="grape">Grape</li><li class="plum">Plum</li>').insertBefore('.apple, .pear');
       expect($purple.cheerio).to.be.ok();
       expect($purple.each).to.be.ok();
       expect($purple.length).to.be(4);
@@ -1573,9 +1125,11 @@ describe('$(...)', function() {
       expect($things.eq(2).hasClass('apple')).to.be.ok();
       expect($things.eq(3).hasClass('orange')).to.be.ok();
     });
+
   });
 
   describe('.remove', function() {
+
     it('() : should remove selected elements', function() {
       $('.apple').remove();
       expect($fruits.find('.apple')).to.have.length(0);
@@ -1605,39 +1159,21 @@ describe('$(...)', function() {
   });
 
   describe('.replaceWith', function() {
+
     it('(elem) : should replace one <li> tag with another', function() {
       var $plum = $('<li class="plum">Plum</li>');
       $('.pear').replaceWith($plum);
-      expect(
-        $('.orange')
-          .next()
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $('.orange')
-          .next()
-          .html()
-      ).to.equal('Plum');
+      expect($('.orange').next().hasClass('plum')).to.be.ok();
+      expect($('.orange').next().html()).to.equal('Plum');
     });
 
     it('(Array) : should replace one <li> tag with the elements in the array', function() {
-      var more = $(
-        '<li class="plum">Plum</li><li class="grape">Grape</li>'
-      ).get();
+      var more = $('<li class="plum">Plum</li><li class="grape">Grape</li>')
+        .get();
       $('.pear').replaceWith(more);
 
-      expect(
-        $fruits
-          .children()
-          .eq(2)
-          .hasClass('plum')
-      ).to.be.ok();
-      expect(
-        $fruits
-          .children()
-          .eq(3)
-          .hasClass('grape')
-      ).to.be.ok();
+      expect($fruits.children().eq(2).hasClass('plum')).to.be.ok();
+      expect($fruits.children().eq(3).hasClass('grape')).to.be.ok();
       expect($fruits.children()).to.have.length(4);
     });
 
@@ -1663,11 +1199,7 @@ describe('$(...)', function() {
 
       $pear.remove();
       $pear.replaceWith($plum);
-      expect(
-        $('.orange')
-          .next()
-          .hasClass('plum')
-      ).to.not.be.ok();
+      expect($('.orange').next().hasClass('plum')).to.not.be.ok();
     });
 
     it('(elem) : should replace the single selected element with given element', function() {
@@ -1774,7 +1306,7 @@ describe('$(...)', function() {
       expect($fruits.children()).to.have.length(4);
     });
 
-    it("() : should destroy children's references to the parent", function() {
+    it('() : should destroy children\'s references to the parent', function() {
       var $children = $fruits.children();
 
       $fruits.empty();
@@ -1789,17 +1321,17 @@ describe('$(...)', function() {
       expect($children.eq(2).next()).to.have.length(0);
       expect($children.eq(2).prev()).to.have.length(0);
     });
+
   });
 
   describe('.html', function() {
+
     it('() : should get the innerHTML for an element', function() {
-      expect($fruits.html()).to.equal(
-        [
-          '<li class="apple">Apple</li>',
-          '<li class="orange">Orange</li>',
-          '<li class="pear">Pear</li>'
-        ].join('')
-      );
+      expect($fruits.html()).to.equal([
+        '<li class="apple">Apple</li>',
+        '<li class="orange">Orange</li>',
+        '<li class="pear">Pear</li>'
+      ].join(''));
     });
 
     it('() : should get innerHTML even if its just text', function() {
@@ -1822,13 +1354,8 @@ describe('$(...)', function() {
       $fruits = $('li');
       $fruits.html('<li class="durian">Durian</li>');
       var tested = 0;
-      $fruits.each(function() {
-        expect(
-          $(this)
-            .children()
-            .parent()
-            .get(0)
-        ).to.equal(this);
+      $fruits.each(function(){
+        expect($(this).children().parent().get(0)).to.equal(this);
         tested++;
       });
       expect(tested).to.equal(3);
@@ -1859,9 +1386,7 @@ describe('$(...)', function() {
     });
 
     it('() : should return an html string for a set of elements', function() {
-      expect($fruits.find('li').toString()).to.equal(
-        '<li class="apple">Apple</li><li class="orange">Orange</li><li class="pear">Pear</li>'
-      );
+      expect($fruits.find('li').toString()).to.equal('<li class="apple">Apple</li><li class="orange">Orange</li><li class="pear">Pear</li>');
     });
 
     it('() : should be called implicitly', function() {
@@ -1870,12 +1395,13 @@ describe('$(...)', function() {
     });
 
     it('() : should pass options', function() {
-      var dom = cheerio.load('&', { xml: { decodeEntities: false } });
+      var dom = cheerio.load('&', {decodeEntities: false});
       expect(dom.root().toString()).to.equal('&');
     });
   });
 
   describe('.text', function() {
+
     it('() : gets the text for a single element', function() {
       expect($('.apple').text()).to.equal('Apple');
     });
@@ -1892,25 +1418,13 @@ describe('$(...)', function() {
     it('(text) : inserts separate nodes for all children', function() {
       $('li').text('Fruits');
       var tested = 0;
-      $('li').each(function() {
-        expect(this.childNodes[0].parentNode).to.equal(this);
+      $('li').each(function(){
+        expect(this.childNodes[0].parent).to.equal(this);
         tested++;
       });
       expect(tested).to.equal(3);
     });
 
-    it('(text) : should create a Node with the DOM level 1 API', function() {
-      var $apple = $('.apple');
-      var textNode;
-
-      $apple.text('anything');
-      textNode = $apple[0].childNodes[0];
-
-      expect(textNode.parentNode).to.be($apple[0]);
-      expect(textNode.nodeType).to.be(3);
-      expect(textNode.data).to.be('anything');
-    });
-
     it('should allow functions as arguments', function() {
       $('.apple').text(function(idx, content) {
         expect(idx).to.equal(0);
@@ -1920,15 +1434,6 @@ describe('$(...)', function() {
       expect($('.apple')[0].childNodes[0].data).to.equal('whatever mate');
     });
 
-    it('should allow functions as arguments for multiple elements', function() {
-      $('li').text(function(idx) {
-        return 'text' + idx;
-      });
-      $('li').each(function(idx) {
-        expect(this.childNodes[0].data).to.equal('text' + idx);
-      });
-    });
-
     it('should decode special chars', function() {
       var text = $('<p>M&amp;M</p>').text();
       expect(text).to.equal('M&M');
@@ -1951,34 +1456,23 @@ describe('$(...)', function() {
     });
 
     it('( null ) : should convert to string', function() {
-      expect(
-        $('<div>')
-          .text(null)
-          .text()
-      ).to.equal('null');
+      expect($('<div>').text(null).text()).to.equal('null');
     });
 
     it('( 0 ) : should convert to string', function() {
-      expect(
-        $('<div>')
-          .text(0)
-          .text()
-      ).to.equal('0');
+      expect($('<div>').text(0).text()).to.equal('0');
     });
 
     it('(str) should encode then decode unsafe characters', function() {
       var $apple = $('.apple');
 
       $apple.text('blah <script>alert("XSS!")</script> blah');
-      expect($apple[0].childNodes[0].data).to.equal(
-        'blah <script>alert("XSS!")</script> blah'
-      );
-      expect($apple.text()).to.equal(
-        'blah <script>alert("XSS!")</script> blah'
-      );
+      expect($apple[0].childNodes[0].data).to.equal('blah <script>alert("XSS!")</script> blah');
+      expect($apple.text()).to.equal('blah <script>alert("XSS!")</script> blah');
 
       $apple.text('blah <script>alert("XSS!")</script> blah');
       expect($apple.html()).to.not.contain('<script>alert("XSS!")</script>');
     });
   });
+
 });
diff --git a/test/api/traversing.js b/test/api/traversing.js
index 61e018d668..06a969ca42 100644
--- a/test/api/traversing.js
+++ b/test/api/traversing.js
@@ -1,30 +1,20 @@
-/*global Symbol*/
 var expect = require('expect.js'),
-    cheerio = require('../..'),
-    food = require('../fixtures').food,
-    fruits = require('../fixtures').fruits,
-    drinks = require('../fixtures').drinks,
-    text = require('../fixtures').text;
+  cheerio = require('../..'),
+  food = require('../fixtures').food,
+  fruits = require('../fixtures').fruits,
+  drinks = require('../fixtures').drinks,
+  text = require('../fixtures').text;
 
 describe('$(...)', function() {
+
   var $;
 
   beforeEach(function() {
     $ = cheerio.load(fruits);
   });
 
-  describe('.load', function() {
-    it('should throw a TypeError if given invalid input', function() {
-      expect(function() {
-        cheerio.load();
-      }).to.throwException(function(err) {
-        expect(err).to.be.an(Error);
-        expect(err.message).to.be('cheerio.load() expects a string');
-      });
-    });
-  });
-
   describe('.find', function() {
+
     it('() : should find nothing', function() {
       expect($('ul').find()).to.have.length(0);
     });
@@ -62,19 +52,19 @@ describe('$(...)', function() {
       expect(q('foo').find('> bar')).to.have.length(1);
     });
 
-    it('should query case-sensitively when in xml mode', function() {
-      var q = cheerio.load('<caseSenSitive allTheWay>', { xml: true });
+    it('should query case-sensitively when in xmlMode', function() {
+      var q = cheerio.load('<caseSenSitive allTheWay>', {xmlMode: true});
       expect(q('caseSenSitive')).to.have.length(1);
       expect(q('[allTheWay]')).to.have.length(1);
       expect(q('casesensitive')).to.have.length(0);
       expect(q('[alltheway]')).to.have.length(0);
     });
 
-    it('should throw an Error if given an invalid selector', function() {
+    it('should throw a SyntaxError if given an invalid selector', function() {
       expect(function() {
         $('#fruits').find(':bah');
       }).to.throwException(function(err) {
-        expect(err).to.be.a(Error);
+        expect(err).to.be.a(SyntaxError);
       });
     });
 
@@ -123,6 +113,7 @@ describe('$(...)', function() {
   });
 
   describe('.children', function() {
+
     it('() : should get all children', function() {
       expect($('ul').children()).to.have.length(3);
     });
@@ -143,9 +134,11 @@ describe('$(...)', function() {
     it('should only match immediate children, not ancestors', function() {
       expect($(food).children('li')).to.have.length(0);
     });
+
   });
 
   describe('.contents', function() {
+
     beforeEach(function() {
       $ = cheerio.load(text);
     });
@@ -155,23 +148,17 @@ describe('$(...)', function() {
     });
 
     it('() : should include text nodes', function() {
-      expect(
-        $('p')
-          .contents()
-          .first()[0].type
-      ).to.equal('text');
+      expect($('p').contents().first()[0].type).to.equal('text');
     });
 
     it('() : should include comment nodes', function() {
-      expect(
-        $('p')
-          .contents()
-          .last()[0].type
-      ).to.equal('comment');
+      expect($('p').contents().last()[0].type).to.equal('comment');
     });
+
   });
 
   describe('.next', function() {
+
     it('() : should return next element', function() {
       var cls = $('.orange').next()[0].attribs['class'];
       expect(cls).to.equal('pear');
@@ -198,9 +185,11 @@ describe('$(...)', function() {
         expect($('.apple').next('.orange')).to.have.length(1);
       });
     });
+
   });
 
   describe('.nextAll', function() {
+
     it('() : should return all following siblings', function() {
       var elems = $('.apple').nextAll();
       expect(elems).to.have.length(2);
@@ -230,13 +219,15 @@ describe('$(...)', function() {
         expect($('.apple').nextAll('.pear')).to.have.length(1);
       });
 
-      it("should not consider siblings' contents when filtering", function() {
+      it('should not consider siblings\' contents when filtering', function() {
         expect($('#fruits', food).nextAll('li')).to.have.length(0);
       });
     });
+
   });
 
   describe('.nextUntil', function() {
+
     it('() : should return all following siblings if no selector specified', function() {
       var elems = $('.apple', food).nextUntil();
       expect(elems).to.have.length(2);
@@ -279,10 +270,7 @@ describe('$(...)', function() {
 
     it('(null, filterString) : should return all following siblings until selector, filtered by filter', function() {
       var elems = $('<ul><li></li><li><p></p></li></ul>');
-      var empty = elems
-        .find('li')
-        .eq(0)
-        .nextUntil(null, 'p');
+      var empty = elems.find('li').eq(0).nextUntil(null, 'p');
       expect(empty).to.have.length(0);
     });
 
@@ -306,9 +294,11 @@ describe('$(...)', function() {
       var elems = $drinks.eq(0).nextUntil($until);
       expect(elems).to.have.length(2);
     });
+
   });
 
   describe('.prev', function() {
+
     it('() : should return previous element', function() {
       var cls = $('.orange').prev()[0].attribs['class'];
       expect(cls).to.equal('apple');
@@ -335,9 +325,11 @@ describe('$(...)', function() {
         expect($('.orange').prev('.apple')).to.have.length(1);
       });
     });
+
   });
 
   describe('.prevAll', function() {
+
     it('() : should return all preceding siblings', function() {
       var elems = $('.pear').prevAll();
       expect(elems).to.have.length(2);
@@ -368,14 +360,16 @@ describe('$(...)', function() {
         expect(elems).to.have.length(1);
       });
 
-      it("should not consider siblings's descendents", function() {
+      it('should not consider siblings\'s descendents', function() {
         var elems = $('#vegetables', food).prevAll('li');
         expect(elems).to.have.length(0);
       });
     });
+
   });
 
   describe('.prevUntil', function() {
+
     it('() : should return all preceding siblings if no selector specified', function() {
       var elems = $('.pear').prevUntil();
       expect(elems).to.have.length(2);
@@ -384,9 +378,7 @@ describe('$(...)', function() {
     });
 
     it('() : should filter out non-element nodes', function() {
-      var elems = $(
-        '<div class="1"><div class="2"></div><!-- comment -->text<div class="3"></div></div>'
-      );
+      var elems = $('<div class="1"><div class="2"></div><!-- comment -->text<div class="3"></div></div>');
       var div = elems.children().last();
       expect(div.prevUntil()).to.have.length(1);
     });
@@ -421,10 +413,7 @@ describe('$(...)', function() {
 
     it('(selector, filterString) : should return all preceding siblings until selector', function() {
       var elems = $('<ul><li><p></p></li><li></li></ul>');
-      var empty = elems
-        .find('li')
-        .eq(1)
-        .prevUntil(null, 'p');
+      var empty = elems.find('li').eq(1).prevUntil(null, 'p');
       expect(empty).to.have.length(0);
     });
 
@@ -448,9 +437,11 @@ describe('$(...)', function() {
       var elems = $drinks.eq(4).prevUntil($until);
       expect(elems).to.have.length(2);
     });
+
   });
 
   describe('.siblings', function() {
+
     it('() : should get all the siblings', function() {
       expect($('.orange').siblings()).to.have.length(2);
       expect($('#fruits').siblings()).to.have.length(0);
@@ -462,36 +453,34 @@ describe('$(...)', function() {
       expect($('.orange').siblings('.peach')).to.have.length(0);
     });
 
-    it('(selector) : should throw an Error if given an invalid selector', function() {
+    it('(selector) : should throw a SyntaxError if given an invalid selector', function() {
       expect(function() {
         $('.orange').siblings(':bah');
       }).to.throwException(function(err) {
-        expect(err).to.be.a(Error);
+        expect(err).to.be.a(SyntaxError);
       });
     });
 
     it('(selector) : does not consider the contents of siblings when filtering (GH-374)', function() {
       expect($('#fruits', food).siblings('li')).to.have.length(0);
     });
+
   });
 
   describe('.parents', function() {
+
     beforeEach(function() {
       $ = cheerio.load(food);
     });
 
-    it('() : should get all of the parents in logical order', function() {
+    it('() : should get all of the parents in logical order', function(){
       var result = $('.orange').parents();
-      expect(result).to.have.length(4);
+      expect(result).to.have.length(2);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
-      expect(result[2].tagName).to.be('body');
-      expect(result[3].tagName).to.be('html');
       result = $('#fruits').parents();
-      expect(result).to.have.length(3);
+      expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('food');
-      expect(result[1].tagName).to.be('body');
-      expect(result[2].tagName).to.be('html');
     });
 
     it('(selector) : should get all of the parents that match the selector in logical order', function() {
@@ -510,44 +499,40 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty set for top-level elements', function() {
-      var result = $('html').parents();
+      var result = $('#food').parents();
       expect(result).to.have.length(0);
     });
 
     it('() : should return the parents of every element in the *reveresed* collection, omitting duplicates', function() {
       var $parents = $('li').parents();
 
-      expect($parents).to.have.length(5);
+      expect($parents).to.have.length(3);
       expect($parents[0]).to.be($('#vegetables')[0]);
       expect($parents[1]).to.be($('#food')[0]);
-      expect($parents[2]).to.be($('body')[0]);
-      expect($parents[3]).to.be($('html')[0]);
-      expect($parents[4]).to.be($('#fruits')[0]);
+      expect($parents[2]).to.be($('#fruits')[0]);
     });
+
   });
 
   describe('.parentsUntil', function() {
+
     beforeEach(function() {
       $ = cheerio.load(food);
     });
 
     it('() : should get all of the parents in logical order', function() {
       var result = $('.orange').parentsUntil();
-      expect(result).to.have.length(4);
+      expect(result).to.have.length(2);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
-      expect(result[2].tagName).to.be('body');
-      expect(result[3].tagName).to.be('html');
     });
 
     it('() : should get all of the parents in reversed order, omitting duplicates', function() {
       var result = $('.apple, .sweetcorn').parentsUntil();
-      expect(result).to.have.length(5);
+      expect(result).to.have.length(3);
       expect(result[0].attribs.id).to.be('vegetables');
       expect(result[1].attribs.id).to.be('food');
-      expect(result[2].tagName).to.be('body');
-      expect(result[3].tagName).to.be('html');
-      expect(result[4].attribs.id).to.be('fruits');
+      expect(result[2].attribs.id).to.be('fruits');
     });
 
     it('(selector) : should get all of the parents until selector', function() {
@@ -560,18 +545,13 @@ describe('$(...)', function() {
 
     it('(selector not parent) : should return all parents', function() {
       var result = $('.orange').parentsUntil('.apple');
-      expect(result).to.have.length(4);
+      expect(result).to.have.length(2);
       expect(result[0].attribs.id).to.be('fruits');
       expect(result[1].attribs.id).to.be('food');
-      expect(result[2].tagName).to.be('body');
-      expect(result[3].tagName).to.be('html');
     });
 
     it('(selector, filter) : should get all of the parents that match the filter', function() {
-      var result = $('.apple, .sweetcorn').parentsUntil(
-        '.saladbar',
-        '#vegetables'
-      );
+      var result = $('.apple, .sweetcorn').parentsUntil('.saladbar', '#vegetables');
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('vegetables');
     });
@@ -582,23 +562,22 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty set for top-level elements', function() {
-      var result = $('html').parentsUntil();
+      var result = $('#food').parentsUntil();
       expect(result).to.have.length(0);
     });
 
     it('(cheerio object) : should return all parents until any member of the cheerio object', function() {
       var $fruits = $('#fruits');
       var $until = $('#food');
-      var result = $fruits
-        .children()
-        .eq(1)
-        .parentsUntil($until);
+      var result = $fruits.children().eq(1).parentsUntil($until);
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('fruits');
     });
+
   });
 
   describe('.parent', function() {
+
     it('() : should return the parent of each matched element', function() {
       var result = $('.orange').parent();
       expect(result).to.have.length(1);
@@ -610,7 +589,7 @@ describe('$(...)', function() {
     });
 
     it('() : should return an empty object for top-level elements', function() {
-      var result = $('html').parent();
+      var result = $('ul').parent();
       expect(result).to.have.length(0);
     });
 
@@ -627,9 +606,11 @@ describe('$(...)', function() {
       expect(result).to.have.length(1);
       expect(result[0].attribs.id).to.be('fruits');
     });
+
   });
 
   describe('.closest', function() {
+
     it('() : should return an empty array', function() {
       var result = $('.orange').closest();
       expect(result).to.have.length(0);
@@ -655,9 +636,11 @@ describe('$(...)', function() {
       var result = $('.saladbar', food).closest('ul');
       expect(result).to.have.length(0);
     });
+
   });
 
   describe('.each', function() {
+
     it('( (i, elem) -> ) : should loop selected returning fn with (i, elem)', function() {
       var items = [],
           classes = ['apple', 'orange', 'pear'];
@@ -679,22 +662,8 @@ describe('$(...)', function() {
 
       expect(iterationCount).to.equal(2);
     });
-  });
 
-  if (typeof Symbol !== 'undefined') {
-    describe('[Symbol.iterator]', function() {
-
-      it('should yield each element', function() {
-        // The equivalent of: for (const element of $('li')) ...
-        var $li = $('li'),
-            iterator = $li[Symbol.iterator]();
-        expect(iterator.next().value.attribs['class']).to.equal('apple');
-        expect(iterator.next().value.attribs['class']).to.equal('orange');
-        expect(iterator.next().value.attribs['class']).to.equal('pear');
-        expect(iterator.next().done).to.equal(true);
-      });
-    });
-  }
+  });
 
   describe('.map', function() {
     it('(fn) : should be invoked with the correct arguments and context', function() {
@@ -707,8 +676,16 @@ describe('$(...)', function() {
         thisVals.push(this);
       });
 
-      expect(args).to.eql([[0, $fruits[0]], [1, $fruits[1]], [2, $fruits[2]]]);
-      expect(thisVals).to.eql([$fruits[0], $fruits[1], $fruits[2]]);
+      expect(args).to.eql([
+        [0, $fruits[0]],
+        [1, $fruits[1]],
+        [2, $fruits[2]]
+      ]);
+      expect(thisVals).to.eql([
+        $fruits[0],
+        $fruits[1],
+        $fruits[2]
+      ]);
     });
 
     it('(fn) : should return an Cheerio object wrapping the returned items', function() {
@@ -742,7 +719,11 @@ describe('$(...)', function() {
         return [1, [3, 4]];
       });
 
-      expect($mapped.get()).to.eql([1, [3, 4], 1, [3, 4], 1, [3, 4]]);
+      expect($mapped.get()).to.eql([
+        1, [3, 4],
+        1, [3, 4],
+        1, [3, 4]
+      ]);
     });
 
     it('(fn) : should tolerate `null` and `undefined` when flattening arrays returned by iterator', function() {
@@ -753,21 +734,16 @@ describe('$(...)', function() {
       });
 
       expect($mapped.get()).to.eql([
-        null,
-        undefined,
-        null,
-        undefined,
-        null,
-        undefined
+        null, undefined,
+        null, undefined,
+        null, undefined,
       ]);
     });
   });
 
   describe('.filter', function() {
     it('(selector) : should reduce the set of matched elements to those that match the selector', function() {
-      var pear = $('li')
-        .filter('.pear')
-        .text();
+      var pear = $('li').filter('.pear').text();
       expect(pear).to.be('Pear');
     });
 
@@ -788,15 +764,13 @@ describe('$(...)', function() {
       expect($fruits.filter(pear)).to.have.length(1);
     });
 
-    it("(fn) : should reduce the set of matched elements to those that pass the function's test", function() {
-      var orange = $('li')
-        .filter(function(i, el) {
-          expect(this).to.be(el);
-          expect(el.tagName).to.be('li');
-          expect(i).to.be.a('number');
-          return $(this).attr('class') === 'orange';
-        })
-        .text();
+    it('(fn) : should reduce the set of matched elements to those that pass the function\'s test', function() {
+      var orange = $('li').filter(function(i, el) {
+        expect(this).to.be(el);
+        expect(el.tagName).to.be('li');
+        expect(i).to.be.a('number');
+        return $(this).attr('class') === 'orange';
+      }).text();
 
       expect(orange).to.be('Orange');
     });
@@ -840,7 +814,7 @@ describe('$(...)', function() {
       expect($notApple[1]).to.be($fruits[2]);
     });
 
-    it("(fn) : should reduce the set of matched elements to those that do not pass the function's test", function() {
+    it('(fn) : should reduce the set of matched elements to those that do not pass the function\'s test', function() {
       var $fruits = $('li');
 
       var $notOrange = $fruits.not(function(i, el) {
@@ -857,6 +831,7 @@ describe('$(...)', function() {
   });
 
   describe('.has', function() {
+
     beforeEach(function() {
       $ = cheerio.load(food);
     });
@@ -888,6 +863,7 @@ describe('$(...)', function() {
   });
 
   describe('.first', function() {
+
     it('() : should return the first item', function() {
       var $src = $('<span>foo</span><span>bar</span><span>baz</span>');
       var $elem = $src.first();
@@ -901,9 +877,11 @@ describe('$(...)', function() {
       expect($first.length).to.equal(0);
       expect($first[0]).to.be(undefined);
     });
+
   });
 
   describe('.last', function() {
+
     it('() : should return the last element', function() {
       var $src = $('<span>foo</span><span>bar</span><span>baz</span>');
       var $elem = $src.last();
@@ -917,9 +895,11 @@ describe('$(...)', function() {
       expect($last.length).to.equal(0);
       expect($last[0]).to.be(undefined);
     });
+
   });
 
   describe('.first & .last', function() {
+
     it('() : should return equivalent collections if only one element', function() {
       var $src = $('<span>bar</span>');
       var $first = $src.first();
@@ -930,11 +910,13 @@ describe('$(...)', function() {
       expect($last[0].childNodes[0].data).to.equal('bar');
       expect($first[0]).to.equal($last[0]);
     });
+
   });
 
   describe('.eq', function() {
+
     function getText(el) {
-      if (!el.length) return '';
+      if(!el.length) return '';
       return el[0].childNodes[0].data;
     }
 
@@ -945,9 +927,11 @@ describe('$(...)', function() {
       expect(getText($('li').eq(3))).to.equal('');
       expect(getText($('li').eq(-1))).to.equal('Pear');
     });
+
   });
 
   describe('.get', function() {
+
     it('(i) : should return the element at the specified index', function() {
       var children = $('#fruits').children();
       expect(children.get(0)).to.be(children[0]);
@@ -966,8 +950,13 @@ describe('$(...)', function() {
       var children = $('#fruits').children();
       var all = children.get();
       expect(Array.isArray(all)).to.be.ok();
-      expect(all).to.eql([children[0], children[1], children[2]]);
+      expect(all).to.eql([
+        children[0],
+        children[1],
+        children[2]
+      ]);
     });
+
   });
 
   describe('.index', function() {
@@ -1025,8 +1014,9 @@ describe('$(...)', function() {
   });
 
   describe('.slice', function() {
+
     function getText(el) {
-      if (!el.length) return '';
+      if(!el.length) return '';
       return el[0].childNodes[0].data;
     }
 
@@ -1048,6 +1038,7 @@ describe('$(...)', function() {
       expect(sliced).to.have.length(1);
       expect(getText(sliced.eq(0))).to.equal('Pear');
     });
+
   });
 
   describe('.end() :', function() {
@@ -1058,18 +1049,8 @@ describe('$(...)', function() {
     });
 
     it('returns an empty object at the end of the chain', function() {
-      expect(
-        $fruits
-          .end()
-          .end()
-          .end()
-      ).to.be.ok();
-      expect(
-        $fruits
-          .end()
-          .end()
-          .end()
-      ).to.have.length(0);
+      expect($fruits.end().end().end()).to.be.ok();
+      expect($fruits.end().end().end()).to.have.length(0);
     });
     it('find', function() {
       expect($fruits.find('.apple').end()).to.be($fruits);
@@ -1078,13 +1059,7 @@ describe('$(...)', function() {
       expect($fruits.filter('.apple').end()).to.be($fruits);
     });
     it('map', function() {
-      expect(
-        $fruits
-          .map(function() {
-            return this;
-          })
-          .end()
-      ).to.be($fruits);
+      expect($fruits.map(function() { return this; }).end()).to.be($fruits);
     });
     it('contents', function() {
       expect($fruits.contents().end()).to.be($fruits);
@@ -1398,9 +1373,7 @@ describe('$(...)', function() {
   describe('.addBack', function() {
     describe('() : ', function() {
       it('includes siblings and self', function() {
-        var $selection = $('.orange')
-          .siblings()
-          .addBack();
+        var $selection = $('.orange').siblings().addBack();
 
         expect($selection).to.have.length(3);
         expect($selection[0]).to.be($('.apple')[0]);
@@ -1408,9 +1381,7 @@ describe('$(...)', function() {
         expect($selection[2]).to.be($('.pear')[0]);
       });
       it('includes children and self', function() {
-        var $selection = $('#fruits')
-          .children()
-          .addBack();
+        var $selection = $('#fruits').children().addBack();
 
         expect($selection).to.have.length(4);
         expect($selection[0]).to.be($('#fruits')[0]);
@@ -1419,9 +1390,7 @@ describe('$(...)', function() {
         expect($selection[3]).to.be($('.pear')[0]);
       });
       it('includes parent and self', function() {
-        var $selection = $('.apple')
-          .parent()
-          .addBack();
+        var $selection = $('.apple').parent().addBack();
 
         expect($selection).to.have.length(2);
         expect($selection[0]).to.be($('#fruits')[0]);
@@ -1429,22 +1398,16 @@ describe('$(...)', function() {
       });
       it('includes parents and self', function() {
         var q = cheerio.load(food);
-        var $selection = q('.apple')
-          .parents()
-          .addBack();
-
-        expect($selection).to.have.length(5);
-        expect($selection[0]).to.be(q('html')[0]);
-        expect($selection[1]).to.be(q('body')[0]);
-        expect($selection[2]).to.be(q('#food')[0]);
-        expect($selection[3]).to.be(q('#fruits')[0]);
-        expect($selection[4]).to.be(q('.apple')[0]);
+        var $selection = q('.apple').parents().addBack();
+
+        expect($selection).to.have.length(3);
+        expect($selection[0]).to.be(q('#food')[0]);
+        expect($selection[1]).to.be(q('#fruits')[0]);
+        expect($selection[2]).to.be(q('.apple')[0]);
       });
     });
     it('(filter) : filters the previous selection', function() {
-      var $selection = $('li')
-        .eq(1)
-        .addBack('.apple');
+      var $selection = $('li').eq(1).addBack('.apple');
 
       expect($selection).to.have.length(2);
       expect($selection[0]).to.be($('.apple')[0]);
diff --git a/test/api/utils.js b/test/api/utils.js
index 28c0ab7d55..d6983c8a1c 100644
--- a/test/api/utils.js
+++ b/test/api/utils.js
@@ -3,7 +3,9 @@ var expect = require('expect.js'),
     cheerio = require('../..');
 
 describe('cheerio', function() {
+
   describe('.html', function() {
+
     it('() : should return innerHTML; $.html(obj) should return outerHTML', function() {
       var $div = cheerio('div', '<div><span>foo</span><span>bar</span></div>');
       var span = $div.children()[1];
@@ -21,101 +23,95 @@ describe('cheerio', function() {
       var $elem = cheerio('<span>foo</span>').html('');
       expect(cheerio.html($elem)).to.equal('<span></span>');
     });
+
+    it('() : of empty cheerio object should return null', function() {
+      expect(cheerio().html()).to.be(null);
+    });
+
+    it('(selector) : should return the outerHTML of the selected element', function() {
+      var $ = cheerio.load(fixtures.fruits);
+      expect($.html('.pear')).to.equal('<li class="pear">Pear</li>');
+    });
   });
 
+
   describe('.text', function() {
     it('(cheerio object) : should return the text contents of the specified elements', function() {
       var $ = cheerio.load('<a>This is <em>content</em>.</a>');
-      expect(cheerio.text($('a'))).to.equal('This is content.');
+      expect($.text($('a'))).to.equal('This is content.');
     });
 
     it('(cheerio object) : should omit comment nodes', function() {
       var $ = cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
-      expect(cheerio.text($('a'))).to.equal('This is  not a comment.');
+      expect($.text($('a'))).to.equal('This is  not a comment.');
     });
 
     it('(cheerio object) : should include text contents of children recursively', function() {
-      var $ = cheerio.load(
-        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
-      );
-      expect(cheerio.text($('a'))).to.equal(
-        'This is a child with another child and  not a comment followed by one last child and some final text.'
-      );
+      var $ = cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
+      expect($.text($('a'))).to.equal('This is a child with another child and  not a comment followed by one last child and some final text.');
     });
 
     it('() : should return the rendered text content of the root', function() {
-      var $ = cheerio.load(
-        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
-      );
-      expect(cheerio.text($.root())).to.equal(
-        'This is a child with another child and  not a comment followed by one last child and some final text.'
-      );
+      var $ = cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
+      expect($.text()).to.equal('This is a child with another child and  not a comment followed by one last child and some final text.');
     });
 
-    it('(cheerio object) : should omit script tags', function() {
-      var $ = cheerio.load('<script>console.log("test")</script>');
-      expect(cheerio.text($.root())).to.equal('');
+    it('(cheerio object) : should omit script tags', function(){
+       var $ = cheerio.load('<script>console.log("test")</script>');
+       expect($.text()).to.equal('');
     });
 
-    it('(cheerio object) : should omit style tags', function() {
-      var $ = cheerio.load(
-        '<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>'
-      );
-      expect($.text()).to.equal('');
+    it('(cheerio object) : should omit style tags', function(){
+       var $ = cheerio.load('<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>');
+       expect($.text()).to.equal('');
     });
 
-    it('(cheerio object) : should include text contents of children omiting style and script tags', function() {
-      var $ = cheerio.load(
-        '<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>'
-      );
-      expect(cheerio.text($.root())).to.equal(
-        'Welcome Hello, testing text function,End of messege'
-      );
+     it('(cheerio object) : should include text contents of children omiting style and script tags', function(){
+       var $ = cheerio.load('<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>');
+       expect($.text()).to.equal('Welcome Hello, testing text function,End of messege');
     });
+
   });
 
+
   describe('.load', function() {
+
     it('(html) : should retain original root after creating a new node', function() {
-      var $ = cheerio.load('<body><ul id="fruits"></ul></body>');
-      expect($('body')).to.have.length(1);
-      $('<script>');
-      expect($('body')).to.have.length(1);
+      var $html = cheerio.load('<body><ul id="fruits"></ul></body>');
+      expect($html('body')).to.have.length(1);
+      $html('<script>');
+      expect($html('body')).to.have.length(1);
     });
 
     it('(html) : should handle lowercase tag options', function() {
-      var $ = cheerio.load('<BODY><ul id="fruits"></ul></BODY>', {
-        xml: { lowerCaseTags: true }
-      });
-      expect($.html()).to.be('<body><ul id="fruits"/></body>');
+      var $html = cheerio.load('<BODY><ul id="fruits"></ul></BODY>', { lowerCaseTags : true });
+      expect($html.html()).to.be('<body><ul id="fruits"></ul></body>');
     });
 
     it('(html) : should handle the `normalizeWhitepace` option', function() {
-      var $ = cheerio.load('<body><b>foo</b>  <b>bar</b></body>', {
-        xml: { normalizeWhitespace: true }
-      });
-      expect($.html()).to.be('<body><b>foo</b> <b>bar</b></body>');
+      var $html = cheerio.load('<body><b>foo</b>  <b>bar</b></body>', { normalizeWhitespace : true });
+      expect($html.html()).to.be('<body><b>foo</b> <b>bar</b></body>');
     });
 
     // TODO:
     // it('(html) : should handle xml tag option', function() {
-    //   var $ = $.load('<body><script>oh hai</script></body>', { xml : true });
-    //   console.log($('script')[0].type);
-    //   expect($('script')[0].type).to.be('tag');
+    //   var $html = $.load('<body><script>oh hai</script></body>', { xmlMode : true });
+    //   console.log($html('script')[0].type);
+    //   expect($html('script')[0].type).to.be('tag');
     // });
 
     it('(buffer) : should accept a buffer', function() {
-      var $ = cheerio.load(
-        new Buffer('<html><head></head><body>foo</body></html>')
-      );
-      expect($.html()).to.be('<html><head></head><body>foo</body></html>');
+      var $html = cheerio.load(new Buffer('<div>foo</div>'));
+      expect($html.html()).to.be('<div>foo</div>');
     });
+
   });
 
+
   describe('.clone', function() {
+
     it('() : should return a copy', function() {
-      var $src = cheerio(
-        '<div><span>foo</span><span>bar</span><span>baz</span></div>'
-      ).children();
+      var $src = cheerio('<div><span>foo</span><span>bar</span><span>baz</span></div>').children();
       var $elem = $src.clone();
       expect($elem.length).to.equal(3);
       expect($elem.parent()).to.have.length(0);
@@ -124,19 +120,6 @@ describe('cheerio', function() {
       expect($elem.text()).to.not.equal($src.text());
     });
 
-    it('() : should return a copy of document', function() {
-      var $src = cheerio
-        .load('<html><body><div>foo</div>bar</body></html>')
-        .root()
-        .children();
-      var $elem = $src.clone();
-      expect($elem.length).to.equal(1);
-      expect($elem.parent()).to.have.length(0);
-      expect($elem.text()).to.equal($src.text());
-      $src.text('rofl');
-      expect($elem.text()).to.not.equal($src.text());
-    });
-
     it('() : should preserve parsing options', function() {
       var $ = cheerio.load('<div>π</div>', { decodeEntities: false });
       var $div = $('div');
@@ -146,23 +129,22 @@ describe('cheerio', function() {
   });
 
   describe('.parseHTML', function() {
-    var $ = cheerio.load('');
 
     it('() : returns null', function() {
-      expect($.parseHTML()).to.equal(null);
+      expect(cheerio.parseHTML()).to.equal(null);
     });
 
     it('(null) : returns null', function() {
-      expect($.parseHTML(null)).to.equal(null);
+      expect(cheerio.parseHTML(null)).to.equal(null);
     });
 
     it('("") : returns null', function() {
-      expect($.parseHTML('')).to.equal(null);
+      expect(cheerio.parseHTML('')).to.equal(null);
     });
 
     it('(largeHtmlString) : parses large HTML strings', function() {
       var html = new Array(10).join('<div></div>');
-      var nodes = $.parseHTML(html);
+      var nodes = cheerio.parseHTML(html);
 
       expect(nodes.length).to.be.greaterThan(4);
       expect(nodes).to.be.an('array');
@@ -170,49 +152,47 @@ describe('cheerio', function() {
 
     it('("<script>") : ignores scripts by default', function() {
       var html = '<script>undefined()</script>';
-      expect($.parseHTML(html)).to.have.length(0);
+      expect(cheerio.parseHTML(html)).to.have.length(0);
     });
 
     it('("<script>", true) : preserves scripts when requested', function() {
       var html = '<script>undefined()</script>';
-      expect($.parseHTML(html, true)[0].tagName).to.match(/script/i);
+      expect(cheerio.parseHTML(html, true)[0].tagName).to.match(/script/i);
     });
 
     it('("scriptAndNonScript) : preserves non-script nodes', function() {
       var html = '<script>undefined()</script><div></div>';
-      expect($.parseHTML(html)[0].tagName).to.match(/div/i);
+      expect(cheerio.parseHTML(html)[0].tagName).to.match(/div/i);
     });
 
     it('(scriptAndNonScript, true) : Preserves script position', function() {
       var html = '<script>undefined()</script><div></div>';
-      expect($.parseHTML(html, true)[0].tagName).to.match(/script/i);
+      expect(cheerio.parseHTML(html, true)[0].tagName).to.match(/script/i);
     });
 
     it('(text) : returns a text node', function() {
-      expect($.parseHTML('text')[0].type).to.be('text');
+      expect(cheerio.parseHTML('text')[0].type).to.be('text');
     });
 
     it('(\\ttext) : preserves leading whitespace', function() {
-      expect($.parseHTML('\t<div></div>')[0].data).to.equal('\t');
+      expect(cheerio.parseHTML('\t<div></div>')[0].data).to.equal('\t');
     });
 
     it('( text) : Leading spaces are treated as text nodes', function() {
-      expect($.parseHTML(' <div/> ')[0].type).to.be('text');
+      expect(cheerio.parseHTML(' <div/> ')[0].type).to.be('text');
     });
 
     it('(html) : should preserve content', function() {
       var html = '<div>test div</div>';
-      expect(cheerio($.parseHTML(html)[0]).html()).to.equal('test div');
+      expect(cheerio(cheerio.parseHTML(html)[0]).html()).to.equal('test div');
     });
 
     it('(malformedHtml) : should not break', function() {
-      expect($.parseHTML('<span><span>')).to.have.length(1);
+      expect(cheerio.parseHTML('<span><span>')).to.have.length(1);
     });
 
     it('(garbageInput) : should not cause an error', function() {
-      expect(
-        $.parseHTML('<#if><tr><p>This is a test.</p></tr><#/if>') || true
-      ).to.be.ok();
+      expect(cheerio.parseHTML('<#if><tr><p>This is a test.</p></tr><#/if>') || true).to.be.ok();
     });
 
     it('(text) : should return an array that is not effected by DOM manipulation methods', function() {
@@ -225,24 +205,8 @@ describe('cheerio', function() {
     });
   });
 
-  /**
-   * The `.parseHTML` method exported by the Cheerio module is deprecated.
-   *
-   * In order to promote consistency with the jQuery library, users are
-   * encouraged to instead use the static method of the same name as it is
-   * defined on the "loaded" Cheerio factory function. For example:
-   *
-   *     var $ = cheerio.load('');
-   *     $.parseHTML('<b>markup</b>');
-   */
-  describe('.parseHTML - deprecated API', function() {
-    it('(html) : should preserve content', function() {
-      var html = '<div>test div</div>';
-      expect(cheerio(cheerio.parseHTML(html)[0]).html()).to.equal('test div');
-    });
-  });
-
   describe('.contains', function() {
+
     var $;
 
     beforeEach(function() {
@@ -269,15 +233,17 @@ describe('cheerio', function() {
       expect($.contains($fruits[0], $fruits[0])).to.equal(false);
       expect($.contains($vegetables[0], $vegetables[0])).to.equal(false);
     });
+
   });
 
   describe('.root', function() {
+
     it('() : should return a cheerio-wrapped root object', function() {
-      var $ = cheerio.load('<html><head></head><body>foo</body></html>');
-      $.root().append('<div id="test"></div>');
-      expect($.html()).to.equal(
-        '<html><head></head><body>foo</body></html><div id="test"></div>'
-      );
+      var $html = cheerio.load('<div><span>foo</span><span>bar</span></div>');
+      $html.root().append('<div id="test"></div>');
+      expect($html.html()).to.equal('<div><span>foo</span><span>bar</span></div><div id="test"></div>');
     });
+
   });
+
 });
diff --git a/test/cheerio.js b/test/cheerio.js
index a08d8281cf..e477add9d3 100644
--- a/test/cheerio.js
+++ b/test/cheerio.js
@@ -1,6 +1,6 @@
 var expect = require('expect.js'),
     htmlparser2 = require('htmlparser2'),
-    cheerio = require('../'),
+    $ = require('../'),
     fixtures = require('./fixtures'),
     fruits = fixtures.fruits,
     food = fixtures.food,
@@ -13,43 +13,44 @@ var script = '<script src="script.js" type="text/javascript"></script>',
     multiclass = '<p><a class="btn primary" href="#">Save</a></p>';
 
 describe('cheerio', function() {
+
   it('should get the version', function() {
-    expect(/\d+\.\d+\.\d+/.test(cheerio.version)).to.be.ok();
+    expect(/\d+\.\d+\.\d+/.test($.version)).to.be.ok();
   });
 
-  it('cheerio(null) should return be empty', function() {
-    expect(cheerio(null)).to.be.empty();
+  it('$(null) should return be empty', function() {
+    expect($(null)).to.be.empty();
   });
 
-  it('cheerio(undefined) should be empty', function() {
-    expect(cheerio(undefined)).to.be.empty();
+  it('$(undefined) should be empty', function() {
+    expect($(undefined)).to.be.empty();
   });
 
-  it('cheerio(null) should be empty', function() {
-    expect(cheerio('')).to.be.empty();
+  it('$(null) should be empty', function() {
+    expect($('')).to.be.empty();
   });
 
-  it('cheerio(selector) with no context or root should be empty', function() {
-    expect(cheerio('.h2')).to.be.empty();
-    expect(cheerio('#fruits')).to.be.empty();
+  it('$(selector) with no context or root should be empty', function() {
+    expect($('.h2')).to.be.empty();
+    expect($('#fruits')).to.be.empty();
   });
 
-  it('cheerio(node) : should override previously-loaded nodes', function() {
-    var $ = cheerio.load('<div><span></span></div>');
-    var spanNode = $('span')[0];
-    var $span = $(spanNode);
+  it('$(node) : should override previously-loaded nodes', function() {
+    var C = $.load('<div><span></span></div>');
+    var spanNode = C('span')[0];
+    var $span = C(spanNode);
     expect($span[0]).to.equal(spanNode);
   });
 
   it('should be able to create html without a root or context', function() {
-    var $h2 = cheerio('<h2>');
+    var $h2 = $('<h2>');
     expect($h2).to.not.be.empty();
     expect($h2).to.have.length(1);
     expect($h2[0].tagName).to.equal('h2');
   });
 
   it('should be able to create complicated html', function() {
-    var $script = cheerio(script);
+    var $script = $(script);
     expect($script).to.not.be.empty();
     expect($script).to.have.length(1);
     expect($script[0].attribs.src).to.equal('script.js');
@@ -68,52 +69,52 @@ describe('cheerio', function() {
   };
 
   it('should be able to select .apple with only a context', function() {
-    var $apple = cheerio('.apple', fruits);
+    var $apple = $('.apple', fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select .apple with a node as context', function() {
-    var $apple = cheerio('.apple', cheerio(fruits)[0]);
+    var $apple = $('.apple', $(fruits)[0]);
     testAppleSelect($apple);
   });
 
   it('should be able to select .apple with only a root', function() {
-    var $apple = cheerio('.apple', null, fruits);
+    var $apple = $('.apple', null, fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select an id', function() {
-    var $fruits = cheerio('#fruits', null, fruits);
+    var $fruits = $('#fruits', null, fruits);
     expect($fruits).to.have.length(1);
     expect($fruits[0].attribs.id).to.equal('fruits');
   });
 
   it('should be able to select a tag', function() {
-    var $ul = cheerio('ul', fruits);
+    var $ul = $('ul', fruits);
     expect($ul).to.have.length(1);
     expect($ul[0].tagName).to.equal('ul');
   });
 
   it('should accept a node reference as a context', function() {
-    var $elems = cheerio('<div><span></span></div>');
-    expect(cheerio('span', $elems[0])).to.have.length(1);
+    var $elems = $('<div><span></span></div>');
+    expect($('span', $elems[0])).to.have.length(1);
   });
 
   it('should accept an array of node references as a context', function() {
-    var $elems = cheerio('<div><span></span></div>');
-    expect(cheerio('span', $elems.toArray())).to.have.length(1);
+    var $elems = $('<div><span></span></div>');
+    expect($('span', $elems.toArray())).to.have.length(1);
   });
 
   it('should select only elements inside given context (Issue #193)', function() {
-    var $ = cheerio.load(food),
-        $fruits = $('#fruits'),
-        fruitElements = $('li', $fruits);
+    var q = $.load(food),
+        $fruits = q('#fruits'),
+        fruitElements = q('li', $fruits);
 
     expect(fruitElements).to.have.length(3);
   });
 
   it('should be able to select multiple tags', function() {
-    var $fruits = cheerio('li', null, fruits);
+    var $fruits = $('li', null, fruits);
     expect($fruits).to.have.length(3);
     var classes = ['apple', 'orange', 'pear'];
     $fruits.each(function(idx, $fruit) {
@@ -121,34 +122,34 @@ describe('cheerio', function() {
     });
   });
 
-  it('should be able to do: cheerio("#fruits .apple")', function() {
-    var $apple = cheerio('#fruits .apple', fruits);
+  it('should be able to do: $("#fruits .apple")', function() {
+    var $apple = $('#fruits .apple', fruits);
     testAppleSelect($apple);
   });
 
-  it('should be able to do: cheerio("li.apple")', function() {
-    var $apple = cheerio('li.apple', fruits);
+  it('should be able to do: $("li.apple")', function() {
+    var $apple = $('li.apple', fruits);
     testAppleSelect($apple);
   });
 
   it('should be able to select by attributes', function() {
-    var $apple = cheerio('li[class=apple]', fruits);
+    var $apple = $('li[class=apple]', fruits);
     testAppleSelect($apple);
   });
 
-  it('should be able to select multiple classes: cheerio(".btn.primary")', function() {
-    var $a = cheerio('.btn.primary', multiclass);
+  it('should be able to select multiple classes: $(".btn.primary")', function() {
+    var $a = $('.btn.primary', multiclass);
     expect($a).to.have.length(1);
     expect($a[0].childNodes[0].data).to.equal('Save');
   });
 
   it('should not create a top-level node', function() {
-    var $elem = cheerio('* div', '<div>');
+    var $elem = $('* div', '<div>');
     expect($elem).to.have.length(0);
   });
 
-  it('should be able to select multiple elements: cheerio(".apple, #fruits")', function() {
-    var $elems = cheerio('.apple, #fruits', fruits);
+  it('should be able to select multiple elements: $(".apple, #fruits")', function() {
+    var $elems = $('.apple, #fruits', fruits);
     expect($elems).to.have.length(2);
 
     var $apple = _.filter($elems, function(elem) {
@@ -161,109 +162,109 @@ describe('cheerio', function() {
     expect($fruits[0].attribs.id).to.equal('fruits');
   });
 
-  it('should select first element cheerio(:first)');
-  // var $elem = cheerio(':first', fruits);
-  // var $h2 = cheerio('<h2>fruits</h2>');
-  // console.log($elem.before('hi'));
-  // console.log($elem.before($h2));
+  it('should select first element $(:first)');
+    // var $elem = $(':first', fruits);
+    // var $h2 = $('<h2>fruits</h2>');
+    // console.log($elem.before('hi'));
+    // console.log($elem.before($h2));
 
-  it('should be able to select immediate children: cheerio("#fruits > .pear")', function() {
-    var $food = cheerio(food);
-    cheerio('.pear', $food).append('<li class="pear">Another Pear!</li>');
-    expect(cheerio('#fruits .pear', $food)).to.have.length(2);
-    var $elem = cheerio('#fruits > .pear', $food);
+  it('should be able to select immediate children: $("#fruits > .pear")', function() {
+    var $food = $(food);
+    $('.pear', $food).append('<li class="pear">Another Pear!</li>');
+    expect($('#fruits .pear', $food)).to.have.length(2);
+    var $elem = $('#fruits > .pear', $food);
     expect($elem).to.have.length(1);
     expect($elem.attr('class')).to.equal('pear');
   });
 
-  it('should be able to select immediate children: cheerio(".apple + .pear")', function() {
-    var $elem = cheerio('.apple + li', fruits);
+  it('should be able to select immediate children: $(".apple + .pear")', function() {
+    var $elem = $('.apple + li', fruits);
     expect($elem).to.have.length(1);
-    $elem = cheerio('.apple + .pear', fruits);
+    $elem = $('.apple + .pear', fruits);
     expect($elem).to.have.length(0);
-    $elem = cheerio('.apple + .orange', fruits);
+    $elem = $('.apple + .orange', fruits);
     expect($elem).to.have.length(1);
     expect($elem.attr('class')).to.equal('orange');
   });
 
-  it('should be able to select immediate children: cheerio(".apple ~ .pear")', function() {
-    var $elem = cheerio('.apple ~ li', fruits);
+  it('should be able to select immediate children: $(".apple ~ .pear")', function() {
+    var $elem = $('.apple ~ li', fruits);
     expect($elem).to.have.length(2);
-    $elem = cheerio('.apple ~ .pear', fruits);
+    $elem = $('.apple ~ .pear', fruits);
     expect($elem.attr('class')).to.equal('pear');
   });
 
-  it('should handle wildcards on attributes: cheerio("li[class*=r]")', function() {
-    var $elem = cheerio('li[class*=r]', fruits);
+  it('should handle wildcards on attributes: $("li[class*=r]")', function() {
+    var $elem = $('li[class*=r]', fruits);
     expect($elem).to.have.length(2);
     expect($elem.eq(0).attr('class')).to.equal('orange');
     expect($elem.eq(1).attr('class')).to.equal('pear');
   });
 
-  it('should handle beginning of attr selectors: cheerio("li[class^=o]")', function() {
-    var $elem = cheerio('li[class^=o]', fruits);
+  it('should handle beginning of attr selectors: $("li[class^=o]")', function() {
+    var $elem = $('li[class^=o]', fruits);
     expect($elem).to.have.length(1);
     expect($elem.eq(0).attr('class')).to.equal('orange');
   });
 
-  it('should handle beginning of attr selectors: cheerio("li[class$=e]")', function() {
-    var $elem = cheerio('li[class$=e]', fruits);
+  it('should handle beginning of attr selectors: $("li[class$=e]")', function() {
+    var $elem = $('li[class$=e]', fruits);
     expect($elem).to.have.length(2);
     expect($elem.eq(0).attr('class')).to.equal('apple');
     expect($elem.eq(1).attr('class')).to.equal('orange');
   });
 
   it('should gracefully degrade on complex, unmatched queries', function() {
-    var $elem = cheerio('Eastern States Cup #8-fin&nbsp;<br>Downhill&nbsp;');
+    var $elem = $('Eastern States Cup #8-fin&nbsp;<br>Downhill&nbsp;');
     expect($elem).to.have.length(0); // []
   });
 
   it('(extended Array) should not interfere with prototype methods (issue #119)', function() {
     var extended = [];
     extended.find = extended.children = extended.each = function() {};
-    var $empty = cheerio(extended);
+    var $empty = $(extended);
 
-    expect($empty.find).to.be(cheerio.prototype.find);
-    expect($empty.children).to.be(cheerio.prototype.children);
-    expect($empty.each).to.be(cheerio.prototype.each);
+    expect($empty.find).to.be($.prototype.find);
+    expect($empty.children).to.be($.prototype.children);
+    expect($empty.each).to.be($.prototype.each);
   });
 
   it('should set html(number) as a string', function() {
-    var $elem = cheerio('<div>');
+    var $elem = $('<div>');
     $elem.html(123);
     expect(typeof $elem.text()).to.equal('string');
   });
 
   it('should set text(number) as a string', function() {
-    var $elem = cheerio('<div>');
+    var $elem = $('<div>');
     $elem.text(123);
     expect(typeof $elem.text()).to.equal('string');
   });
 
   describe('.merge', function() {
     var arr1, arr2;
-    beforeEach(function() {
-      arr1 = [1, 2, 3];
-      arr2 = [4, 5, 6];
+    beforeEach(function(){
+      arr1 = [1,2,3];
+      arr2 = [4,5,6];
     });
 
     it('should be a function', function() {
-      expect(typeof cheerio.merge).to.equal('function');
+      expect(typeof $.merge).to.equal('function');
     });
 
     it('(arraylike, arraylike) : should return an array', function() {
-      var ret = cheerio.merge(arr1, arr2);
+      var ret = $.merge(arr1, arr2);
       expect(typeof ret).to.equal('object');
       expect(ret instanceof Array).to.be.ok();
     });
 
     it('(arraylike, arraylike) : should modify the first array', function() {
-      cheerio.merge(arr1, arr2);
+      $.merge(arr1, arr2);
       expect(arr1).to.have.length(6);
     });
 
     it('(arraylike, arraylike) : should not modify the second array', function() {
-      cheerio.merge(arr1, arr2);
+      $.merge(arr1, arr2);
       expect(arr2).to.have.length(3);
     });
 
@@ -278,7 +279,7 @@ describe('cheerio', function() {
       arr2[0] = 'd';
       arr2[1] = 'e';
       arr2[2] = 'f';
-      cheerio.merge(arr1, arr2);
+      $.merge(arr1, arr2);
       expect(arr1).to.have.length(6);
       expect(arr1[3]).to.equal('d');
       expect(arr1[4]).to.equal('e');
@@ -287,227 +288,100 @@ describe('cheerio', function() {
     });
 
     it('(?, ?) : should gracefully reject invalid inputs', function() {
-      var ret = cheerio.merge([4], 3);
+      var ret = $.merge([4],3);
       expect(ret).to.not.be.ok();
-      ret = cheerio.merge({}, {});
+      ret = $.merge({},{});
       expect(ret).to.not.be.ok();
-      ret = cheerio.merge([], {});
+      ret = $.merge([],{});
       expect(ret).to.not.be.ok();
-      ret = cheerio.merge({}, []);
+      ret = $.merge({},[]);
       expect(ret).to.not.be.ok();
-      var fakeArray1 = { length: 3 };
+      var fakeArray1 = {length: 3};
       fakeArray1[0] = 'a';
       fakeArray1[1] = 'b';
       fakeArray1[3] = 'd';
-      ret = cheerio.merge(fakeArray1, []);
+      ret = $.merge(fakeArray1,[]);
       expect(ret).to.not.be.ok();
-      ret = cheerio.merge([], fakeArray1);
+      ret = $.merge([], fakeArray1);
       expect(ret).to.not.be.ok();
       fakeArray1 = {};
       fakeArray1.length = '7';
-      ret = cheerio.merge(fakeArray1, []);
+      ret = $.merge(fakeArray1, []);
       expect(ret).to.not.be.ok();
       fakeArray1.length = -1;
-      ret = cheerio.merge(fakeArray1, []);
+      ret = $.merge(fakeArray1, []);
       expect(ret).to.not.be.ok();
     });
 
     it('(?, ?) : should no-op on invalid inputs', function() {
-      var fakeArray1 = { length: 3 };
+      var fakeArray1 = {length: 3};
       fakeArray1[0] = 'a';
       fakeArray1[1] = 'b';
       fakeArray1[3] = 'd';
-      cheerio.merge(fakeArray1, []);
+      var ret = $.merge(fakeArray1, []);
       expect(fakeArray1).to.have.length(3);
-      expect(fakeArray1[0]).to.equal('a');
-      expect(fakeArray1[1]).to.equal('b');
-      expect(fakeArray1[3]).to.equal('d');
-      cheerio.merge([], fakeArray1);
+      expect(fakeArray1[0] = 'a');
+      expect(fakeArray1[1] = 'b');
+      expect(fakeArray1[3] = 'd');
+      ret = $.merge([], fakeArray1);
       expect(fakeArray1).to.have.length(3);
-      expect(fakeArray1[0]).to.equal('a');
-      expect(fakeArray1[1]).to.equal('b');
-      expect(fakeArray1[3]).to.equal('d');
-    });
-  });
-
-  /**
-   * The `.html` static method defined on the "loaded" Cheerio factory function
-   * is deprecated.
-   *
-   * In order to promote consistency with the jQuery library, users are
-   * encouraged to instead use the instance method of the same name. For
-   * example:
-   *
-   *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
-   *     $('h1').text(); // '<h1>Hello, <span>world</span>.'
-   *
-   * To render the markup of an entire document, invoke the `html` function
-   * exported by the Cheerio module with a "root" selection, e.g.
-   *
-   *     cheerio.html($.root()); // '<html><head></head><body><h1>Hello, <span>world</span>.</h1></body></html>'
-   */
-  describe('.html - deprecated API', function() {
-    it('() : of empty cheerio object should return null', function() {
-      // Note: the direct invocation of the Cheerio constructor function is
-      // also deprecated.
-      var $ = cheerio();
-      expect($.html()).to.be(null);
-    });
-
-    it('(selector) : should return the outerHTML of the selected element', function() {
-      var $ = cheerio.load(fixtures.fruits);
-      expect($.html('.pear')).to.equal('<li class="pear">Pear</li>');
-    });
-  });
-
-  /**
-   * The `.xml` static method defined on the "loaded" Cheerio factory function
-   * is deprecated. Users are encouraged to instead use the `xml` function
-   * exported by the Cheerio module. For example:
-   *
-   *     cheerio.xml($.root());
-   */
-  describe('.xml  - deprecated API', function() {
-    it('() :  renders XML', function() {
-      var $ = cheerio.load('<foo></foo>', { xmlMode: true });
-      expect($.xml()).to.equal('<foo/>');
-    });
-  });
-
-  /**
-   * The `.text` static method defined on the "loaded" Cheerio factory function
-   * is deprecated.
-   *
-   * In order to promote consistency with the jQuery library, users are
-   * encouraged to instead use the instance method of the same name. For
-   * example:
-   *
-   *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
-   *     $('h1').text(); // 'Hello, world.'
-   *
-   * To render the text content of an entire document, invoke the `text`
-   * function exported by the Cheerio module with a "root" selection, e.g.
-   *
-   *     cheerio.text($.root()); // 'Hello, world.'
-   */
-  describe('.text  - deprecated API', function() {
-    it('(cheerio object) : should return the text contents of the specified elements', function() {
-      var $ = cheerio.load('<a>This is <em>content</em>.</a>');
-      expect($.text($('a'))).to.equal('This is content.');
-    });
-
-    it('(cheerio object) : should omit comment nodes', function() {
-      var $ = cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
-      expect($.text($('a'))).to.equal('This is  not a comment.');
-    });
-
-    it('(cheerio object) : should include text contents of children recursively', function() {
-      var $ = cheerio.load(
-        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
-      );
-      expect($.text($('a'))).to.equal(
-        'This is a child with another child and  not a comment followed by one last child and some final text.'
-      );
-    });
-
-    it('() : should return the rendered text content of the root', function() {
-      var $ = cheerio.load(
-        '<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>'
-      );
-      expect($.text()).to.equal(
-        'This is a child with another child and  not a comment followed by one last child and some final text.'
-      );
-    });
-
-    it('(cheerio object) : should omit script tags', function() {
-      var $ = cheerio.load('<script>console.log("test")</script>');
-      expect($.text()).to.equal('');
-    });
-
-    it('(cheerio object) : should omit style tags', function() {
-      var $ = cheerio.load(
-        '<style type="text/css">.cf-hidden { display: none; } .cf-invisible { visibility: hidden; }</style>'
-      );
-      expect($.text()).to.equal('');
-    });
-
-    it('(cheerio object) : should include text contents of children omiting style and script tags', function() {
-      var $ = cheerio.load(
-        '<body>Welcome <div>Hello, testing text function,<script>console.log("hello")</script></div><style type="text/css">.cf-hidden { display: none; }</style>End of messege</body>'
-      );
-      expect($.text()).to.equal(
-        'Welcome Hello, testing text function,End of messege'
-      );
+      expect(fakeArray1[0] = 'a');
+      expect(fakeArray1[1] = 'b');
+      expect(fakeArray1[3] = 'd');
     });
   });
 
   describe('.load', function() {
+
     it('should generate selections as proper instances', function() {
-      var $ = cheerio.load(fruits);
+      var q = $.load(fruits);
 
-      expect($('.apple')).to.be.a($);
+      expect(q('.apple')).to.be.a(q);
     });
 
     it('should be able to filter down using the context', function() {
-      var $ = cheerio.load(fruits),
-          apple = $('.apple', 'ul'),
-          lis = $('li', 'ul');
+      var q = $.load(fruits),
+          apple = q('.apple', 'ul'),
+          lis = q('li', 'ul');
 
       expect(apple).to.have.length(1);
       expect(lis).to.have.length(3);
     });
 
-    /**
-     * The `.load` static method defined on the "loaded" Cheerio factory
-     * function is deprecated. Users are encouraged to instead use the `load`
-     * function exported by the Cheerio module. For example:
-     *
-     *     var $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
-     */
-    it('should be available as a static method on the "loaded" factory function (deprecated API)', function() {
-      var $1 = cheerio.load(fruits);
-      var $2 = $1.load('<div><p>Some <a>text</a>.</p></div>');
-
-      expect($2('a')).to.have.length(1);
-    });
-
     it('should allow loading a pre-parsed DOM', function() {
       var dom = htmlparser2.parseDOM(food),
-          $ = cheerio.load(dom);
+          q = $.load(dom);
 
-      expect($('ul')).to.have.length(3);
+      expect(q('ul')).to.have.length(3);
     });
 
-    it('should render xml in html() when options.xml = true', function() {
+    it('should render xml in html() when options.xmlMode = true', function() {
       var str = '<MixedCaseTag UPPERCASEATTRIBUTE=""></MixedCaseTag>',
           expected = '<MixedCaseTag UPPERCASEATTRIBUTE=""/>',
-          $ = cheerio.load(str, { xml: true });
+          dom = $.load(str, {xmlMode: true});
 
-      expect($('MixedCaseTag').get(0).tagName).to.equal('MixedCaseTag');
-      expect($.html()).to.be(expected);
+      expect(dom('MixedCaseTag').get(0).tagName).to.equal('MixedCaseTag');
+      expect(dom.html()).to.be(expected);
     });
 
-    it('should render xml in html() when options.xml = true passed to html()', function() {
+    it('should render xml in html() when options.xmlMode = true passed to html()', function() {
       var str = '<MixedCaseTag UPPERCASEATTRIBUTE=""></MixedCaseTag>',
-          // since parsing done without xml flag, all tags converted to lowercase
-          expectedXml =
-          '<html><head/><body><mixedcasetag uppercaseattribute=""/></body></html>',
-          expectedNoXml =
-          '<html><head></head><body><mixedcasetag uppercaseattribute=""></mixedcasetag></body></html>',
-          $ = cheerio.load(str);
-
-      expect($('MixedCaseTag').get(0).tagName).to.equal('mixedcasetag');
-      expect($.html()).to.be(expectedNoXml);
-      expect($.html({ xml: true })).to.be(expectedXml);
+          // since parsing done without xmlMode flag, all tags converted to lowercase
+          expectedXml = '<mixedcasetag uppercaseattribute=""/>',
+          expectedNoXml = '<mixedcasetag uppercaseattribute=""></mixedcasetag>',
+          dom = $.load(str);
+
+      expect(dom('MixedCaseTag').get(0).tagName).to.equal('mixedcasetag');
+      expect(dom.html()).to.be(expectedNoXml);
+      expect(dom.html({xmlMode: true})).to.be(expectedXml);
     });
 
     it('should respect options on the element level', function() {
-      var str =
-          '<!doctype html><html><head><title>Some test</title></head><body><footer><p>Copyright &copy; 2003-2014</p></footer></body></html>',
+      var str = '<!doctype html><html><head><title>Some test</title></head><body><footer><p>Copyright &copy; 2003-2014</p></footer></body></html>',
           expectedHtml = '<p>Copyright &copy; 2003-2014</p>',
-          expectedXml = '<p>Copyright © 2003-2014</p>',
-          domNotEncoded = cheerio.load(str, { xml: { decodeEntities: false } }),
-          domEncoded = cheerio.load(str);
+          expectedXml = '<p>Copyright &#xA9; 2003-2014</p>',
+          domNotEncoded = $.load(str, {decodeEntities: false}),
+          domEncoded = $.load(str);
 
       expect(domNotEncoded('footer').html()).to.be(expectedHtml);
       // TODO: Make it more html friendly, maybe with custom encode tables
@@ -515,57 +389,51 @@ describe('cheerio', function() {
     });
 
     it('should return a fully-qualified Function', function() {
-      var $ = cheerio.load('<div>');
+      var $c = $.load('<div>');
 
-      expect($).to.be.a(Function);
+      expect($c).to.be.a(Function);
     });
 
     describe('prototype extensions', function() {
       it('should honor extensions defined on `prototype` property', function() {
-        var $ = cheerio.load('<div>');
+        var $c = $.load('<div>');
         var $div;
-        $.prototype.myPlugin = function() {
+        $c.prototype.myPlugin = function() {
           return {
             context: this,
             args: arguments
           };
         };
 
-        $div = $('div');
+        $div = $c('div');
 
         expect($div.myPlugin).to.be.a('function');
         expect($div.myPlugin().context).to.be($div);
-        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args)).to.eql([
-          1,
-          2,
-          3
-        ]);
+        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args))
+          .to.eql([1, 2, 3]);
       });
 
       it('should honor extensions defined on `fn` property', function() {
-        var $ = cheerio.load('<div>');
+        var $c = $.load('<div>');
         var $div;
-        $.fn.myPlugin = function() {
+        $c.fn.myPlugin = function() {
           return {
             context: this,
             args: arguments
           };
         };
 
-        $div = $('div');
+        $div = $c('div');
 
         expect($div.myPlugin).to.be.a('function');
         expect($div.myPlugin().context).to.be($div);
-        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args)).to.eql([
-          1,
-          2,
-          3
-        ]);
+        expect(Array.prototype.slice.call($div.myPlugin(1, 2, 3).args))
+          .to.eql([1, 2, 3]);
       });
 
       it('should isolate extensions between loaded functions', function() {
-        var $a = cheerio.load('<div>');
-        var $b = cheerio.load('<div>');
+        var $a = $.load('<div>');
+        var $b = $.load('<div>');
 
         $a.prototype.foo = function() {};
 
diff --git a/test/fixtures.js b/test/fixtures.js
index 2952796500..0c1a009451 100644
--- a/test/fixtures.js
+++ b/test/fixtures.js
@@ -1,41 +1,41 @@
 /* jshint indent: false */
 exports.fruits = [
   '<ul id="fruits">',
-  '<li class="apple">Apple</li>',
-  '<li class="orange">Orange</li>',
-  '<li class="pear">Pear</li>',
+    '<li class="apple">Apple</li>',
+    '<li class="orange">Orange</li>',
+    '<li class="pear">Pear</li>',
   '</ul>'
 ].join('');
 
 exports.vegetables = [
   '<ul id="vegetables">',
-  '<li class="carrot">Carrot</li>',
-  '<li class="sweetcorn">Sweetcorn</li>',
+    '<li class="carrot">Carrot</li>',
+    '<li class="sweetcorn">Sweetcorn</li>',
   '</ul>'
 ].join('');
 
 exports.chocolates = [
   '<ul id="chocolates">',
-  '<li class="linth" data-highlight="Lindor" data-origin="swiss">Linth</li>',
-  '<li class="frey" data-taste="sweet" data-best-collection="Mahony">Frey</li>',
-  '<li class="cailler">Cailler</li>',
+    '<li class="linth" data-highlight="Lindor" data-origin="swiss">Linth</li>',
+    '<li class="frey" data-taste="sweet" data-best-collection="Mahony">Frey</li>',
+    '<li class="cailler">Cailler</li>',
   '</ul>'
 ].join('');
 
 exports.drinks = [
   '<ul id="drinks">',
-  '<li class="beer">Beer</li>',
-  '<li class="juice">Juice</li>',
-  '<li class="milk">Milk</li>',
-  '<li class="water">Water</li>',
-  '<li class="cider">Cider</li>',
+    '<li class="beer">Beer</li>',
+    '<li class="juice">Juice</li>',
+    '<li class="milk">Milk</li>',
+    '<li class="water">Water</li>',
+    '<li class="cider">Cider</li>',
   '</ul>'
 ].join('');
 
 exports.food = [
   '<ul id="food">',
-  exports.fruits,
-  exports.vegetables,
+    exports.fruits,
+    exports.vegetables,
   '</ul>'
 ].join('');
 
diff --git a/test/parse.js b/test/parse.js
index 90b11bf3fb..d22bad38f6 100644
--- a/test/parse.js
+++ b/test/parse.js
@@ -1,6 +1,7 @@
 var expect = require('expect.js'),
     parse = require('../lib/parse'),
-    defaultOpts = require('../lib/options').default;
+    defaultOpts = require('..').prototype.options;
+
 
 // Tags
 var basic = '<html></html>';
@@ -20,8 +21,7 @@ var noValueAttribute = '<textarea disabled></textarea>';
 
 // Comments
 var comment = '<!-- sexy -->';
-var conditional =
-  '<!--[if IE 8]><html class="no-js ie8" lang="en"><![endif]-->';
+var conditional = '<!--[if IE 8]><html class="no-js ie8" lang="en"><![endif]-->';
 
 // Text
 var text = 'lorem ipsum';
@@ -37,17 +37,20 @@ var styleEmpty = '<style></style>';
 // Directives
 var directive = '<!doctype html>';
 
+
 describe('parse', function() {
+
   describe('.eval', function() {
+
     it('should parse basic empty tags: ' + basic, function() {
-      var tag = parse.evaluate(basic, defaultOpts, true)[0];
+      var tag = parse.evaluate(basic, defaultOpts)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('html');
-      expect(tag.childNodes).to.have.length(2);
+      expect(tag.childNodes).to.be.empty();
     });
 
     it('should handle sibling tags: ' + siblings, function() {
-      var dom = parse.evaluate(siblings, defaultOpts, false),
+      var dom = parse.evaluate(siblings, defaultOpts),
           h2 = dom[0],
           p = dom[1];
 
@@ -57,70 +60,66 @@ describe('parse', function() {
     });
 
     it('should handle single tags: ' + single, function() {
-      var tag = parse.evaluate(single, defaultOpts, false)[0];
+      var tag = parse.evaluate(single, defaultOpts)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('br');
       expect(tag.childNodes).to.be.empty();
     });
 
     it('should handle malformatted single tags: ' + singleWrong, function() {
-      var tag = parse.evaluate(singleWrong, defaultOpts, false)[0];
+      var tag = parse.evaluate(singleWrong, defaultOpts)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('br');
       expect(tag.childNodes).to.be.empty();
     });
 
     it('should handle tags with children: ' + children, function() {
-      var tag = parse.evaluate(children, defaultOpts, true)[0];
+      var tag = parse.evaluate(children, defaultOpts)[0];
       expect(tag.type).to.equal('tag');
       expect(tag.tagName).to.equal('html');
       expect(tag.childNodes).to.be.ok();
-      expect(tag.childNodes[1].tagName).to.equal('body');
-      expect(tag.childNodes[1].childNodes).to.have.length(1);
+      expect(tag.childNodes).to.have.length(1);
     });
 
     it('should handle tags with children: ' + li, function() {
-      var tag = parse.evaluate(li, defaultOpts, false)[0];
+      var tag = parse.evaluate(li, defaultOpts)[0];
       expect(tag.childNodes).to.have.length(1);
       expect(tag.childNodes[0].data).to.equal('Durian');
     });
 
     it('should handle tags with attributes: ' + attributes, function() {
-      var attrs = parse.evaluate(attributes, defaultOpts, false)[0].attribs;
+      var attrs = parse.evaluate(attributes, defaultOpts)[0].attribs;
       expect(attrs).to.be.ok();
       expect(attrs.src).to.equal('hello.png');
       expect(attrs.alt).to.equal('man waving');
     });
 
     it('should handle value-less attributes: ' + noValueAttribute, function() {
-      var attrs = parse.evaluate(noValueAttribute, defaultOpts, false)[0]
-        .attribs;
+      var attrs = parse.evaluate(noValueAttribute, defaultOpts)[0].attribs;
       expect(attrs).to.be.ok();
       expect(attrs.disabled).to.equal('');
     });
 
     it('should handle comments: ' + comment, function() {
-      var elem = parse.evaluate(comment, defaultOpts, false)[0];
+      var elem = parse.evaluate(comment, defaultOpts)[0];
       expect(elem.type).to.equal('comment');
       expect(elem.data).to.equal(' sexy ');
     });
 
     it('should handle conditional comments: ' + conditional, function() {
-      var elem = parse.evaluate(conditional, defaultOpts, false)[0];
+      var elem = parse.evaluate(conditional, defaultOpts)[0];
       expect(elem.type).to.equal('comment');
-      expect(elem.data).to.equal(
-        conditional.replace('<!--', '').replace('-->', '')
-      );
+      expect(elem.data).to.equal(conditional.replace('<!--', '').replace('-->', ''));
     });
 
     it('should handle text: ' + text, function() {
-      var text_ = parse.evaluate(text, defaultOpts, false)[0];
+      var text_ = parse.evaluate(text, defaultOpts)[0];
       expect(text_.type).to.equal('text');
       expect(text_.data).to.equal('lorem ipsum');
     });
 
     it('should handle script tags: ' + script, function() {
-      var script_ = parse.evaluate(script, defaultOpts, false)[0];
+      var script_ = parse.evaluate(script, defaultOpts)[0];
       expect(script_.type).to.equal('script');
       expect(script_.tagName).to.equal('script');
       expect(script_.attribs.type).to.equal('text/javascript');
@@ -130,7 +129,7 @@ describe('parse', function() {
     });
 
     it('should handle style tags: ' + style, function() {
-      var style_ = parse.evaluate(style, defaultOpts, false)[0];
+      var style_ = parse.evaluate(style, defaultOpts)[0];
       expect(style_.type).to.equal('style');
       expect(style_.tagName).to.equal('style');
       expect(style_.attribs.type).to.equal('text/css');
@@ -140,14 +139,16 @@ describe('parse', function() {
     });
 
     it('should handle directives: ' + directive, function() {
-      var elem = parse.evaluate(directive, defaultOpts, true)[0];
+      var elem = parse.evaluate(directive, defaultOpts)[0];
       expect(elem.type).to.equal('directive');
-      expect(elem.data).to.equal('!DOCTYPE html');
+      expect(elem.data).to.equal('!doctype html');
       expect(elem.tagName).to.equal('!doctype');
     });
+
   });
 
   describe('.parse', function() {
+
     // root test utility
     function rootTest(root) {
       expect(root.tagName).to.equal('root');
@@ -162,14 +163,14 @@ describe('parse', function() {
     }
 
     it('should add root to: ' + basic, function() {
-      var root = parse(basic, defaultOpts, true);
+      var root = parse(basic, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].tagName).to.equal('html');
     });
 
     it('should add root to: ' + siblings, function() {
-      var root = parse(siblings, defaultOpts, false);
+      var root = parse(siblings, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(2);
       expect(root.childNodes[0].tagName).to.equal('h2');
@@ -178,46 +179,42 @@ describe('parse', function() {
     });
 
     it('should add root to: ' + comment, function() {
-      var root = parse(comment, defaultOpts, false);
+      var root = parse(comment, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('comment');
     });
 
     it('should add root to: ' + text, function() {
-      var root = parse(text, defaultOpts, false);
+      var root = parse(text, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('text');
     });
 
     it('should add root to: ' + scriptEmpty, function() {
-      var root = parse(scriptEmpty, defaultOpts, false);
+      var root = parse(scriptEmpty, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('script');
     });
 
     it('should add root to: ' + styleEmpty, function() {
-      var root = parse(styleEmpty, defaultOpts, false);
+      var root = parse(styleEmpty, defaultOpts);
       rootTest(root);
       expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('style');
     });
 
     it('should add root to: ' + directive, function() {
-      var root = parse(directive, defaultOpts, true);
+      var root = parse(directive, defaultOpts);
       rootTest(root);
-      expect(root.childNodes).to.have.length(2);
+      expect(root.childNodes).to.have.length(1);
       expect(root.childNodes[0].type).to.equal('directive');
     });
 
     it('should expose the DOM level 1 API', function() {
-      var root = parse(
-        '<div><a></a><span></span><p></p></div>',
-        defaultOpts,
-        false
-      ).childNodes[0];
+      var root = parse('<div><a></a><span></span><p></p></div>', defaultOpts).childNodes[0];
       var childNodes = root.childNodes;
 
       expect(childNodes).to.have.length(3);
@@ -250,130 +247,6 @@ describe('parse', function() {
       expect(childNodes[2].firstChild).to.be(null);
       expect(childNodes[2].lastChild).to.be(null);
     });
-
-    it('Should parse less than or equal sign sign', function() {
-      var root = parse('<i>A</i><=<i>B</i>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].tagName).to.be('i');
-      expect(childNodes[0].childNodes[0].data).to.be('A');
-      expect(childNodes[1].data).to.be('<=');
-      expect(childNodes[2].tagName).to.be('i');
-      expect(childNodes[2].childNodes[0].data).to.be('B');
-    });
-
-    it('Should ignore unclosed CDATA', function() {
-      var root = parse(
-        '<a></a><script>foo //<![CDATA[ bar</script><b></b>',
-        defaultOpts,
-        false
-      );
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].tagName).to.be('a');
-      expect(childNodes[1].tagName).to.be('script');
-      expect(childNodes[1].childNodes[0].data).to.be('foo //<![CDATA[ bar');
-      expect(childNodes[2].tagName).to.be('b');
-    });
-
-    it('Should add <head> to documents', function() {
-      var root = parse('<html></html>', defaultOpts, true);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].tagName).to.be('html');
-      expect(childNodes[0].childNodes[0].tagName).to.be('head');
-    });
-
-    it('Should implicitly create <tr> around <td>', function() {
-      var root = parse('<table><td>bar</td></tr></table>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].tagName).to.be('table');
-      expect(childNodes[0].childNodes.length).to.be(1);
-      expect(childNodes[0].childNodes[0].tagName).to.be('tbody');
-      expect(childNodes[0].childNodes[0].childNodes[0].tagName).to.be('tr');
-      expect(
-        childNodes[0].childNodes[0].childNodes[0].childNodes[0].tagName
-      ).to.be('td');
-      expect(
-        childNodes[0].childNodes[0].childNodes[0].childNodes[0].childNodes[0]
-          .data
-      ).to.be('bar');
-    });
-
-    it('Should parse custom tag <line>', function() {
-      var root = parse('<line>test</line>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes.length).to.be(1);
-      expect(childNodes[0].tagName).to.be('line');
-      expect(childNodes[0].childNodes[0].data).to.be('test');
-    });
-
-    it('Should properly parse misnested table tags', function() {
-      var root = parse(
-        '<tr><td>i1</td></tr><tr><td>i2</td></td></tr><tr><td>i3</td></td></tr>',
-        defaultOpts,
-        false
-      );
-      var childNodes = root.childNodes;
-
-      expect(childNodes.length).to.be(3);
-
-      childNodes.forEach(function(child, i) {
-        expect(child.tagName).to.be('tr');
-        expect(child.childNodes[0].tagName).to.be('td');
-        expect(child.childNodes[0].childNodes[0].data).to.be('i' + (i + 1));
-      });
-    });
-
-    it('Should correctly parse data url attributes', function() {
-      var html =
-        '<div style=\'font-family:"butcherman-caps"; src:url(data:font/opentype;base64,AAEA...);\'></div>';
-      var expectedAttr =
-        'font-family:"butcherman-caps"; src:url(data:font/opentype;base64,AAEA...);';
-      var root = parse(html, defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].attribs.style).to.be(expectedAttr);
-    });
-
-    it('Should treat <xmp> tag content as text', function() {
-      var root = parse('<xmp><h2></xmp>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].childNodes[0].data).to.be('<h2>');
-    });
-
-    it('Should correctly parse malformed numbered entities', function() {
-      var root = parse('<p>z&#</p>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes[0].childNodes[0].data).to.be('z&#');
-    });
-
-    it('Should correctly parse mismatched headings', function() {
-      var root = parse('<h2>Test</h3><div></div>', defaultOpts, false);
-      var childNodes = root.childNodes;
-
-      expect(childNodes.length).to.be(2);
-      expect(childNodes[0].tagName).to.be('h2');
-      expect(childNodes[1].tagName).to.be('div');
-    });
-
-    it('Should correctly parse tricky <pre> content', function() {
-      var root = parse(
-        '<pre>\nA <- factor(A, levels = c("c","a","b"))\n</pre>',
-        defaultOpts,
-        false
-      );
-      var childNodes = root.childNodes;
-
-      expect(childNodes.length).to.be(1);
-      expect(childNodes[0].tagName).to.be('pre');
-      expect(childNodes[0].childNodes[0].data).to.be(
-        'A <- factor(A, levels = c("c","a","b"))\n'
-      );
-    });
   });
+
 });
diff --git a/test/xml.js b/test/xml.js
index d24e3feb77..cc23133532 100644
--- a/test/xml.js
+++ b/test/xml.js
@@ -5,9 +5,9 @@ var expect = require('expect.js'),
     };
 
 var xml = function(str, options) {
-  options = _.extend({ xml: true }, options);
-  var $ = cheerio.load(str, options);
-  return $.xml();
+  options = _.extend({ xmlMode: true }, options);
+  var dom = cheerio.load(str, options);
+  return dom.xml();
 };
 
 var dom = function(str, options) {
@@ -16,13 +16,12 @@ var dom = function(str, options) {
 };
 
 describe('render', function() {
+
   describe('(xml)', function() {
+
     it('should render <media:thumbnail /> tags correctly', function() {
-      var str =
-        '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />';
-      expect(xml(str)).to.equal(
-        '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>'
-      );
+      var str = '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />';
+      expect(xml(str)).to.equal('<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>');
     });
 
     it('should render <link /> tags (RSS) correctly', function() {
@@ -30,34 +29,32 @@ describe('render', function() {
       expect(xml(str)).to.equal('<link>http://www.github.com/</link>');
     });
 
-    it('should escape entities', function() {
+    it('should escape entities', function(){
       var str = '<tag attr="foo &amp; bar"/>';
       expect(xml(str)).to.equal(str);
     });
+
   });
 
-  describe('(dom)', function() {
+  describe('(dom)', function () {
+
     it('should keep camelCase for new nodes', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      expect(dom(str, { xml: false })).to.equal(
-        '<someelem someattribute="something">hello</someelem>'
-      );
+      expect(dom(str, {xmlMode: false})).to.equal('<someelem someattribute="something">hello</someelem>');
     });
 
     it('should keep camelCase for new nodes', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      expect(dom(str, { xml: true })).to.equal(
-        '<someElem someAttribute="something">hello</someElem>'
-      );
+      expect(dom(str, {xmlMode: true})).to.equal('<someElem someAttribute="something">hello</someElem>');
     });
 
     it('should maintain the parsing options of distinct contexts independently', function() {
       var str = '<g><someElem someAttribute="something">hello</someElem></g>';
-      var $ = cheerio.load('', { xml: false });
+      var $x = cheerio.load('', { xmlMode: false });
 
-      expect($(str).html()).to.equal(
-        '<someelem someattribute="something">hello</someelem>'
-      );
+      expect($x(str).html()).to.equal('<someelem someattribute="something">hello</someelem>');
     });
+
   });
+
 });

From 426b555173fbb6ac4718a38c23e261ce0235ca6a Mon Sep 17 00:00:00 2001
From: Luan Muniz <luanmuniz@users.noreply.github.com>
Date: Wed, 30 Jan 2019 01:27:54 -0200
Subject: [PATCH 11/16] Fix error for cheerio.css

cheerio.css on empty elements set throws, jQuery returns undefined.
This PR Checks for the element before checking the styles.

Include tests

Signed-off-by: Luan <luan@luanmuniz.com.br>
---
 lib/api/css.js  |  4 ++++
 test/api/css.js | 10 ++++++++++
 2 files changed, 14 insertions(+)

diff --git a/lib/api/css.js b/lib/api/css.js
index d9ffae6cfa..d784b68d22 100644
--- a/lib/api/css.js
+++ b/lib/api/css.js
@@ -66,6 +66,10 @@ function setCss(el, prop, val, idx) {
  */
 
 function getCss(el, prop) {
+  if(!el || !el.attribs) {
+    return undefined;
+  }
+
   var styles = parse(el.attribs.style);
   if (typeof prop === 'string') {
     return styles[prop];
diff --git a/test/api/css.js b/test/api/css.js
index 9e394c44f0..1f75abb4a4 100644
--- a/test/api/css.js
+++ b/test/api/css.js
@@ -42,6 +42,16 @@ describe('$(...)', function() {
       expect(el.css()).to.eql({position:'absolute'});
     });
 
+    it('(prop): should return undefined for unmatched elements', function() {
+      var $ = cheerio.load('<li style="color:;position:absolute;">');
+      expect($('ul').css('background-image')).to.eql(undefined);
+    });
+
+    it('(prop): should return undefined for unmatched styles', function() {
+      var el = cheerio('<li style="color:;position:absolute;">');
+      expect(el.css('margin')).to.eql(undefined);
+    });
+
     describe('(prop, function):', function() {
       beforeEach(function() {
         this.$el = cheerio('<div style="margin: 0px;"></div><div style="margin: 1px;"></div><div style="margin: 2px;">');

From bfd857f84cf30236d4257317d04adf25389c85d3 Mon Sep 17 00:00:00 2001
From: Luigi Pinca <luigipinca@gmail.com>
Date: Fri, 12 Oct 2018 11:44:51 +0200
Subject: [PATCH 12/16] Do not use the deprecated Buffer() constructor

Refs: https://github.com/nodejs/citgm/issues/605
Refs: https://nodejs.org/api/deprecations.html#deprecations_dep0005_buffer_constructor
---
 test/api/utils.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/api/utils.js b/test/api/utils.js
index d6983c8a1c..a750f28377 100644
--- a/test/api/utils.js
+++ b/test/api/utils.js
@@ -101,8 +101,12 @@ describe('cheerio', function() {
     // });
 
     it('(buffer) : should accept a buffer', function() {
-      var $html = cheerio.load(new Buffer('<div>foo</div>'));
-      expect($html.html()).to.be('<div>foo</div>');
+      var html = '<div>foo</div>';
+      var buf = Buffer.from && Buffer.from !== Uint8Array.from
+        ? Buffer.from(html)
+        : new Buffer(html);
+      var $html = cheerio.load(buf);
+      expect($html.html()).to.be(html);
     });
 
   });

From 9afacf89ff37e4e1f8371d2910c7e7c08ba8bb12 Mon Sep 17 00:00:00 2001
From: 0xflotus <0xflotus@gmail.com>
Date: Wed, 13 Feb 2019 21:16:12 +0100
Subject: [PATCH 13/16] (docs) fixed some small errors

---
 Readme.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Readme.md b/Readme.md
index 8d8fdc325a..e057f75061 100644
--- a/Readme.md
+++ b/Readme.md
@@ -1067,7 +1067,7 @@ $.root().append('<ul id="vegetables"></ul>').html();
 Checks to see if the `contained` DOM element is a descendant of the `container` DOM element.
 
 #### $.parseHTML( data [, context ] [, keepScripts ] )
-Parses a string into an array of DOM nodes. The `context` argument has no meaning for Cheerio, but it is maintained for API compatability.
+Parses a string into an array of DOM nodes. The `context` argument has no meaning for Cheerio, but it is maintained for API compatibility.
 
 #### $.load( html[, options ] )
 Load in the HTML. (See the previous section titled "Loading" for more information.)
@@ -1087,7 +1087,7 @@ $('body').logHtml(); // logs "Hello, <b>world</b>!" to the console
 
 ### The "DOM Node" object
 
-Cheerio collections are made up of objects that bear some resemblence to [browser-based DOM nodes](https://developer.mozilla.org/en-US/docs/Web/API/Node). You can expect them to define the following properties:
+Cheerio collections are made up of objects that bear some resemblance to [browser-based DOM nodes](https://developer.mozilla.org/en-US/docs/Web/API/Node). You can expect them to define the following properties:
 
 - `tagName`
 - `parentNode`

From 7a9ff22f68bd6dbdf04f8e3a52e28a6b369b5fa7 Mon Sep 17 00:00:00 2001
From: dzcpy <huyifan@vip.sina.com>
Date: Mon, 22 Apr 2019 01:38:12 +0800
Subject: [PATCH 14/16] Update dependencies & fix vulnerability  (#1281)

* update dependencies

* update dependencies

* Update package.json

* Update package.json

* Fix weird xml mode issue

* Fix package-lock.json and update vulnerable modules

* Remove Node 0.12 from Travis test environments

* Fix JSDOM API issue

* Fix JSDOM new API

* Delete package-lock.json
---
 .travis.yml            |  1 -
 benchmark/suite.js     | 25 ++++++++++++-------------
 package.json           | 26 +++++++++++++-------------
 test/api/traversing.js |  8 ++------
 test/cheerio.js        |  8 +-------
 test/mocha.opts        |  1 -
 6 files changed, 28 insertions(+), 41 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index b7d7df23f8..e8b962b198 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,7 +4,6 @@ node_js:
   - "unstable"
   - "6"
   - "4"
-  - "0.12"
 script: make travis-test
 matrix:
   fast_finish: true
diff --git a/benchmark/suite.js b/benchmark/suite.js
index da029ad7ec..d45ccf7eb8 100644
--- a/benchmark/suite.js
+++ b/benchmark/suite.js
@@ -62,20 +62,19 @@ Suites.prototype.add = function(name, fileName, options) {
 Suites.prototype._benchJsDom = function(suite, markup, options) {
   var testFn = options.test;
 
-  jsdom.env({
-    html: markup,
-    scripts: jQuerySrc,
-    done: function(err, window) {
-      var setupData;
-      if (options.setup) {
-        setupData = options.setup.call(null, window.$);
-      }
-      suite.add('jsdom', function() {
-        testFn.call(null, window.$, setupData);
-      });
-      suite.run();
-    }
+  var { JSDOM } = jsdom;
+  var { window } = new JSDOM(markup);
+  window.$ = require(jQuerySrc)(window);
+
+  var setupData;
+  if (options.setup) {
+    setupData = options.setup.call(null, window.$);
+  }
+  suite.add('jsdom', function() {
+    testFn.call(null, window.$, setupData);
   });
+  suite.run();
+
 };
 
 Suites.prototype._benchCheerio = function(suite, markup, options) {
diff --git a/package.json b/package.json
index 91d4e0aa34..e824ae1578 100644
--- a/package.json
+++ b/package.json
@@ -25,22 +25,22 @@
     "node": ">= 0.6"
   },
   "dependencies": {
-    "css-select": "~1.2.0",
-    "dom-serializer": "~0.1.0",
-    "entities": "~1.1.1",
-    "htmlparser2": "^3.9.1",
-    "lodash": "^4.15.0"
+    "css-select": "~2.0.2",
+    "dom-serializer": "~0.1.1",
+    "entities": "~1.1.2",
+    "htmlparser2": "^3.10.1",
+    "lodash": "^4.17.11"
   },
   "devDependencies": {
-    "benchmark": "^2.1.0",
-    "coveralls": "^2.11.9",
+    "benchmark": "^2.1.4",
+    "coveralls": "^3.0.2",
     "expect.js": "~0.3.1",
-    "istanbul": "^0.4.3",
-    "jsdom": "^9.2.1",
-    "jquery": "^3.0.0",
-    "jshint": "^2.9.2",
-    "mocha": "^3.1.2",
-    "xyz": "~1.1.0"
+    "istanbul": "^0.4.5",
+    "jquery": "^3.3.1",
+    "jsdom": "^13.2.0",
+    "jshint": "^2.10.1",
+    "mocha": "^5.2.0",
+    "xyz": "~3.0.0"
   },
   "scripts": {
     "test": "jshint lib/ test/ && mocha --recursive --reporter dot"
diff --git a/test/api/traversing.js b/test/api/traversing.js
index 06a969ca42..939ffb36d1 100644
--- a/test/api/traversing.js
+++ b/test/api/traversing.js
@@ -63,9 +63,7 @@ describe('$(...)', function() {
     it('should throw a SyntaxError if given an invalid selector', function() {
       expect(function() {
         $('#fruits').find(':bah');
-      }).to.throwException(function(err) {
-        expect(err).to.be.a(SyntaxError);
-      });
+      }).to.throwException(/unmatched pseudo-class/);
     });
 
     describe('(cheerio object) :', function() {
@@ -456,9 +454,7 @@ describe('$(...)', function() {
     it('(selector) : should throw a SyntaxError if given an invalid selector', function() {
       expect(function() {
         $('.orange').siblings(':bah');
-      }).to.throwException(function(err) {
-        expect(err).to.be.a(SyntaxError);
-      });
+      }).to.throwException(/unmatched pseudo-class/);
     });
 
     it('(selector) : does not consider the contents of siblings when filtering (GH-374)', function() {
diff --git a/test/cheerio.js b/test/cheerio.js
index e477add9d3..be2785a6fc 100644
--- a/test/cheerio.js
+++ b/test/cheerio.js
@@ -162,12 +162,6 @@ describe('cheerio', function() {
     expect($fruits[0].attribs.id).to.equal('fruits');
   });
 
-  it('should select first element $(:first)');
-    // var $elem = $(':first', fruits);
-    // var $h2 = $('<h2>fruits</h2>');
-    // console.log($elem.before('hi'));
-    // console.log($elem.before($h2));
-
   it('should be able to select immediate children: $("#fruits > .pear")', function() {
     var $food = $(food);
     $('.pear', $food).append('<li class="pear">Another Pear!</li>');
@@ -368,7 +362,7 @@ describe('cheerio', function() {
       var str = '<MixedCaseTag UPPERCASEATTRIBUTE=""></MixedCaseTag>',
           // since parsing done without xmlMode flag, all tags converted to lowercase
           expectedXml = '<mixedcasetag uppercaseattribute=""/>',
-          expectedNoXml = '<mixedcasetag uppercaseattribute=""></mixedcasetag>',
+          expectedNoXml = '<mixedcasetag uppercaseattribute></mixedcasetag>',
           dom = $.load(str);
 
       expect(dom('MixedCaseTag').get(0).tagName).to.equal('mixedcasetag');
diff --git a/test/mocha.opts b/test/mocha.opts
index 9431de4c17..b8a05a88fc 100644
--- a/test/mocha.opts
+++ b/test/mocha.opts
@@ -1,2 +1 @@
 --reporter list
---growl
\ No newline at end of file

From 6a4886232f4d140b631b3dc5664c5a59962f9286 Mon Sep 17 00:00:00 2001
From: Matthew Mueller <mattmuelle@gmail.com>
Date: Sun, 5 May 2019 18:47:38 +0700
Subject: [PATCH 15/16] Remove 8x performance claim

This was true many years ago, but JSDOM is a lot faster now. See [this issue](https://github.com/cheeriojs/cheerio/issues/700) for more details.
---
 Readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Readme.md b/Readme.md
index e057f75061..51dce11389 100644
--- a/Readme.md
+++ b/Readme.md
@@ -45,7 +45,7 @@ __&#10084; Familiar syntax:__
 Cheerio implements a subset of core jQuery. Cheerio removes all the DOM inconsistencies and browser cruft from the jQuery library, revealing its truly gorgeous API.
 
 __&#991; Blazingly fast:__
-Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient. Preliminary end-to-end benchmarks suggest that cheerio is about __8x__ faster than JSDOM.
+Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient.
 
 __&#10049; Incredibly flexible:__
 Cheerio wraps around @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.

From 3368605edb3c5babecc8576602a9d54ccfdaef1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20B=C3=B6hm?= <me@feedic.com>
Date: Mon, 10 Jun 2019 10:22:58 -0700
Subject: [PATCH 16/16] Create FUNDING.yml

---
 .github/FUNDING.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000000..f3fc95057c
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: cheerio
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with a single custom sponsorship URL