diff --git a/.travis.yml b/.travis.yml
index 34951f3..6d17c6d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +1,4 @@
 language: node_js
 node_js:
-  - "0.8"
+  - "8"
+  - "6"
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..9a741a1
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at peter@cornerstonenw.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..1aa031a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,5 @@
+Before sending a pull request, please verify that [all the existing tests](http://csnw.github.io/sql-bricks/browser-tests.html) pass and add new tests for the changes you are making. The tests can be run in node with `npm test` (provided `npm install` has been run to install the dependencies) or they can be run in the browser with `browser-tests.html`. All of the examples in the documentation are run as tests, in addition to the tests in tests.js.
+
+Note that **pull requests for additional SQL dialects** or extensions beyond ANSI SQL-92 will probably not be merged. If you would like support for a different dialect, you are welcome to maintain a dialect-specific fork or a library that extends sql-bricks.
+
+Also, **pull requests for additional SQL statements** beyond the four CRUD statements (`SELECT`, `UPDATE`, `INSERT`, `DELETE`) will probably not be merged. Other SQL statements do not benefit as much from re-use and composition; the goal being to keep SQL Bricks small, sharp and low-maintenance.
diff --git a/browser-tests.html b/browser-tests.html
index 9a11784..9a12bf2 100644
--- a/browser-tests.html
+++ b/browser-tests.html
@@ -10,6 +10,7 @@
   <script src="tests/mocha.js"></script>
   <script>mocha.setup({ui: 'bdd', reporter: 'html'})</script>
   <script src="sql-bricks.js"></script>
+
   <script src="tests/tests.js"></script>
   <script src="tests/doctests.js"></script>
   <script>
diff --git a/index.html b/index.html
index d43d12d..a2912fc 100644
--- a/index.html
+++ b/index.html
@@ -6,7 +6,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
   <meta name="viewport" content="target-densitydpi=device-dpi" />
   <meta name="HandheldFriendly" content="true"/>
-  <link rel="canonical" href="http://csnw.github.io/sql-bricks" />
+  <link rel="canonical" href="https://csnw.github.io/sql-bricks" />
   <title>SQL Bricks</title>
   <style>
     body {
@@ -129,7 +129,7 @@
     SQL Bricks.js
     
     <ul class="toc_section">
-      <li>&raquo; <a href="http://github.com/CSNW/sql-bricks">GitHub Repository</a></li>
+      <li>&raquo; <a href="https://github.com/CSNW/sql-bricks">GitHub Repository</a></li>
     </ul>
     <a class="toc_title" href="#">
       Introduction
@@ -161,13 +161,13 @@
       <li>- <a href="#selfrom">from</a></li>
       <li>- <a href="#join">join, leftJoin, rightJoin, fullJoin, crossJoin</a></li>
       <li>- <a href="#on">on</a></li>
+      <li>- <a href="#using">using</a></li>
+      <li>- <a href="#naturaljoin">naturalJoin, naturalLeftJoin, naturalRightJoin, naturalFullJoin</a></li>
       <li>- <a href="#selwhere">where</a></li>
       <li>- <a href="#groupBy">groupBy</a></li>
       <li>- <a href="#having">having</a></li>
       <li>- <a href="#union">(union, intersect, minus, except)[All]</a></li>
       <li>- <a href="#orderBy">orderBy</a></li>
-      <li>- <a href="#limit">limit</a></li>
-      <li>- <a href="#offset">offset</a></li>
       <li>- <a href="#forUpdate">forUpdate, noWait</a></li>
     </ul>
     <a class="toc_title" href="#insert">
@@ -232,16 +232,23 @@
   <div class="container">
     <h1>SQL Bricks.js</h1>
     <p><a href="https://travis-ci.org/CSNW/sql-bricks" title="Build Status"><img src="https://travis-ci.org/CSNW/sql-bricks.png?branch=master"></a></p>
-    <p id="introduction">As with other SQL generation libraries, SQL Bricks was created to help eliminate DRY violations in SQL-heavy applications. SQL statements can be easily stored, cloned, modified and passed around to other parts of an application and they can generate both parameterized and non-parameterized SQL.</p>
+    <p id="introduction">SQL Bricks was created to help eliminate DRY violations in SQL-heavy applications. SQL statements can be easily stored, cloned, modified and passed around to other parts of an application and they can generate both parameterized and non-parameterized SQL.</p>
     <p>In addition, SQL Bricks contains a few conveniences to aid in re-use and to make SQL generation a little less of a chore: automatic quoting of columns that collide with keywords (<tt>order</tt>, <tt>desc</tt>, etc) &amp; columns that contain capital letters, automatic <a href="#aliasExpansions">alias expansion</a>, user-supplied <a href="#joinCriteria">join criteria</a> functions.</p>
-    <p>SQL Bricks differs from similar libraries in that it does not require a schema and it is designed to be transparent, matching SQL so faithfully that developers with SQL experience will immediately know the API.</p>
-    <p>SQL Bricks supports the four CRUD statements (<tt>SELECT</tt>, <tt>INSERT</tt>, <tt>UPDATE</tt>, <tt>DELETE</tt>) and all of their clauses as defined by <b><a href="http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt">SQL-92</a></b> as well as some additional clauses supported by <b>Postgres</b> and <b>SQLite</b>. Adding support for other SQL statements (<tt>CREATE</tt>, <tt>ALTER TABLE</tt>, etc) would clutter the library without providing much real benefit.</p>
-    <p>The <a href="http://github.com/CSNW/sql-bricks">source</a> is on GitHub and over <a href="browser-tests.html">175 tests</a> are available for your perusal.</p>
+    <p>SQL Bricks differs from similar libraries in that it does not require a schema and it is designed to be transparent, matching SQL so faithfully that developers with knowledge of SQL will pick up the API extremely quickly.</p>
+    <p>The core SQL Bricks library supports the four CRUD statements (<tt>SELECT</tt>, <tt>INSERT</tt>, <tt>UPDATE</tt>, <tt>DELETE</tt>) and all of their clauses as defined by <b><a href="https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt">SQL-92</a></b> (additional clauses supported by <b>Postgres</b>, <b>MySQL</b>, and <b>SQLite</b> are in the dialect-specific extension libraries, <a href="https://github.com/Suor/sql-bricks-postgres">sql-bricks-postgres</a>, <a href="https://github.com/tamarzil/mysql-bricks">mysql-bricks</a> and <a href="https://github.com/CSNW/sql-bricks-sqlite">sql-bricks-sqlite</a>, respectively). Adding support for other SQL statements (<tt>CREATE</tt>, <tt>ALTER TABLE</tt>, etc) would clutter the library without providing much real benefit.</p>
+    <p>The <a href="https://github.com/CSNW/sql-bricks">source</a> is on GitHub and over <a href="browser-tests.html">200 tests</a> are available for your perusal.</p>
+
+    <h2>Related Libraries</h2>
+    <p><a href="https://github.com/tamarzil/mysql-bricks">mysql-bricks</a> adds mysql-dialect extensions, like <tt>INSERT ... ON DUPLICATE KEY UPDATE ...</tt>, <tt>INSERT IGNORE ...</tt>, <tt>LIMIT (SELECT / UPDATE / DELETE)</tt>, <tt>OFFSET</tt>, <tt>ORDER BY (UPDATE / DELETE)</tt></p>
+    <p><a href="https://github.com/CSNW/sql-bricks-sqlite">sql-bricks-sqlite</a> adds sqlite-dialect extensions, like <tt>LIMIT ... OFFSET</tt> and <tt>OR REPLACE</tt></p>
+    <p><a href="https://github.com/Suor/sql-bricks-postgres">sql-bricks-postgres</a> adds postgres-dialect extensions, like <tt>LIMIT ... OFFSET</tt> and <tt>RETURNING</tt></p> 
+    <p><a href="https://github.com/Suor/pg-bricks">pg-bricks</a> adds postgres connections, transactions, query execution and data accessors on top of SQLBricks.</p>
+
 
     <div id="documentation">
       <h2 id="use">Use</h2>
       <p>
-        <p>In <a href="http://nodejs.org">node</a>, SQL Bricks can be accessed with <tt>require('sql-bricks')</tt>. In the browser, it can be accessed with the <tt>SqlBricks</tt> global. SQL Bricks' only dependency is <a href="http://underscorejs.org">Underscore.js</a>. Throughout this documentation, it is assumed that SQL Bricks is set to a local <tt>sql</tt> variable and that top-level functions are also set to local variables (for example: <tt>var sql = SqlBricks, select = sql.select, or = sql.or, $in = sql.in;</tt>).</p>
+        <p>In <a href="https://nodejs.org">node</a>, SQL Bricks can be accessed with <tt>require('sql-bricks')</tt>. In the browser, it can be accessed with the <tt>SqlBricks</tt> global. SQL Bricks has no production dependencies; its only dev dependency is Mocha.js. Throughout this documentation, it is assumed that SQL Bricks is set to a local <tt>sql</tt> variable and that top-level functions are also set to local variables (for example: <tt>var sql = SqlBricks, select = sql.select, or = sql.or, $in = sql.in;</tt>).</p>
         <p>The API is designed to mirror SQL faithfully, with SQL keywords represented by chainable camelCase method and non-keywords passed as string arguments. To make the API easier to use, objects can also be passed in wherever there are key/value pairs.</p>
         <pre>
 select().from('person')
@@ -252,13 +259,25 @@ <h2 id="use">Use</h2>
       </p>
       
       <p id="sql">
-        <b class="header">sql</b><code>sql(str)</code>
+        <b class="header">sql</b><code>sql(str[, values])</code>
         <br />
         <p>The SQL Bricks namespace (saved to the local variable <tt>sql</tt> in these docs) can be called as a function to insert SQL into SQL Bricks somewhere that a value is expected (the right-hand side of <tt>WHERE</tt> criteria, or <tt>insert()</tt>/<tt>update()</tt> values):
 
         <pre>
 select('*').from('person').where({'billing_addr_id': sql('mailing_addr_id')})
 // SELECT * FROM person WHERE billing_addr_id = mailing_addr_id
+</pre>
+      </p>
+      <p>Multiple <b>values</b> can be passed in as separate arguments or as an array (this example uses the postgres <a href="https://www.postgresql.org/docs/9.4/static/functions-json.html#FUNCTIONS-JSONB-OP-TABLE">jsonb contains operator</a>, <tt>@&gt;</tt>):
+        <pre>
+select().where(sql('field @> $ and field @> $', { key: 'value' }, { key: 'value2' })).toParams()
+// {"text": "SELECT * WHERE field @> $1 and field @> $2", "values": [{"key": "value"}, {"key": "value2"}]}
+</pre>
+      </p>
+      <p>Note that numbered params can be used in the literal SQL string and these refer to the position in the current `sql()` call, not the position in the statement as a whole:
+        <pre>
+select().where({name: 'Fred'}).and(sql('f1 @> $2 and f2 @> $1', [{key: 'value' }, {key: 'value2'}])).toParams()
+// {"text": "SELECT * WHERE name = $1 AND f1 @> $3 and f2 @> $2", "values": ["Fred", {"key": "value"}, {"key": "value2"}]}
 </pre>
       </p>
 
@@ -291,6 +310,12 @@ <h2 id="statement">Statement</h2>
         <b class="header">toString</b><code>stmt.toString()</code>
         <br />
         Returns the non-parameterized SQL for the statement. This is called implicitly by Javascript when using a Statement anywhere that a string is expected (string concatenation, <tt>Array.join()</tt>, etc).
+        <br />
+        While <tt>toString()</tt> is easy to use, it is not recommended in most cases because:
+        <ul><li>It doesn't provide <a href="https://en.wikipedia.org/wiki/SQL_injection#Parameterized_statements">robust protection</a> against SQL injection attacks (it just does basic escaping)</li>
+        <li>It doesn't provide as much support for complex data types (objects, arrays, etc, are "stringified" before being passed to your database driver, which then has to interpret them correctly)</li>
+        <li>It does not provide the same level of detail in error messages (see <a href="https://github.com/Suor/sql-bricks-postgres/issues/10">this issue</a>)</li></ul>
+        For the above reasons, it is usually better to use <tt>toParams()</tt>.
       </p>
 
       <p id="toParams">
@@ -356,6 +381,7 @@ <h2 id="select">select</h2>
         <span class="alias">Aliases: <b>innerJoin, leftOuterJoin, rightOuterJoin, fullOuterJoin</b></span>
         <br />
         <p>Adds the specified join to the query. <b>tbl</b> can include an alias after a space or after the <tt>'AS'</tt> keyword (<tt>'my_table my_alias'</tt>). <b>onCriteria</b> is optional if a <a href="#joinCriteria">joinCriteria</a> function has been supplied.</p>
+        <p><i>Note: <b>crossJoin</b> will ignore any <b>onCriteria</b> argument, if supplied.</i></p>
         <pre>
 select().from('person').join('address', {'person.addr_id': 'address.id'});
 // SELECT * FROM person INNER JOIN address ON person.addr_id = address.id
@@ -371,13 +397,49 @@ <h2 id="select">select</h2>
 
 select('*').from('person').join('address').on({'person.addr_id': 'address.id'});
 // SELECT * FROM person INNER JOIN address ON person.addr_id = address.id
+</pre>
+      </p>
+      <p id="using">
+        <b class="header">using</b><code>sel.using(columnList)</code>
+        <br />
+        <p>Joins using <tt>USING</tt> instead of <tt>ON</tt>. <b>columnList</b> can be passed in as one or more string arguments, a comma-delimited string, or an array.</p>
+
+        <pre>
+select('*').from('person').innerJoin('address').using('address_id');
+// SELECT * FROM person INNER JOIN address USING (address_id)
+
+select('*').from('person').join('address').using('address_id', 'country_id');
+// SELECT * FROM person INNER JOIN address USING (address_id, country_id)
+
+select('*').from('person').join('address').using('address_id, country_id');
+// SELECT * FROM person INNER JOIN address USING (address_id, country_id)
+
+select('*').from('person').join('address').using(['address_id', 'country_id']);
+// SELECT * FROM person INNER JOIN address USING (address_id, country_id)
+</pre>
+        <p><i>Note: <b>columnList</b> can also be passed as the second argument to <tt>join</tt> - in which case it must be specified <b>as an array</b> of one or more string values.</i></p>
+        <pre>
+select('*').from('person').join('address', ['address_id', 'country_id']);
+// SELECT * FROM person INNER JOIN address USING (address_id, country_id)
+</pre>
+      </p>
+      <p id="naturaljoin">
+        <b class="header">naturalJoin, naturalLeftJoin, naturalRightJoin, naturalFullJoin</b><br />
+        <code>sel.naturalJoin(tbl)</code><br />
+        <span class="alias">Aliases: <b>naturalInnerJoin, naturalLeftOuterJoin, naturalRightOuterJoin, naturalFullOuterJoin</b></span>
+        <br />
+        <p>Adds the specified natural join to the query. <b>tbl</b> can include an alias after a space or after the <tt>'AS'</tt> keyword (<tt>'my_table my_alias'</tt>).</p>
+        <pre>
+select().from('person').naturalJoin('address');
+// SELECT * FROM person NATURAL INNER JOIN address
 </pre>
       </p>
       <p id="selwhere">
         <b class="header">where</b><span class="alias">Alias: <b>and</b></span><br />
         <code>sel.where(column, value)</code><br />
         <code>sel.where(criteria)</code><br />
-        <code>sel.where(whereExpr)</code>
+        <code>sel.where(whereExpr)</code><br />
+        <code>sel.where(sql)</code>
         <p>Sets or extends the <tt>WHERE</tt> clause. If there already is a <tt>WHERE</tt> clause, the new criteria will be added to a top-level <tt>AND</tt> group.
         <pre>
 select('*').from('person').where('first_name', 'Fred');
@@ -395,6 +457,12 @@ <h2 id="select">select</h2>
         <pre>
 select('*').from('person').where(or(like('last_name', 'Flint%'), {'first_name': 'Fred'}));
 // SELECT * FROM person WHERE last_name LIKE 'Flint%' OR first_name = 'Fred'
+</pre>
+        <p>If necessary, literal SQL can be passed in via <a href="#sql"><tt>sql(str[, values...])</tt></a>:</p>
+        <pre>
+var last_name = 'Flintstone';
+select('*').from('person').where(sql('LTRIM(last_name) = $', last_name));
+// SELECT * FROM person WHERE LTRIM(last_name) = 'Flintstone'
 </pre>
       </p>
       <p id="groupBy">
@@ -433,23 +501,13 @@ <h2 id="select">select</h2>
         <br />
         <p>Sets or extends the list of columns in the <tt>ORDER BY</tt> clause. Columns can be passed as multiple arguments, a single comma-delimited string or an array.</p>
       </p>
-      <p id="limit">
-        <b class="header">limit</b><code>sel.limit(count)</code>
-        <br />
-        <p>Adds a <tt>LIMIT</tt> clause.</p>
-      </p>
-      <p id="offset">
-        <b class="header">offset</b><code>sel.offset(position)</code>
-        <br />
-        <p>Adds an <tt>OFFSET</tt> clause.</p>
-      </p>
       <p id="forUpdate">
         <b class="header">forUpdate, noWait</b><code>sel.forUpdate([tbl, ...]) / sel.noWait()</code>
         <br />
-        <p>Add the <tt>FOR UPDATE</tt> clause to lock all selected records from all tables in the select (or just the tables specified), along with an optional <tt>NO WAIT</tt> at the end:</p>
+        <p>Add the <tt>FOR UPDATE</tt> clause to lock all selected records from all tables in the select (or just the tables specified), along with an optional <tt>NOWAIT</tt> at the end:</p>
         <pre>
-select('addr_id').from('person').forUpdate('addr_id').noWait();
-// SELECT addr_id FROM person FOR UPDATE addr_id NO WAIT
+select('addr_id').from('person').forUpdate().of('addr_id').noWait();
+// SELECT addr_id FROM person FOR UPDATE OF addr_id NOWAIT
 </pre>
       </p>
       
@@ -468,25 +526,6 @@ <h2 id="insert">insert</h2>
         <pre>
 insertInto('person', 'first_name', 'last_name').values('Fred', 'Flintstone');
 // INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')
-</pre>
-      </p>
-      <p id="insorReplace">
-        <b class="header">orReplace, orRollback, orAbort, orFail, orIgnore</b>
-        <code>ins.orReplace(), ins.orRollback(), ins.orAbort(), ins.orFail(), ins.orIgnore()</code>
-        <br />
-        <p>Adds appropriate SQLite/MySQL clause to the <tt>INSERT</tt> statement:</p>
-        <pre>
-insert().orReplace().into('person').values({'first_name': 'Fred', 'id': 33});
-// INSERT OR REPLACE INTO person (first_name, id) VALUES ('Fred', 33)
-</pre>
-      </p>
-      <p id="into">
-        <b class="header">into</b><code>ins.into(tbl)</code>
-        <br />
-        <p><tt>insertInto()</tt> (or the shorter alias <tt>insert()</tt>) is preferred over <tt>insert().into()</tt>. <tt>.into()</tt> is kept as a way to match the SQLite dialect <tt>INSERT OR REPLACE INTO</tt>:</p>
-        <pre>
-insert().orReplace().into('person').values({'first_name': 'Fred', 'last_name': 'Flintstone'});
-// INSERT OR REPLACE INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')
 </pre>
       </p>
       <p id="values">
@@ -518,22 +557,6 @@ <h2 id="insert">insert</h2>
         <p>Note that if you want to call a method on the insert object, you have to save a reference to it before calling <tt>select()</tt>, since <tt>select()</tt> returns a reference to a child Select statement instead of the parent Insert statement.</p>
       </p>
 
-      <p id="returning">
-        <b class="header">returning</b><code>ins.returning(columns)</code>
-        <br />
-        <p>Adds a <tt>RETURNING</tt> clause to the <tt>INSERT</tt> statement.</p>
-        <pre>
-var ins = insert('person', 'first_name, last_name');
-ins.select('first_name, last_name')
-.from('account');
-ins.returning('account.pk');
-// INSERT INTO person (first_name, last_name)
-// SELECT first_name, last_name
-// FROM account
-// RETURNING account.pk
-</pre>
-      </p>
-
       <h2 id="update">update</h2>
       <p id="updconstructor">
         <b class="header">constructor</b><code>update(tbl[, values])</code>
@@ -543,16 +566,6 @@ <h2 id="update">update</h2>
 update('person', {'first_name': 'Fred', 'last_name': 'Flintstone'});
 // UPDATE person SET first_name = 'Fred', last_name = 'Flintstone'
 </pre>
-      <p id="updorReplace">
-        <b class="header">orReplace, orRollback, orAbort, orFail, orIgnore</b>
-        <code>upd.orReplace(), upd.orRollback(), upd.orAbort(), upd.orFail(), upd.orIgnore()</code>
-        <br />
-        <p>Adds appropriate SQLite/MySQL clause to the <tt>UPDATE</tt> statement:</p>
-        <pre>
-update('person').orReplace().set({'first_name': 'Fred', 'id': 33});
-// UPDATE OR REPLACE person SET first_name = 'Fred', id = 33
-</pre>
-      </p>
 
       <p id="set">
         <b class="header">set</b><span class="alias">Alias: <b>values</b></span><br />
@@ -749,7 +762,7 @@ <h2 id="conveniences">Conveniences</h2>
 
         <pre>
 var alias_expansions = {'psn': 'person', 'addr': 'address', 'zip': 'zipcode', 'usr': 'user'};
-var table_to_alias = _.invert(alias_expansions);
+var table_to_alias = invert(alias_expansions);
 sql.joinCriteria(function(left_tbl, left_alias, right_tbl, right_alias) {
   var criteria = {};
   criteria[left_alias + '.' + table_to_alias[right_tbl] + '_id'] = right_alias + '.id';
@@ -821,12 +834,13 @@ <h2 id="askeyword">AS Keyword</h2>
 
       <h2 id="contributing">Contributing</h2>
       <p>Before sending a pull request, please verify that <a href="browser-tests.html">all the existing tests</a> pass and add new tests for the changes you are making. The tests can be run in node with <tt>npm test</tt> (provided <tt>npm install</tt> has been run to install the dependencies) or they can be run in the browser with <tt>browser-tests.html</tt>. All of the examples in the documentation are run as tests, in addition to the tests in tests.js.</p>
-      <p>Note that <b>pull requests for additional SQL dialects</b> or extensions beyond ANSI SQL, Postgres and SQLite will probably not be merged. If you would like support for a different dialect, you are welcome to maintain a dialect-specific fork.</p>
+      <p>Note that <b>pull requests for additional SQL dialects</b> or extensions beyond ANSI SQL-92 will probably not be merged. If you would like support for a different dialect, you are welcome to maintain a dialect-specific fork or a library that extends sql-bricks.</p>
       <p>Also, <b>pull requests for additional SQL statements</b> beyond the four CRUD statements (<tt>SELECT</tt>, <tt>UPDATE</tt>, <tt>INSERT</tt>, <tt>DELETE</tt>) will probably not be merged. Other SQL statements do not benefit as much from re-use and composition; the goal being to keep SQL Bricks small, sharp and low-maintenance.</p>
 
       <h2 id="acknowledgments">Acknowledgments</h2>
+      <p>Thanks to <a href="https://github.com/Suor">Suor</a> for taking over maintenance of the postgres-dialect extension library: <a href="https://github.com/Suor/sql-bricks-postgres">sql-bricks-postgres</a>. Thanks to <a href="https://github.com/tamarzil">tamarzil</a> for creating and maintaining the mysql-dialect extension library: <a href="https://github.com/tamarzil/mysql-bricks">mysql-bricks</a></p>
       <p>Huge thanks to <a href="https://github.com/brianc">Brian C</a> for his hard work supporting and maintaining <a href="https://github.com/brianc/node-sql">node-sql</a> and <a href="https://github.com/brianc/node-postgres">node-postgres</a> and especially for his patience with me and my pull requests.</p>
-      <p>Also, thanks to <a href="https://github.com/jashkenas">jashkenas</a> for <a href="https://github.com/jashkenas/underscore">underscore</a>, which SQL Bricks depends on -- and for its documentation, which served as a model and template for these docs.</p>
+      <p>Also, thanks to <a href="https://github.com/jashkenas">jashkenas</a> for Underscore.js and its documentation, which served as a model and template for these docs.</p>
 
       <h2 id="license">License</h2>
       <p>SQL Bricks is <a href="https://github.com/CSNW/sql-bricks/raw/master/LICENSE.md">MIT licensed</a>.</p>
@@ -835,7 +849,6 @@ <h2 id="license">License</h2>
   </div>
 
   <!-- include it so you can play in the console -->
-  <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.5.2/underscore-min.js"></script>
   <script type="text/javascript" src="sql-bricks.js"></script>
   <script>
     sql = SqlBricks;
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..abf7749
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,963 @@
+{
+  "name": "sql-bricks",
+  "version": "3.0.1",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "ansi-colors": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz",
+      "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==",
+      "dev": true
+    },
+    "ansi-regex": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz",
+      "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==",
+      "dev": true
+    },
+    "ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "requires": {
+        "color-convert": "^1.9.0"
+      }
+    },
+    "argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "dev": true,
+      "requires": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "browser-stdout": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
+      "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
+      "dev": true
+    },
+    "call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      }
+    },
+    "camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "dev": true
+    },
+    "chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "dependencies": {
+        "supports-color": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        }
+      }
+    },
+    "cliui": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
+      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
+      "dev": true,
+      "requires": {
+        "string-width": "^3.1.0",
+        "strip-ansi": "^5.2.0",
+        "wrap-ansi": "^5.1.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+          "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "requires": {
+        "color-name": "1.1.3"
+      }
+    },
+    "color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
+      "dev": true
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "dev": true
+    },
+    "debug": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
+      "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+      "dev": true,
+      "requires": {
+        "ms": "^2.1.1"
+      }
+    },
+    "decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
+      "dev": true
+    },
+    "define-properties": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+      "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+      "dev": true,
+      "requires": {
+        "object-keys": "^1.0.12"
+      }
+    },
+    "diff": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz",
+      "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==",
+      "dev": true
+    },
+    "emoji-regex": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+      "dev": true
+    },
+    "es-abstract": {
+      "version": "1.19.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.19.2.tgz",
+      "integrity": "sha512-gfSBJoZdlL2xRiOCy0g8gLMryhoe1TlimjzU99L/31Z8QEGIhVQI+EWwt5lT+AuU9SnorVupXFqqOGqGfsyO6w==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "es-to-primitive": "^1.2.1",
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.1.1",
+        "get-symbol-description": "^1.0.0",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.3",
+        "internal-slot": "^1.0.3",
+        "is-callable": "^1.2.4",
+        "is-negative-zero": "^2.0.2",
+        "is-regex": "^1.1.4",
+        "is-shared-array-buffer": "^1.0.1",
+        "is-string": "^1.0.7",
+        "is-weakref": "^1.0.2",
+        "object-inspect": "^1.12.0",
+        "object-keys": "^1.1.1",
+        "object.assign": "^4.1.2",
+        "string.prototype.trimend": "^1.0.4",
+        "string.prototype.trimstart": "^1.0.4",
+        "unbox-primitive": "^1.0.1"
+      },
+      "dependencies": {
+        "object.assign": {
+          "version": "4.1.2",
+          "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz",
+          "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==",
+          "dev": true,
+          "requires": {
+            "call-bind": "^1.0.0",
+            "define-properties": "^1.1.3",
+            "has-symbols": "^1.0.1",
+            "object-keys": "^1.1.1"
+          }
+        }
+      }
+    },
+    "es-to-primitive": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
+      "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
+      "dev": true,
+      "requires": {
+        "is-callable": "^1.1.4",
+        "is-date-object": "^1.0.1",
+        "is-symbol": "^1.0.2"
+      }
+    },
+    "escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "dev": true
+    },
+    "esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true
+    },
+    "find-up": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "dev": true,
+      "requires": {
+        "locate-path": "^3.0.0"
+      }
+    },
+    "flat": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz",
+      "integrity": "sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==",
+      "dev": true,
+      "requires": {
+        "is-buffer": "~2.0.3"
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+      "dev": true
+    },
+    "function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
+      "dev": true
+    },
+    "get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true
+    },
+    "get-intrinsic": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
+      "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.1"
+      }
+    },
+    "get-symbol-description": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz",
+      "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "get-intrinsic": "^1.1.1"
+      }
+    },
+    "glob": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
+      "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
+      "dev": true,
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "growl": {
+      "version": "1.10.5",
+      "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz",
+      "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==",
+      "dev": true
+    },
+    "has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1"
+      }
+    },
+    "has-bigints": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.1.tgz",
+      "integrity": "sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA==",
+      "dev": true
+    },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "dev": true
+    },
+    "has-tostringtag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz",
+      "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==",
+      "dev": true,
+      "requires": {
+        "has-symbols": "^1.0.2"
+      }
+    },
+    "he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "dev": true
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dev": true,
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "internal-slot": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.3.tgz",
+      "integrity": "sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==",
+      "dev": true,
+      "requires": {
+        "get-intrinsic": "^1.1.0",
+        "has": "^1.0.3",
+        "side-channel": "^1.0.4"
+      }
+    },
+    "is-bigint": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz",
+      "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==",
+      "dev": true,
+      "requires": {
+        "has-bigints": "^1.0.1"
+      }
+    },
+    "is-boolean-object": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz",
+      "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "has-tostringtag": "^1.0.0"
+      }
+    },
+    "is-buffer": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz",
+      "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==",
+      "dev": true
+    },
+    "is-callable": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.4.tgz",
+      "integrity": "sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==",
+      "dev": true
+    },
+    "is-date-object": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz",
+      "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==",
+      "dev": true,
+      "requires": {
+        "has-tostringtag": "^1.0.0"
+      }
+    },
+    "is-fullwidth-code-point": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+      "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
+      "dev": true
+    },
+    "is-negative-zero": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz",
+      "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==",
+      "dev": true
+    },
+    "is-number-object": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.6.tgz",
+      "integrity": "sha512-bEVOqiRcvo3zO1+G2lVMy+gkkEm9Yh7cDMRusKKu5ZJKPUYSJwICTKZrNKHA2EbSP0Tu0+6B/emsYNHZyn6K8g==",
+      "dev": true,
+      "requires": {
+        "has-tostringtag": "^1.0.0"
+      }
+    },
+    "is-regex": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz",
+      "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "has-tostringtag": "^1.0.0"
+      }
+    },
+    "is-shared-array-buffer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.1.tgz",
+      "integrity": "sha512-IU0NmyknYZN0rChcKhRO1X8LYz5Isj/Fsqh8NJOSf+N/hCOTwy29F32Ik7a+QszE63IdvmwdTPDd6cZ5pg4cwA==",
+      "dev": true
+    },
+    "is-string": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz",
+      "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==",
+      "dev": true,
+      "requires": {
+        "has-tostringtag": "^1.0.0"
+      }
+    },
+    "is-symbol": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz",
+      "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==",
+      "dev": true,
+      "requires": {
+        "has-symbols": "^1.0.2"
+      }
+    },
+    "is-weakref": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz",
+      "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2"
+      }
+    },
+    "isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
+      "dev": true
+    },
+    "js-yaml": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
+      "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+      "dev": true,
+      "requires": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      }
+    },
+    "locate-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "dev": true,
+      "requires": {
+        "p-locate": "^3.0.0",
+        "path-exists": "^3.0.0"
+      }
+    },
+    "lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "dev": true
+    },
+    "log-symbols": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz",
+      "integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==",
+      "dev": true,
+      "requires": {
+        "chalk": "^2.0.1"
+      }
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dev": true,
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz",
+      "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==",
+      "dev": true
+    },
+    "mkdirp": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.4.tgz",
+      "integrity": "sha512-iG9AK/dJLtJ0XNgTuDbSyNS3zECqDlAhnQW4CsNxBG3LQJBbHmRX1egw39DmtOdCAqY+dKXV+sgPgilNWUKMVw==",
+      "dev": true,
+      "requires": {
+        "minimist": "^1.2.5"
+      }
+    },
+    "mocha": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-6.2.3.tgz",
+      "integrity": "sha512-0R/3FvjIGH3eEuG17ccFPk117XL2rWxatr81a57D+r/x2uTYZRbdZ4oVidEUMh2W2TJDa7MdAb12Lm2/qrKajg==",
+      "dev": true,
+      "requires": {
+        "ansi-colors": "3.2.3",
+        "browser-stdout": "1.3.1",
+        "debug": "3.2.6",
+        "diff": "3.5.0",
+        "escape-string-regexp": "1.0.5",
+        "find-up": "3.0.0",
+        "glob": "7.1.3",
+        "growl": "1.10.5",
+        "he": "1.2.0",
+        "js-yaml": "3.13.1",
+        "log-symbols": "2.2.0",
+        "minimatch": "3.0.4",
+        "mkdirp": "0.5.4",
+        "ms": "2.1.1",
+        "node-environment-flags": "1.0.5",
+        "object.assign": "4.1.0",
+        "strip-json-comments": "2.0.1",
+        "supports-color": "6.0.0",
+        "which": "1.3.1",
+        "wide-align": "1.1.3",
+        "yargs": "13.3.2",
+        "yargs-parser": "13.1.2",
+        "yargs-unparser": "1.6.0"
+      }
+    },
+    "ms": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
+      "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
+      "dev": true
+    },
+    "node-environment-flags": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.5.tgz",
+      "integrity": "sha512-VNYPRfGfmZLx0Ye20jWzHUjyTW/c+6Wq+iLhDzUI4XmhrDd9l/FozXV3F2xOaXjvp0co0+v1YSR3CMP6g+VvLQ==",
+      "dev": true,
+      "requires": {
+        "object.getownpropertydescriptors": "^2.0.3",
+        "semver": "^5.7.0"
+      }
+    },
+    "object-inspect": {
+      "version": "1.12.0",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.0.tgz",
+      "integrity": "sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==",
+      "dev": true
+    },
+    "object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "dev": true
+    },
+    "object.assign": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz",
+      "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==",
+      "dev": true,
+      "requires": {
+        "define-properties": "^1.1.2",
+        "function-bind": "^1.1.1",
+        "has-symbols": "^1.0.0",
+        "object-keys": "^1.0.11"
+      }
+    },
+    "object.getownpropertydescriptors": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.3.tgz",
+      "integrity": "sha512-VdDoCwvJI4QdC6ndjpqFmoL3/+HxffFBbcJzKi5hwLLqqx3mdbedRpfZDdK0SrOSauj8X4GzBvnDZl4vTN7dOw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.19.1"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dev": true,
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "dev": true,
+      "requires": {
+        "p-try": "^2.0.0"
+      }
+    },
+    "p-locate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+      "dev": true,
+      "requires": {
+        "p-limit": "^2.0.0"
+      }
+    },
+    "p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "dev": true
+    },
+    "path-exists": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+      "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+      "dev": true
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "dev": true
+    },
+    "require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
+      "dev": true
+    },
+    "require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "dev": true
+    },
+    "semver": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+      "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+      "dev": true
+    },
+    "set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=",
+      "dev": true
+    },
+    "side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      }
+    },
+    "sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=",
+      "dev": true
+    },
+    "string-width": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+      "dev": true,
+      "requires": {
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^4.0.0"
+      }
+    },
+    "string.prototype.trimend": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz",
+      "integrity": "sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3"
+      }
+    },
+    "string.prototype.trimstart": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz",
+      "integrity": "sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3"
+      }
+    },
+    "strip-ansi": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+      "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=",
+      "dev": true,
+      "requires": {
+        "ansi-regex": "^3.0.0"
+      }
+    },
+    "strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+      "dev": true
+    },
+    "supports-color": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz",
+      "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==",
+      "dev": true,
+      "requires": {
+        "has-flag": "^3.0.0"
+      }
+    },
+    "unbox-primitive": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.1.tgz",
+      "integrity": "sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1",
+        "has-bigints": "^1.0.1",
+        "has-symbols": "^1.0.2",
+        "which-boxed-primitive": "^1.0.2"
+      }
+    },
+    "which": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
+      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
+      "dev": true,
+      "requires": {
+        "isexe": "^2.0.0"
+      }
+    },
+    "which-boxed-primitive": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz",
+      "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==",
+      "dev": true,
+      "requires": {
+        "is-bigint": "^1.0.1",
+        "is-boolean-object": "^1.1.0",
+        "is-number-object": "^1.0.4",
+        "is-string": "^1.0.5",
+        "is-symbol": "^1.0.3"
+      }
+    },
+    "which-module": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
+      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=",
+      "dev": true
+    },
+    "wide-align": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz",
+      "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==",
+      "dev": true,
+      "requires": {
+        "string-width": "^1.0.2 || 2"
+      }
+    },
+    "wrap-ansi": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
+      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+      "dev": true,
+      "requires": {
+        "ansi-styles": "^3.2.0",
+        "string-width": "^3.0.0",
+        "strip-ansi": "^5.0.0"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+          "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "dev": true
+    },
+    "y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==",
+      "dev": true
+    },
+    "yargs": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz",
+      "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==",
+      "dev": true,
+      "requires": {
+        "cliui": "^5.0.0",
+        "find-up": "^3.0.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^3.0.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^13.1.2"
+      },
+      "dependencies": {
+        "ansi-regex": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+          "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+          "dev": true
+        },
+        "string-width": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+          "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+          "dev": true,
+          "requires": {
+            "emoji-regex": "^7.0.1",
+            "is-fullwidth-code-point": "^2.0.0",
+            "strip-ansi": "^5.1.0"
+          }
+        },
+        "strip-ansi": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+          "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+          "dev": true,
+          "requires": {
+            "ansi-regex": "^4.1.0"
+          }
+        }
+      }
+    },
+    "yargs-parser": {
+      "version": "13.1.2",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz",
+      "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==",
+      "dev": true,
+      "requires": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      }
+    },
+    "yargs-unparser": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz",
+      "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==",
+      "dev": true,
+      "requires": {
+        "flat": "^4.1.0",
+        "lodash": "^4.17.15",
+        "yargs": "^13.3.0"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
index aaae949..feb9d7e 100644
--- a/package.json
+++ b/package.json
@@ -1,46 +1,56 @@
-{
-  "name": "sql-bricks",
-  "version": "0.12.0",
-  "author": "Peter Rust <peter@cornerstonenw.com>",
-  "description": "Transparent, Schemaless SQL Generation",
-  "homepage": "http://csnw.github.io/sql-bricks",
-  "bugs": "https://github.com/CSNW/sql-bricks/issues",
-  "scripts": {
-    "prepublish": "node tests/gen-tests.js",
-    "test": "mocha tests/tests.js tests/doctests.js"
-  },
-  "main": "sql-bricks.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/CSNW/sql-bricks.git"
-  },
-  "keywords": [
-    "sql", "generation", "generate", "query", "pg", "postgres", "sqlite", "builder", "select", "insert", "update", "delete"
-  ],
-  "engines": {
-    "node": "*"
-  },
-  "dependencies": {
-    "underscore": "1.4.x"
-  },
-  "devDependencies": {
-    "mocha": "1.13.x"
-  },
-  "license": "MIT",
-  "testling": {
-    "html": "browser-tests.html",
-    "browsers": [
-      "chrome/29.0",
-      "iexplore/8.0",
-      "iexplore/9.0",
-      "iexplore/10.0",
-      "firefox/4.0",
-      "firefox/6.0",
-      "firefox/24.0",
-      "safari/6.0",
-      "iphone/6.0",
-      "ipad/6.0",
-      "android-browser/4.2"
-    ]
-  }
-}
+{
+  "name": "sql-bricks",
+  "version": "3.0.1",
+  "author": "Peter Rust <peter@cornerstonenw.com>",
+  "description": "Transparent, Schemaless SQL Generation",
+  "homepage": "http://csnw.github.io/sql-bricks",
+  "bugs": "https://github.com/CSNW/sql-bricks/issues",
+  "scripts": {
+    "prepublish": "node tests/gen-tests.js",
+    "test": "mocha tests/tests.js tests/doctests.js && mocha tests/tests.js tests/doctests.js --empty-extension"
+  },
+  "main": "sql-bricks.js",
+  "types": "sql-bricks.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CSNW/sql-bricks.git"
+  },
+  "keywords": [
+    "sql",
+    "generation",
+    "generate",
+    "query",
+    "pg",
+    "postgres",
+    "sqlite",
+    "builder",
+    "select",
+    "insert",
+    "update",
+    "delete"
+  ],
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "^6.2.2"
+  },
+  "license": "MIT",
+  "testling": {
+    "html": "browser-tests.html",
+    "browsers": [
+      "chrome/29.0",
+      "iexplore/8.0",
+      "iexplore/9.0",
+      "iexplore/10.0",
+      "firefox/4.0",
+      "firefox/6.0",
+      "firefox/24.0",
+      "safari/6.0",
+      "iphone/6.0",
+      "ipad/6.0",
+      "android-browser/4.2"
+    ]
+  }
+}
diff --git a/readme.md b/readme.md
index 8101c91..6b7fa0a 100644
--- a/readme.md
+++ b/readme.md
@@ -1,58 +1,94 @@
-# SQL Bricks.js
+# SQL Bricks.js 
 
-[![Build Status](https://travis-ci.org/CSNW/sql-bricks.png?branch=master)](https://travis-ci.org/CSNW/sql-bricks)
+[![Build Status](https://travis-ci.org/CSNW/sql-bricks.svg?branch=master)](https://travis-ci.org/CSNW/sql-bricks)
 
 SQL Bricks.js is a transparent, schemaless library for building and composing SQL statements.
 
-- Supports all [SQL-92](http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt) clauses for select/insert/update/delete (plus some postgres & sqlite additions)
-- Over [175 tests](http://csnw.github.io/sql-bricks/browser-tests.html)
-- Easy-to-use, comprehensive [docs](http://csnw.github.io/sql-bricks)
-- Single straightforward [source file](sql-bricks.js) (less than 1,000 lines), easy to understand & debug
-
-
-Comparison with popular SQL-generation libraries:
-
-library         | lines | files | schema       | language     | other notes  
---------------- | ----- | ----- | ------------ | --------     | --------------
-[Knex][1]       | 3500  |    30 | schema       | javascript   | transactions, migrations, promises, connection pooling
-[Squel][2]      | 1000  |     3 | schemaless   | coffeescript | 
-[node-sql][3]   | 2600  |    59 | schema       | javascript   |
-[mongo-sql][4]  | 1700  |    49 | schemaless   | javascript   | 
-[gesundheit][5] | 1600  |    21 | schemaless   | coffeescript | uses Any-DB to wrap the DB driver
-[sql-bricks][6] |  750  |     1 | schemaless   | javascript   |
+- The core library supports all [SQL-92](https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt) clauses for `SELECT`, `INSERT`, `UPDATE` and `DELETE` (with the exception of asc/desc/collate options for `orderBy()`, see [#73](https://github.com/CSNW/sql-bricks/issues/73))
+  - Postgres extensions are at https://github.com/Suor/sql-bricks-postgres
+  - MySQL extensions are at https://github.com/tamarzil/mysql-bricks
+  - SQLite extensions are at https://github.com/CSNW/sql-bricks-sqlite
+- Over [200 tests](https://datavjs.github.io/sql-bricks/browser-tests.html)
+- Easy-to-use, comprehensive [docs](https://datavjs.github.io/sql-bricks)
+- Single [source file](sql-bricks.js) (~1,100 lines)
+- No production dependencies and only 1 dev dependency (Mocha.js)
+
+Comparison with other SQL-generation JS libraries:
+
+library         | lines | files | schema     | other notes  
+--------------- | ----- | ----- | ---------- | --------------
+[Knex][1]       | 20k   |   ~50 | schema     | transactions, migrations, promises, connection pooling
+[Squel][2]      | 1.7k  |     1 | schemaless |
+[node-sql][3]   | 2.6k  |   ~60 | schema     |
+[mongo-sql][4]  | 1.7k  |   ~50 | schemaless |
+[sql-bricks][5] | 1.1k  |     1 | schemaless |
 
 [1]: https://github.com/tgriesser/knex
 [2]: https://github.com/hiddentao/squel
 [3]: https://github.com/brianc/node-sql
 [4]: https://github.com/goodybag/mongo-sql
-[5]: https://github.com/BetSmartMedia/gesundheit
-[6]: https://github.com/CSNW/sql-bricks
+[5]: https://github.com/CSNW/sql-bricks
+
+# Related Libraries
+
+* [mysql-bricks](https://github.com/tamarzil/mysql-bricks) adds mysql-dialect extensions:
+  * `INSERT ... ON DUPLICATE KEY UPDATE ...`
+  * `INSERT IGNORE ...`
+  * `LIMIT (SELECT / UPDATE / DELETE)`
+  * `OFFSET`
+  * `ORDER BY (UPDATE / DELETE)`
+* [sql-bricks-sqlite](https://github.com/CSNW/sql-bricks-sqlite) adds sqlite-dialect extensions:
+  * `LIMIT` and `OFFSET`
+  * `OR REPLACE`, `OR ABORT`, `OR ROLLBACK`, `OR FAIL`
+* [sql-bricks-postgres](https://github.com/Suor/sql-bricks-postgres) adds postgres-dialect extensions:
+  * `LIMIT` and `OFFSET`
+  * `RETURNING`
+  * `UPDATE ... FROM`
+  * `DELETE ... USING`
+  * `FROM VALUES`
+* [pg-bricks](https://github.com/Suor/pg-bricks) adds:
+  * connections
+  * transactions
+  * query execution
+  * data accessors
+* [A Layer Above Database Connectors](https://github.com/paleo/ladc) adds:
+  * A common way to access to relational databases (SQLite & Postgres as of Oct 2019)
+  * A pool of connections in order to allow transactions in an asynchronous context;
+  * A way to augment your connector with your SQL query builder (has a sql-bricks plugin)
 
 # Use
 
-SQLBricks' only dependency is [Underscore.js](http://underscorejs.org/).
-
 In the browser:
 
 ```javascript
 var select = SqlBricks.select;
-
-select().from('person').where({last_name: 'Rubble'});
-// SELECT * FROM person WHERE last_name = 'Rubble'
 ```
 
 In node:
 
 ```javascript
 var select = require('sql-bricks').select;
+```
 
-select().from('person').where({last_name: 'Rubble'});
-// SELECT * FROM person WHERE last_name = 'Rubble'
+A simple select via `.toString()` and `.toParams()`:
+
+```javascript
+select().from('person').where({last_name: 'Rubble'}).toString();
+// "SELECT * FROM person WHERE last_name = 'Rubble'"
+
+select().from('person').where({last_name: 'Rubble'}).toParams();
+// {"text": "SELECT * FROM person WHERE last_name = $1", "values": ["Rubble"]}
 ```
 
+While `toString()` is slightly easier, `toParams()` is recommended because:
+
+* It provides [robust protection](https://en.wikipedia.org/wiki/SQL_injection#Parameterized_statements) against SQL injection attacks (toString() just does basic escaping)
+* It provides better support for complex data types (objects, arrays, etc, are passed directly to your database driver instead of being "stringified")
+* It provides more helpful error messages (see https://github.com/Suor/sql-bricks-postgres/issues/10)
+
 # Examples
 
-The [SQLBricks API](http://csnw.github.io/sql-bricks/) is comprehensive, supporting all of SQL-92 for select/insert/update/delete. It is also quite flexible; in most places arguments can be passed in a variety of ways (arrays, objects, separate arguments, etc). That said, here are some of the most common operations:
+The [SQLBricks API](https://datavjs.github.io/sql-bricks/) is comprehensive, supporting all of SQL-92 for select/insert/update/delete. It is also quite flexible; in most places arguments can be passed in a variety of ways (arrays, objects, separate arguments, etc). That said, here are some of the most common operations:
 
 ```javascript
 // convenience variables (for node; for the browser: "var sql = SqlBricks;")
@@ -100,6 +136,6 @@ update('person', {'first_name': 'Fred'}).where({'last_name': 'Flintstone'}).toPa
 // {"text": "UPDATE person SET first_name = ? WHERE last_name = ?", "values": ["Fred", "Flintstone"]}
 ```
 
-Documentation: http://csnw.github.io/sql-bricks
+Full documentation: https://datavjs.github.io/sql-bricks
 
 License: [MIT](LICENSE.md)
diff --git a/sql-bricks.d.ts b/sql-bricks.d.ts
new file mode 100644
index 0000000..5496b6c
--- /dev/null
+++ b/sql-bricks.d.ts
@@ -0,0 +1,408 @@
+// Type definitions for sql-bricks 2.0
+// Project: http://csnw.github.io/sql-bricks
+// Definitions by: Narcisse Assogba <https://github.com/adn05>
+//                 Paleo <https://github.com/paleo>
+
+declare namespace SqlBricks {
+  /**
+   * Statement is an abstract base class for all statements (SELECT, INSERT, UPDATE, DELETE)
+   * and should never be instantiated directly. It is exposed because it can be used with the
+   * instanceof operator to easily determine whether something is a SQL Bricks statement: my_var instanceof Statement.
+   */
+  interface Statement {
+    /**
+     * Clones a statement so that subsequent modifications do not affect the original statement.
+     */
+    clone(): this
+
+    /**
+     * Returns the non-parameterized SQL for the statement. This is called implicitly by Javascript when using a Statement anywhere that a string is expected (string concatenation, Array.join(), etc).
+     * While toString() is easy to use, it is not recommended in most cases because:
+     *    It doesn't provide robust protection against SQL injection attacks (it just does basic escaping)
+     *    It doesn't provide as much support for complex data types (objects, arrays, etc, are "stringified" before being passed to your database driver, which then has to interpret them correctly)
+     *    It does not provide the same level of detail in error messages (see this issue)
+     * For the above reasons, it is usually better to use toParams().
+     */
+    toString(): string
+
+    /**
+     * Returns an object with two properties: a parameterized text string and a values array. The values are populated with anything on the right-hand side
+     * of a WHERE criteria,as well as any values passed into an insert() or update() (they can be passed explicitly with val() or opted out of with sql())
+     * @param options A placeholder option of '?%d' can be passed to generate placeholders compatible with node-sqlite3 (%d is replaced with the parameter #):
+     * @example
+     * update('person', {'first_name': 'Fred'}).where({'last_name': 'Flintstone'}).toParams({placeholder: '?%d'});
+     *    // {"text": "UPDATE person SET first_name = ?1 WHERE last_name = ?2", "values": ["Fred", "Flintstone"]}
+     */
+    toParams(options?: { placeholder: string }): SqlBricksParam
+  }
+
+  interface SqlBricksParam {
+    text: string
+    values: any[]
+  }
+
+  type TableName = string | SelectStatement
+
+  interface OnCriteria {
+    [column: string]: string
+  }
+
+  interface WhereObject {
+    [column: string]: any
+  }
+
+  interface WhereGroup {
+    op?: string
+    expressions: WhereExpression[]
+  }
+
+  interface WhereBinary {
+    op: string
+    col: string | SelectStatement
+    val: any
+    quantifier: string
+  }
+
+  /**
+   * When a non-expression object is passed somewhere a whereExpression is expected,
+   * each key/value pair will be ANDed together:
+   */
+  type WhereExpression = WhereGroup | WhereBinary | WhereObject | string
+
+  /**
+   * A SELECT statement
+   */
+  interface SelectStatement extends Statement {
+    /**
+     * Appends additional columns to an existing query.
+     * @param columns can be passed as multiple arguments, a comma-delimited string or an array.
+     */
+    select(...columns: Array<string | SelectStatement>): SelectStatement
+    /**
+     * Appends additional columns to an existing query.
+     * @param columns can be passed as multiple arguments, a comma-delimited string or an array.
+     */
+    select(columns: string[] | SelectStatement[]): SelectStatement
+
+    as(alias: string): SelectStatement
+
+    distinct(...columns: Array<string | SelectStatement>): SelectStatement
+    distinct(columns: string[] | SelectStatement[]): SelectStatement
+
+    /**
+     * Makes the query a SELECT ... INTO query (which creates a new table with the results of the query).
+     * @alias intoTable
+     * @param tbl new table to create
+     */
+    into(tbl: TableName): SelectStatement
+    /**
+     * Makes the query a SELECT ... INTO query (which creates a new table with the results of the query).
+     * @alias into
+     * @param tbl new table to create
+     */
+    intoTable(tbl: TableName): SelectStatement
+
+    intoTemp(tbl: TableName): SelectStatement
+    intoTempTable(tbl: TableName): SelectStatement
+
+    /**
+     * Table names can be passed in as multiple string arguments, a comma-delimited string or an array.
+     * @param tbls table names
+     */
+    from(...tbls: TableName[]): SelectStatement
+    /**
+     * Table names can be passed in as multiple string arguments, a comma-delimited string or an array.
+     * @param tbls array of table names
+     */
+    from(tbls: TableName[]): SelectStatement
+
+    /**
+     * Adds the specified join to the query.
+     * @alias innerJoin
+     * @param tbl can include an alias after a space or after the 'AS' keyword ('my_table my_alias').
+     * @param onCriteria is optional if a joinCriteria function has been supplied.
+     */
+    join(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    join(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    join(firstTbl: string, ...otherTbls: string[]): SelectStatement
+
+    leftJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    leftJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    leftJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    rightJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    rightJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    rightJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    fullJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    fullJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    fullJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    crossJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    crossJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    crossJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    innerJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    innerJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    innerJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    leftOuterJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    leftOuterJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    leftOuterJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    rightOuterJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    rightOuterJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    rightOuterJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+    fullOuterJoin(tbl: string, criteria?: OnCriteria | string[] | WhereExpression): SelectStatement
+    fullOuterJoin(tbl: string, onCol1: string, onCol2: string): SelectStatement
+    fullOuterJoin(firstTbl: string, ...otherTbls: string[]): SelectStatement
+
+    on(onCriteria: OnCriteria | WhereExpression): SelectStatement
+    on(onCol1: string, onCol2: string): SelectStatement
+
+    /**
+     * Joins using USING instead of ON.
+     * @param columnList columnList can be passed in as one or more string arguments, a comma-delimited string, or an array.
+     * @example
+     * select('*').from('person').join('address').using('address_id', 'country_id');
+     * // SELECT * FROM person INNER JOIN address USING (address_id, country_id)
+     */
+    using(...columnList: string[]): SelectStatement
+    using(columnList: string[]): SelectStatement
+
+    /**
+     * Adds the specified natural join to the query.
+     * @param tbl can include an alias after a space or after the 'AS' keyword ('my_table my_alias').
+     */
+    naturalJoin(tbl: string): SelectStatement
+    naturalLeftJoin(tbl: string): SelectStatement
+    naturalRightJoin(tbl: string): SelectStatement
+    naturalFullJoin(tbl: string): SelectStatement
+
+    naturalInnerJoin(tbl: string): SelectStatement
+    naturalLeftOuterJoin(tbl: string): SelectStatement
+    naturalRightOuterJoin(tbl: string): SelectStatement
+    naturalFullOuterJoin(tbl: string): SelectStatement
+
+    where(column?: string | null, value?: any): SelectStatement
+    where(...whereExpr: WhereExpression[]): SelectStatement
+
+    and(...options: any[]): SelectStatement
+
+    /**
+     * Sets or extends the GROUP BY columns.
+     * @param columns can take multiple arguments, a single comma-delimited string or an array.
+     */
+    groupBy(...columns: string[]): SelectStatement
+    groupBy(columns: string[]): SelectStatement
+
+    having(column: string, value: string): SelectStatement
+    having(whereExpr: WhereExpression): SelectStatement
+
+    /**
+     * Sets or extends the list of columns in the ORDER BY clause.
+     * @param columns can be passed as multiple arguments, a single comma-delimited string or an array.
+     */
+    orderBy(...columns: string[]): SelectStatement
+    orderBy(columns: string[]): SelectStatement
+    order(...columns: string[]): SelectStatement
+    order(columns: string[]): SelectStatement
+
+    forUpdate(...tbls: string[]): SelectStatement
+    of(tlb: string): SelectStatement
+    noWait(): SelectStatement
+
+    union(...stmt: Statement[]): SelectStatement
+    intersect(...stmt: Statement[]): SelectStatement
+    minus(...stmt: Statement[]): SelectStatement
+    except(...stmt: Statement[]): SelectStatement
+  }
+
+  /**
+   * An INSERT statement
+   */
+  interface InsertStatement extends Statement {
+    into(tbl: TableName, ...columns: any[]): InsertStatement
+    intoTable(tbl: TableName, ...columns: any[]): InsertStatement
+    select(...columns: Array<string | SelectStatement>): InsertStatement
+    select(columns: string[] | SelectStatement[]): InsertStatement
+    values(...values: any[]): InsertStatement
+  }
+
+  /**
+   * An UPDATE statement
+   */
+  interface UpdateStatement extends Statement {
+    values(...values: any[]): UpdateStatement
+    set(...values: any[]): UpdateStatement
+    where(column?: string | null, value?: any): UpdateStatement
+    where(...whereExpr: WhereExpression[]): UpdateStatement
+    and(column?: string | null, value?: any): UpdateStatement
+    and(...whereExpr: WhereExpression[]): UpdateStatement
+  }
+
+  /**
+   * A DELETE statement
+   */
+  interface DeleteStatement extends Statement {
+    from(...tbls: string[]): DeleteStatement
+    using(...columnList: string[]): DeleteStatement
+    using(columnList: string[]): DeleteStatement
+    where(column?: string | null, value?: any): DeleteStatement
+    where(...whereExpr: WhereExpression[]): DeleteStatement
+    and(column?: string | null, value?: any): DeleteStatement
+    and(...whereExpr: WhereExpression[]): DeleteStatement
+  }
+}
+
+interface SqlBricksFn {
+  (...params: any[]): any
+  /**
+   * Wraps a value (user-supplied string, number, boolean, etc) so that it can be passed into SQL Bricks
+   * anywhere that a column is expected (the left-hand side of WHERE criteria and many other SQL Bricks APIs)
+   * @param value value to be wraped
+   */
+  val(value: any): any
+
+  /**
+   * Returns a new INSERT statement. It can be used with or without the new operator.
+   * @alias insertInto
+   * @param tbl table name
+   * @param values a values object or a columns list. Passing a set of columns (as multiple arguments, a comma-delimited string or an array)
+   * will put the statement into split keys/values mode, where a matching array of values is expected in values()
+   * @example
+   * insert('person', {'first_name': 'Fred', 'last_name': 'Flintstone'});
+   * // INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')
+   */
+  insert(tbl?: string, ...values: any[]): SqlBricks.InsertStatement
+
+  /**
+   * Returns a new INSERT statement. It can be used with or without the new operator.
+   * @alias insert
+   * @param tbl table name
+   * @param values a values object or a columns list. Passing a set of columns (as multiple arguments, a comma-delimited string or an array)
+   * will put the statement into split keys/values mode, where a matching array of values is expected in values()
+   * @example
+   * insert('person', {'first_name': 'Fred', 'last_name': 'Flintstone'});
+   * // INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')
+   */
+  insertInto(tbl?: string, ...values: any[]): SqlBricks.InsertStatement
+
+  /**
+   * Returns a new select statement, seeded with a set of columns. It can be used with or without the new keyword.
+   * @param columns it can be passed in here (or appended later via sel.select() or sel.distinct()) via multiple arguments
+   * or a comma-delimited string or an array. If no columns are specified, toString() will default to SELECT *.
+   */
+  select(...columns: Array<string | SqlBricks.SelectStatement>): SqlBricks.SelectStatement
+  select(columns: string[] | SqlBricks.SelectStatement[]): SqlBricks.SelectStatement
+
+  /**
+   * Returns a new UPDATE statement. It can be used with or without the new operator.
+   * @param tbl table name
+   * @param values
+   */
+  update(tbl: string, ...values: any[]): SqlBricks.UpdateStatement
+
+  /**
+   * Returns a new DELETE statement. It can be used with or without the new operator.
+   * @alias deleteFrom
+   * @param tbl table name
+   */
+  delete(tbl?: string): SqlBricks.DeleteStatement
+  /**
+   * Returns a new DELETE statement. It can be used with or without the new operator.
+   * @alias delete
+   * @param tbl table name
+   */
+  deleteFrom(tbl?: string): SqlBricks.DeleteStatement
+
+  /**
+   * Registers a set of frequently-used table aliases with SQL Bricks.
+   * These table aliases can then be used by themselves in from(), join(), etc
+   * and SQL Bricks will automatically expand them to include the table name as well as the alias.
+   * @param expansions
+   * @example
+   * sql.aliasExpansions({'psn': 'person', 'addr': 'address', 'zip': 'zipcode', 'usr': 'user'});
+   * select().from('psn').join('addr', {'psn.addr_id': 'addr.id'});
+   * // SELECT * FROM person psn INNER JOIN address addr ON psn.addr_id = addr.id
+   */
+  aliasExpansions(expansions: { [tbl: string]: string }): void
+
+  /**
+   * Sets a user-supplied function to automatically generate the .on() criteria for joins whenever it is not supplied explicitly.
+   * @param func
+   */
+  joinCriteria(func?: (...args: any[]) => SqlBricks.OnCriteria): any
+
+  _extension(): any
+  prop: number
+  conversions: any
+
+  //////////////////////////////////////////
+  //////  Where Expression functions  //////
+  //////////////////////////////////////////
+
+  /**
+   * Joins the passed expressions with AND
+   * @param whereExprs
+   */
+  and(...whereExprs: SqlBricks.WhereExpression[]): SqlBricks.WhereGroup
+
+  /**
+   * Joins the passed expressions with OR:
+   * @param whereExprs
+   */
+  or(...whereExprs: SqlBricks.WhereExpression[]): SqlBricks.WhereGroup
+
+  /**
+   * Negates the expression by wrapping it in NOT (...)
+   * (if it is at the top level, the parentheses are unnecessary and will be omitted)
+   * @param whereExpr
+   */
+  not(whereExpr: SqlBricks.WhereExpression): SqlBricks.WhereGroup
+
+  /**
+   * Generates a BETWEEN
+   * @param column
+   * @param value1
+   * @param value2
+   */
+  between(column: string, value1: any, value2: any): SqlBricks.WhereExpression
+  isNull(column: string): SqlBricks.WhereExpression
+  isNotNull(column: string): SqlBricks.WhereExpression
+  like(column: string, value: any, escapeStr?: string): SqlBricks.WhereExpression
+  exists(stmt: any): SqlBricks.WhereExpression
+  in(column: string, stmt: SqlBricks.SelectStatement): SqlBricks.WhereExpression
+  in(column: string, ...values: any[]): SqlBricks.WhereExpression
+
+  /**
+   * Generates the appropriate relational operator (=, <>, <, <=, > or >=).
+   * @param column column name or query result
+   * @param value column value
+   */
+  eq(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  equal(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  notEq(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  lt(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  lte(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gt(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gte(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+
+  eqAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  notEqAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  ltAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  lteAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gtAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gteAll(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+
+  eqAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  notEqAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  ltAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  lteAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gtAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gteAny(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+
+  eqSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  notEqSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  ltSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  lteSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gtSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+  gteSome(column: string | SqlBricks.SelectStatement, value?: any): SqlBricks.WhereBinary
+}
+
+declare const SqlBricks: SqlBricksFn
+export = SqlBricks
diff --git a/sql-bricks.js b/sql-bricks.js
index 5dc7940..e32853a 100644
--- a/sql-bricks.js
+++ b/sql-bricks.js
@@ -1,942 +1,1192 @@
 (function() {
+  "use strict";
 
-var global = this;
-var _ = global._ || require('underscore');
-
-// sql() wrapper allows SQL (column/table/etc) where a value (string/number/etc) is expected
-// it is also the main namespace for SQLBricks
-function sql(str) {
-  if (!(this instanceof sql))
-    return new sql(str);
-  this.str = str;
-}
-sql.prototype.toString = function toString() {
-  return this.str;
-};
-
-// val() wrapper allows a value (string/number/etc) where SQL (column/table/etc) is expected
-sql.val = val;
-function val(_val) {
-  if (!(this instanceof val))
-    return new val(_val);
-  this.val = _val;
-}
-
-// SELECT statement
-sql.select = inherits(Select, Statement);
-function Select() {
-  if (!(this instanceof Select))
-    return new Select(argsToArray(arguments));
-
-  Select.super_.call(this, 'select');
-  return this.select.apply(this, arguments);
-}
-
-// COLUMNS clause
-Select.prototype.select = function() {
-  return this._addListArgs(arguments, 'cols');
-};
-Select.prototype.distinct = function() {
-  this._distinct = true;
-  return this._addListArgs(arguments, 'cols');
-};
-Select.prototype.columnsToString = function(opts) {
-  var cols = this.cols.length ? this.cols : ['*'];
-  var result = 'SELECT ';
-  if (this._distinct)
-    result += 'DISTINCT ';
-  return result + cols.map(curry(handleColOrTbl, opts)).join(', ') + ' ';
-};
-
-// INTO clause
-Select.prototype.into = Select.prototype.intoTable = function(tbl) {
-  this._into = tbl;
-  return this;
-};
-Select.prototype.intoTemp = Select.prototype.intoTempTable = function(tbl) {
-  this._into_temp = true;
-  return this.into(tbl);
-};
-Select.prototype.intoToString = function() {
-  if (!this._into)
-    return;
-  var result = 'INTO ';
-  if (this._into_temp)
-    result += 'TEMP ';
-  return result + this._into + ' ';
-};
-
-// FROM clause (includes JOINs)
-Select.prototype.from = function() {
-  return this._add(argsToArray(arguments), 'tbls');
-};
-var join_methods = {
-  'join': 'INNER', 'innerJoin': 'INNER',
-  'leftJoin': 'LEFT', 'leftOuterJoin': 'LEFT',
-  'rightJoin': 'RIGHT', 'rightOuterJoin': 'RIGHT',
-  'fullJoin': 'FULL', 'fullOuterJoin': 'FULL',
-  'crossJoin': 'CROSS'
-};
-Object.keys(join_methods).forEach(function(method) {
-  Select.prototype[method] = function join() {
-    return this._addJoins(arguments, join_methods[method]);
-  };
-});
-
-Select.prototype.on = function(on) {
-  var last_join = this.joins[this.joins.length - 1];
-  if (isExpr(on)) {
-    last_join.on = on;
-  }
-  else {
-    if (!last_join.on)
-      last_join.on = {};
-    _.extend(last_join.on, argsToObject(arguments));
-  }
-  return this;
-};
-
-Select.prototype.fromToString = function(opts) {
-  var result = '';
-  if (this.tbls)
-    result += 'FROM ' + this.tbls.map(curry(handleTable, opts)).join(', ') + ' ';
-  if (this.joins)
-    result += _.invoke(this.joins, 'toString', opts).join(' ') + ' ';
-  return result;
-};
-
-// WHERE clause
-Select.prototype.where = Select.prototype.and = function() {
-  return this._addExpression(arguments, '_where');
-};
-Select.prototype.whereToString = function(opts) {
-  if (this._where)
-    return 'WHERE ' + this._exprToString(opts);
-};
-
-// GROUP BY clause
-Select.prototype.group = Select.prototype.groupBy = function(cols) {
-  return this._addListArgs(arguments, 'group_by');
-};
-Select.prototype.groupByToString = function(opts) {
-  if (this.group_by)
-    return 'GROUP BY ' + this.group_by.map(curry(handleColOrTbl, opts)).join(', ') + ' ';
-};
-
-// HAVING clause
-Select.prototype.having = function() {
-  return this._addExpression(arguments, '_having');
-};
-Select.prototype.havingToString = function(opts) {
-  if (this._having)
-    return 'HAVING ' + this._exprToString(opts, this._having);
-};
-
-// ORDER BY clause
-Select.prototype.order = Select.prototype.orderBy = function(cols) {
-  return this._addListArgs(arguments, 'order_by');
-};
-Select.prototype.orderByToString = function(opts) {
-  if (this.order_by)
-    return 'ORDER BY ' + this.order_by.map(curry(handleColOrTbl, opts)).join(', ') + ' ';
-};
-
-// LIMIT clause
-Select.prototype.limit = function(count) {
-  this._limit = count;
-  return this;
-};
-Select.prototype.limitToString = function(opts) {
-  if (this._limit != null)
-    return 'LIMIT ' + this._limit + ' ';
-};
-
-// OFFSET clause
-Select.prototype.offset = function(count) {
-  this._offset = count;
-  return this;
-};
-Select.prototype.offsetToString = function(opts) {
-  if (this._offset != null)
-    return 'OFFSET ' + this._offset + ' ';
-}
-
-// FOR UPDATE clause
-Select.prototype.forUpdate = Select.prototype.forUpdateOf = function forUpdate() {
-  this.for_update = true;
-  this._addListArgs(arguments, 'for_update_tbls');
-  return this;
-};
-Select.prototype.noWait = function noWait() {
-  this.no_wait = true;
-  return this;
-};
-Select.prototype.forUpdateToString = function(opts) {
-  if (!this.for_update)
-    return;
-  var result = 'FOR UPDATE ';
-  if (this.for_update_tbls)
-    result += this.for_update_tbls.map(curry(handleTable, opts)).join(', ') + ' ';
-  if (this.no_wait)
-    result += 'NO WAIT ';
-  return result;
-};
-
-// compound expressions join queries together
-var compounds = {
-  'union': 'UNION', 'unionAll': 'UNION ALL',
-  'intersect': 'INTERSECT', 'intersectAll': 'INTERSECT ALL',
-  'minus': 'MINUS', 'minusAll': 'MINUS ALL',
-  'except': 'EXCEPT', 'exceptAll': 'EXCEPT ALL'
-};
-_.forEach(compounds, function(value, key) {
-  Select.prototype[key] = function() {
-    var stmts = argsToArray(arguments);
-    if (!stmts.length) {
-      var stmt = new Select();
-      stmt.prev_stmt = this;
-      stmts = [stmt];
-    }
-
-    this._add(stmts, '_' + key);
-
-    if (stmt)
-      return stmt;
+  var is_common_js = typeof exports != 'undefined';
+  var default_opts = { placeholder: '$%d' };
+
+  function toArray(obj) {
+    return Object.keys(obj).map(function(key) {
+      return obj[key];
+    });
+  }
+
+  function extend(obj) {
+    var other_objs = arguments;
+    delete other_objs['0'];
+
+    Object.keys(other_objs).forEach(function(arg_num) {
+      var other_obj = other_objs[arg_num];
+      Object.keys(other_obj).forEach(function(key) {
+        obj[key] = other_obj[key];
+      });
+    });
+    return obj;
+  }
+
+  function cloneObj(obj) {
+    if (types.isArray(obj))
+      return [].concat(obj);
     else
-      return this;
+      return extend({}, obj);
+  }
+
+  var types = {
+    isObject: function isObject(val) {
+      return typeof val == 'object';
+    },
+    isArray: function isArray(val) {
+      return val instanceof Array;
+    },
+    isUndefined: function isUndefined(val) {
+      return typeof val == 'undefined';
+    },
+    isNull: function isNull(val) {
+      return val === null;
+    },
+    isNumber: function isNumber(val) {
+      return typeof val == 'number';
+    },
+    isString: function isString(val) {
+      return typeof val == 'string';
+    },
+    isBoolean: function isBoolean(val) {
+      return typeof val == 'boolean';
+    },
+    isDate: function isDate(val) {
+      return val instanceof Date;
+    }
   };
-});
-
-// subquery aliasing
-Select.prototype.as = function(alias) {
-  this._alias = alias;
-  return this;
-};
-
-sql.select.clauses = ['columns', 'into', 'from', 'where', 'groupBy', 'having', 'orderBy', 'limit', 'offset', 'forUpdate'];
-Select.prototype._toString = function _toString(opts) {
-  var result = '';
-
-  // build main SELECT statement
-  sql.select.clauses.forEach(function(clause) {
-    var rlt = this[clause + 'ToString'](opts);
-    if (rlt)
-      result += rlt;
-  }.bind(this));
-
-  // handle any compound statements
-  _.forEach(compounds, function(value, key) {
-    var arr = this['_' + key];
-    if (arr) {
-      result += value + ' ';
-      result += arr.map(function(stmt) {
-        return stmt._toString(opts);
-      }).join(' ' + value + ' ');
-    }
-  }.bind(this));
-
-  return result.trim();
-};
-
-
-sql.insert = sql.insertInto = inherits(Insert, Statement);
-function Insert(tbl, values) {
-  if (!(this instanceof Insert)) {
-    if (typeof values == 'object' && !_.isArray(values))
-      return new Insert(tbl, values);
-    else
-      return new Insert(tbl, argsToArray(_.toArray(arguments).slice(1)));
+
+  function findIndex(arr, fn) {
+    for (var i = 0; i < arr.length; i++) {
+      if (fn(arr[i])) {
+        return i;
+      }
+    }
+    return -1;
   }
 
-  Insert.super_.call(this, 'insert');
-  return this.into.apply(this, arguments);
-};
+  function isEmpty(obj) {
+    return types.isUndefined(obj) || obj === null || Object.keys(obj).length == 0;
+  }
 
-Insert.prototype.into = function into(tbl, values) {
-  if (tbl)
-    this.tbls = [tbl];
+  function applyDefaults(opts) {
+    Object.keys(default_opts).forEach(function(key) {
+      if (!opts[key]) opts[key] = default_opts[key];
+    });
+    return opts;
+  }
 
-  if (values) {
-    if (isPlainObject(values) || (_.isArray(values) && isPlainObject(values[0]))) {
-      this.values(values);
+  // sql() wrapper allows SQL (column/table/etc) where a value (string/number/etc) is expected
+  // it is also the main namespace for SQLBricks
+  function sql(str) {
+    if (!(this instanceof sql))
+      return applyNew(sql, arguments);
+
+    this.str = str;
+    this.vals = toArray(arguments).slice(1);
+
+    // support passing a single array
+    if (types.isArray(this.vals[0]))
+      this.vals = this.vals[0];
+  }
+  sql.setDefaultOpts = setDefaultOpts;
+  function setDefaultOpts(opts) {
+    default_opts = extend(default_opts, opts);
+  }
+  sql.prototype.toString = function toString(opts) {
+    // replacer(match, [capture1, capture2, ...,] offset, string)
+    function replacer() {
+      // don't do any replacing if the user supplied no values
+      if (!opts.values.length)
+        return arguments[0];
+
+      var ix = arguments.length > 3 ? parseInt(arguments[1], 10) : opts.value_ix++;
+      var val = opts.values[ix - 1];
+      if (types.isUndefined(val))
+        throw new Error('Parameterized sql() (' + str + ') requires ' + ix + ' parameter(s) but only ' + opts.values.length + ' parameter(s) were supplied');
+      if (types.isObject(sql) && !types.isArray(sql) && sql == null)
+        return val.toString(opts);
+      else
+        return sql.convert(val);
     }
-    else if (values.length) {
-      this._split_keys_vals_mode = true;
-      this._values = [{}];
-      var val_arr = argsToArray(_.toArray(arguments).slice(1));
-      _.forEach(val_arr, function(key) {
-        this._values[0][key] = null;
-      }.bind(this));
+
+    var str = this.str;
+    if (!opts)
+      opts = extend({}, default_opts);
+    if (!opts.values)
+      opts.values = [];
+    if (!opts.value_ix)
+      opts.value_ix = 1;
+
+    this.vals.forEach(function(val) {
+      opts.values.push(val);
+    });
+
+    // shift the placeholder indexes if there are already values
+    if (opts.value_ix > 1) {
+      if (opts.placeholder == '$%d')
+        str = str.replace(/\$(\d+)/g, function(match, capture) { return '$' + (parseInt(capture, 10) + opts.value_ix - 1); });
+      else if (opts.placeholder == '?%d')
+        str = str.replace(/\?(\d+)/g, function(match, capture) { return '?' + parseInt(capture, 10) + opts.value_ix - 1; });
     }
+
+    // inject numbers into placeholders if numbers are required
+    if (opts.placeholder == '$%d')
+      str = str.replace(/\$(?!\d)/g, function() { return '$' + opts.value_ix++; });
+    else if (opts.placeholder == '?%d')
+      str = str.replace(/\?(?!\d)/g, function() { return '?' + opts.value_ix++; });
+
+    if (!opts.parameterized) {
+      // replace placeholders with inline values
+      if (opts.placeholder == '$%d')
+        str = str.replace(/\$(\d+)/g, replacer);
+      else if (opts.placeholder == '?%d')
+        str = str.replace(/\?(\d+)/g, replacer);
+      else if (opts.placeholder == '$')
+        str = str.replace(/\$/g, replacer);
+      else if (opts.placeholder == '?')
+        str = str.replace(/\?/g, replacer);
+      else if (opts.placeholder == '') {}
+      else
+        throw new Error('Unsupported placeholder: "' + opts.placeholder + '"');
+    } else {
+      opts.value_ix += this.vals.length;
+    }
+
+    return str;
+  };
+
+  // val() wrapper allows a value (string/number/etc) where SQL (column/table/etc) is expected
+  sql.val = val;
+  function val(_val) {
+    if (!(this instanceof val))
+      return new val(_val);
+    this.val = _val;
   }
-  return this;
-};
-Insert.prototype.values = function values() {
-  if (this._split_keys_vals_mode) {
-    var outer_arr;
-    if (_.isArray(arguments[0]) && _.isArray(arguments[0][0]))
-      outer_arr = arguments[0];
-    else
-      outer_arr = [argsToArray(arguments)];
 
-    var keys = _.keys(this._values[0]);
-    _.forEach(outer_arr, function(args, outer_ix) {
-      if (!this._values[outer_ix])
-        this._values[outer_ix] = {};
+  // mechanism to easily define clauses for SQL statements
+  [Select, Insert, Update, Delete].forEach(function(stmt) {
+    stmt.defineClause = function(clause_id, render_fn, opts) {
+      opts = opts || {};
+      render_fn.clause_id = clause_id;
+      this.prototype.clauses = this.prototype.clauses || [];
+      
+      var index;
+      if (opts.after || opts.before) {
+        index = findIndex(this.prototype.clauses, function(render_fn) {
+          return render_fn.clause_id == (opts.after || opts.before);
+        });
+        if (index == -1)
+          throw new Error('Error adding clause ' + clause_id + ': dependent clause "' + opts.after + '" not found');
+        
+        if (opts.after)
+          index++;
+      }
+      else {
+        index = this.prototype.clauses.length;
+      }
+      this.prototype.clauses.splice(index, 0, render_fn);
+    };
+  });
 
-      _.forEach(keys, function(key, ix) {
-        this._values[outer_ix][key] = args[ix];
-      }.bind(this));
-    }.bind(this));
+  // SELECT statement
+  sql.select = inherits(Select, Statement);
+  function Select() {
+    if (!(this instanceof Select))
+      return new Select(argsToArray(arguments));
+
+    Select.super_.call(this, 'select');
+    return this.select.apply(this, arguments);
   }
-  else {
-    if (_.isArray(arguments[0]) && isPlainObject(arguments[0][0])) {
-      if (!this._values)
-        this._values = [];
-      this._values = this._values.concat(arguments[0]);
+
+  Select.prototype.select = function() {
+    return this._addListArgs(arguments, '_columns');
+  };
+  Select.prototype.distinct = function() {
+    this._distinct = true;
+    return this._addListArgs(arguments, '_columns');
+  };
+  Select.prototype.into = Select.prototype.intoTable = function(tbl) {
+    this._into = tbl;
+    return this;
+  };
+  Select.prototype.intoTemp = Select.prototype.intoTempTable = function(tbl) {
+    this._temp = true;
+    this._into = tbl;
+    return this;
+  };
+  Select.prototype.from = function() {
+    return this._addListArgs(arguments, '_from');
+  };
+
+  var join_methods = {
+    'join': 'INNER', 'innerJoin': 'INNER',
+    'leftJoin': 'LEFT', 'leftOuterJoin': 'LEFT',
+    'rightJoin': 'RIGHT', 'rightOuterJoin': 'RIGHT',
+    'fullJoin': 'FULL', 'fullOuterJoin': 'FULL',
+    'naturalJoin': 'NATURAL INNER', 'naturalInnerJoin': 'NATURAL INNER',
+    'naturalLeftJoin': 'NATURAL LEFT', 'naturalLeftOuterJoin': 'NATURAL LEFT',
+    'naturalRightJoin': 'NATURAL RIGHT', 'naturalRightOuterJoin': 'NATURAL RIGHT',
+    'naturalFullJoin': 'NATURAL FULL', 'naturalFullOuterJoin': 'NATURAL FULL',
+    'crossJoin': 'CROSS'
+  };
+  Object.keys(join_methods).forEach(function(method) {
+    Select.prototype[method] = function join() {
+      return this._addJoins(arguments, join_methods[method]);
+    };
+  });
+  Select.prototype.on = function(on) {
+    var last_join = this.joins[this.joins.length - 1];
+    if (types.isArray(last_join.on) && !isEmpty(last_join.on))
+      throw new Error('Error adding clause ON: ' + last_join.left_tbl + ' JOIN ' + last_join.tbl + ' already has a USING clause.');
+    if (isExpr(on)) {
+      last_join.on = on;
     }
     else {
-      if (!this._values)
+      if (!last_join.on || (types.isArray(last_join.on))) // Instantiate object, including if it's an empty array from .using().
+        last_join.on = {};
+      extend(last_join.on, argsToObject(arguments));
+    }
+    return this;
+  };
+  Select.prototype.using = function(columns) {
+    var last_join = this.joins[this.joins.length - 1];
+    if (!isEmpty(last_join.on) && !types.isArray(last_join.on))
+      throw new Error('Error adding clause USING: ' + last_join.left_tbl + ' JOIN ' + last_join.tbl + ' already has an ON clause.');
+
+    if (isEmpty(last_join.on))
+      last_join.on = []; // Using _.isEmpty tolerates overwriting of empty {}.
+
+    var argsArray = argsToArray(arguments);
+    argsArray.forEach(function(key) {
+      if (last_join.on.indexOf(key) == -1) last_join.on.push(key);
+    });
+
+    return this;
+  };
+
+  Select.prototype.where = Select.prototype.and = function() {
+    return this._addExpression(arguments, '_where');
+  };
+  Select.prototype.having = function() {
+    return this._addExpression(arguments, '_having');
+  };
+  Select.prototype.groupBy = Select.prototype.group = function() {
+    return this._addListArgs(arguments, '_groupBy');
+  };
+  Select.prototype.orderBy = Select.prototype.order = function() {
+    return this._addListArgs(arguments, '_orderBy');
+  };
+  Select.prototype.of = function() {
+    return this._addListArgs(arguments, '_of');
+  };
+
+  Select.prototype.forUpdate = function() {
+    this._forUpdate = true;
+    return this;
+  };
+  Select.prototype.noWait = function() {
+    this._noWait = true;
+    return this;
+  };
+
+  // TODO: Don't we need to keep track of the order of UNION, INTERSECT, etc, clauses?
+  var compounds = {
+    'union': 'UNION', 'unionAll': 'UNION ALL',
+    'intersect': 'INTERSECT', 'intersectAll': 'INTERSECT ALL',
+    'except': 'EXCEPT', 'exceptAll': 'EXCEPT ALL'
+  };
+  Object.keys(compounds).forEach(function(key) {
+    Select.prototype[key] = function() {
+      var stmts = argsToArray(arguments);
+      if (!stmts.length) {
+        var stmt = new Select();
+        stmt.prev_stmt = this;
+        stmts = [stmt];
+      }
+
+      this._add(stmts, '_' + key);
+
+      if (stmt)
+        return stmt;
+      else
+        return this;
+    };
+  });
+
+  // subquery aliasing
+  Select.prototype._toNestedString = function(opts) {
+    return '(' + this._toString(opts) + ')' + this._aliasToString(opts);
+  };
+
+  Select.prototype._aliasToString = function(opts) {
+    if (!this._alias)
+      return '';
+
+    return ' ' + autoQuote(this._alias);
+  };
+
+  Select.prototype.as = function(alias) {
+    this._alias = alias;
+    return this;
+  };
+
+  Select.prototype._toString = function _toString(opts) {
+    if (!this._columns.length)
+      this._columns = ['*'];
+    return Select.super_.prototype._toString.apply(this, arguments);
+  };
+
+  Select.defineClause('select', function(opts) {
+    return `SELECT ${this._distinct ? 'DISTINCT ' : ''}` +
+      (this._columns ? handleColumns(this._columns, opts) : '');
+  });
+  Select.defineClause('into', function(opts) {
+    if (this._into)
+      return `INTO ${this._temp ? 'TEMP ' : ''}${handleTable(this._into, opts)}`;
+  });
+  Select.defineClause('from', function(opts) {
+    if (!this._from)
+      return;
+    var result = `FROM ${handleTables(this._from, opts)}`;
+    if (this.joins) {
+      result += ' ' + this.joins.map(function(join) {
+        return join.toString(opts);
+      }.bind(this)).join(' ');
+    }
+    return result;
+  });
+  Select.defineClause('where', function(opts) {
+    if (this._where)
+      return `WHERE ${handleExpression(this._where, opts)}`;
+  });
+  Select.defineClause('groupBy', function(opts) {
+    if (this._groupBy)
+      return `GROUP BY ${handleColumns(this._groupBy, opts)}`;
+  });
+  Select.defineClause('having', function(opts) {
+    if (this._having)
+      return `HAVING ${handleExpression(this._having, opts)}`;
+  });
+
+  Object.keys(compounds).forEach(function(clause_id) {
+    var sql_keyword = compounds[clause_id];
+    Select.defineClause(clause_id, function(opts) {
+      var arr = this['_' + clause_id];
+      if (arr) {
+        return arr.map(function(stmt) {
+          return sql_keyword + ' ' + stmt._toString(opts);
+        }).join(' ');
+      }
+    });
+  });
+
+  Select.defineClause('orderBy', function(opts) {
+    if (this._orderBy)
+      return `ORDER BY ${handleColumns(this._orderBy, opts)}`;
+  });
+  Select.defineClause('forUpdate', function(opts) {
+    if (this._forUpdate)
+      return `FOR UPDATE${this._of ? ` OF ${handleColumns(this._of, opts)}` : ''}` +
+        (this._noWait ? ' NOWAIT' : '');
+  });
+
+
+  // INSERT statement
+  sql.insert = sql.insertInto = inherits(Insert, Statement);
+  function Insert(tbl, values) {
+    if (!(this instanceof Insert)) {
+      if (typeof values == 'object' && !types.isArray(values))
+        return new Insert(tbl, values);
+      else
+        return new Insert(tbl, argsToArray(toArray(arguments).slice(1)));
+    }
+
+    Insert.super_.call(this, 'insert');
+    return this.into.apply(this, arguments);
+  };
+
+  Insert.prototype.into = function into(tbl, values) {
+    if (tbl)
+      this._table = tbl;
+
+    if (values) {
+      if (isPlainObject(values) || (types.isArray(values) && isPlainObject(values[0]))) {
+        this.values(values);
+      }
+      else if (values.length) {
+        this._split_keys_vals_mode = true;
         this._values = [{}];
-      _.extend(this._values[0], argsToObject(arguments));
-    }
-  }
-  return this;
-};
-Insert.prototype.select = function select() {
-  this._select = sql.select.apply(null, arguments);
-  this._select.prev_stmt = this;
-  return this._select;
-};
-Insert.prototype.returning = function returning() {
-  this._addListArgs(arguments, '_returning');
-  return this;
-};
-Insert.prototype._toString = function _toString(opts) {
-  var keys = _.map(_.keys(this._values[0]), function(col) {
-    return handleColOrTbl(opts, col);
-  }).join(', ');
-  var values = _.map(this._values, function(values) {
-    return '(' + _.map(_.values(values), function(val) {
-      return handleValue(val, opts);
-    }).join(', ') + ')';
-  }).join(', ');
+        var val_arr = argsToArray(toArray(arguments).slice(1));
+        val_arr.forEach(function(key) {
+          this._values[0][key] = null;
+        }.bind(this));
+      }
+    }
+    return this;
+  };
+  Insert.prototype.values = function values() {
+    if (this._split_keys_vals_mode) {
+      var outer_arr;
+      if (types.isArray(arguments[0]) && types.isArray(arguments[0][0]))
+        outer_arr = arguments[0];
+      else
+        outer_arr = [argsToArray(arguments)];
 
-  var sql = 'INSERT ';
-  if (this._or)
-    sql += 'OR ' + this._or + ' ';
-  sql += 'INTO ' + this.tbls.map(curry(handleTable, opts)).join(', ') + ' (' + keys + ') ';
+      var keys = Object.keys(this._values[0]);
+      outer_arr.forEach(function(args, outer_ix) {
+        if (!this._values[outer_ix])
+          this._values[outer_ix] = {};
 
-  if (this._select)
-    sql += this._select._toString(opts) + ' ';
-  else
-    sql += 'VALUES ' + values + ' ';
-
-  if (this._returning) {
-    sql += 'RETURNING ' + _.map(this._returning, function(col) {
-      return handleColOrTbl(opts, col);
-    }).join(', ');
-  }
-
-  return sql.trim();
-};
-
-
-sql.update = inherits(Update, Statement);
-function Update(tbl, values) {
-  if (!(this instanceof Update))
-    return new Update(tbl, argsToObject(_.toArray(arguments).slice(1)));
-
-  Update.super_.call(this, 'update');
-  this.tbls = [tbl];
-  if (values)
-    this.values(values);
-  return this;
-};
-
-Update.prototype.set = Update.prototype.values = function set() {
-  return this._addToObj(argsToObject(arguments), '_values');
-};
-
-Update.prototype.where = Update.prototype.and = Select.prototype.where;
-
-Update.prototype.returning = Insert.prototype.returning;
-
-Update.prototype._toString = function _toString(opts) {
-  var sql = 'UPDATE ';
-  if (this._or)
-    sql += 'OR ' + this._or + ' ';
-  sql += handleTable(opts, this.tbls[0]) + ' SET ';
-  sql += _.map(this._values, function(value, key) {
-    return handleColOrTbl(opts, key) + ' = ' + handleValue(value, opts);
-  }).join(', ') + ' ';
-
-  if (this._where)
-    sql += 'WHERE ' + this._exprToString(opts);
-
-  if (this._returning) {
-    sql += 'RETURNING ' + _.map(this._returning, function(col) {
-      return handleColOrTbl(opts, col);
-    }).join(', ');
-  }
-  return sql.trim();
-};
-
-// Insert & Update OR clauses
-var or_methods = {
-  'orReplace': 'REPLACE', 'orRollback': 'ROLLBACK',
-  'orAbort': 'ABORT', 'orFail': 'FAIL'
-};
-Object.keys(or_methods).forEach(function(method) {
-  Insert.prototype[method] = Update.prototype[method] = function() {
-    this._or = or_methods[method]; return this;
-  };
-});
-
-// Delete
-sql.delete = sql.deleteFrom = inherits(Delete, Statement);
-function Delete(tbl) {
-  if (!(this instanceof Delete))
-    return new Delete(tbl);
-
-  Delete.super_.call(this, 'delete');
-  if (tbl)
-    this.tbls = [tbl];
-  return this;
-}
-Delete.prototype.from = Select.prototype.from;
-Delete.prototype.using = function using() {
-  return this._add(argsToArray(arguments), '_using');
-};
-Delete.prototype.where = Delete.prototype.and = Select.prototype.where;
-Delete.prototype._toString = function _toString(opts) {
-  var sql = 'DELETE FROM ' + handleTable(opts, this.tbls[0]) + ' ';
-  if (this._using)
-    sql += 'USING ' + this._using.map(curry(handleTable, opts)).join(', ') + ' ';
-  if (this._where)
-    sql += 'WHERE ' + this._exprToString(opts);
-  return sql.trim();
-};
-
-
-sql.Statement = Statement;
-function Statement(type) {
-  this.type = type;
-};
-
-Statement.prototype.clone = function clone() {
-  var ctor = _.find([Select, Insert, Update, Delete], function(ctor) {
-    return this instanceof ctor;
-  }.bind(this));
-
-  var stmt = _.extend(new ctor(), this);
-  if (stmt._where)
-    stmt._where = stmt._where.clone();
-  if (stmt.joins)
-    stmt.joins = stmt.joins.slice();
-  if (stmt._values) {
-    if (_.isArray(stmt._values)) {
-      stmt._values = _.map(stmt._values, function(val) {
-        return _.clone(val);
-      });
+        keys.forEach(function(key, ix) {
+          this._values[outer_ix][key] = args[ix];
+        }.bind(this));
+      }.bind(this));
+    }
+    else {
+      if (types.isArray(arguments[0]) && isPlainObject(arguments[0][0])) {
+        if (!this._values)
+          this._values = [];
+        this._values = this._values.concat(arguments[0]);
+      }
+      else {
+        if (!this._values)
+          this._values = [{}];
+        extend(this._values[0], argsToObject(arguments));
+      }
+    }
+    return this;
+  };
+  Insert.prototype.select = function select() {
+    this._select = sql.select.apply(null, arguments);
+    this._select.prev_stmt = this;
+    return this._select;
+  };
+
+  Insert.defineClause('insert', function() { return 'INSERT'; });
+  Insert.defineClause('into', function(opts) {
+    if (this._table) return `INTO ${handleTable(this._table, opts)}`;
+  });
+  Insert.defineClause('columns', function(opts) {
+    if (this._values)
+      return '(' + handleColumns(Object.keys(this._values[0]), opts) + ')';
+  });
+  Insert.defineClause('values', function(opts) {
+    if (this._select) {
+      return this._select._toString(opts);
     }
     else {
-      stmt._values = _.clone(stmt._values);
+      var pickOrder = Object.keys(this._values[0]);
+      return 'VALUES ' + this._values.map(function(values) {
+        var pickValues = pickOrder.map(function(key) {
+          return values[key];
+        });
+        return '(' + handleValues(pickValues, opts).join(', ') + ')';
+      }).join(', ');
     }
+  });
+
+
+  // UPDATE statement
+  sql.update = inherits(Update, Statement);
+  function Update(tbl, values) {
+    if (!(this instanceof Update))
+      return new Update(tbl, argsToObject(toArray(arguments).slice(1)));
+
+    Update.super_.call(this, 'update');
+    this._table = tbl;
+    if (values)
+      this.values(values);
+    return this;
+  };
+
+  Update.prototype.set = Update.prototype.values = function set() {
+    return this._addToObj(argsToObject(arguments), '_values');
+  };
+
+  Update.prototype.where = Update.prototype.and = Select.prototype.where;
+
+  Update.defineClause('update', function() {
+    return 'UPDATE';
+  });
+  Update.defineClause('table', function(opts) {
+    return handleTable(this._table, opts);
+  });
+  Update.defineClause('set', function(opts) {
+    return 'SET ' + Object.keys(this._values).map(function(key) {
+      return handleColumn(key, opts) + ' = ' + handleValue(this._values[key], opts);
+    }.bind(this)).join(', ');
+  });
+  Update.defineClause('where', function(opts) {
+    if (this._where)
+      return `WHERE ${handleExpression(this._where, opts)}`;
+  });
+
+
+  // DELETE statement
+  sql.delete = sql.deleteFrom = inherits(Delete, Statement);
+  function Delete(tbl) {
+    if (!(this instanceof Delete))
+      return new Delete(tbl);
+
+    Delete.super_.call(this, 'delete');
+    if (tbl)
+      this._from = tbl;
+    return this;
   }
-  return stmt;
-};
+  Delete.prototype.from = function(tbl) {
+    this._from = tbl;
+    return this;
+  };
+  Delete.prototype.where = Delete.prototype.and = Select.prototype.where;
 
-Statement.prototype.toParams = function toParams(opts) {
-  if (this.prev_stmt)
-    return this.prev_stmt.toParams(opts);
+  Delete.defineClause('delete', function(opts) {
+    return `DELETE FROM ${handleTable(this._from, opts)}`;
+  });
+  Delete.defineClause('where', function(opts) {
+    if (this._where)
+      return `WHERE ${handleExpression(this._where, opts)}`;
+  });
 
-  if (!opts)
-    opts = {};
-  _.extend(opts, {'parameterized': true, 'values': [], 'value_ix': 1});
-  _.defaults(opts, {'placeholder': '$%d'});
-  var sql = this._toString(opts);
 
-  return {'text': sql, 'values': opts.values};
-};
+  // base statement
+  sql.Statement = Statement;
+  function Statement(type) {
+    this.type = type;
+  };
 
-Statement.prototype.toString = function toString() {
-  if (this.prev_stmt)
-    return this.prev_stmt.toString();
-  else
-    return this._toString({}).trim();
-};
+  // TODO: this seems to not handle... a *lot* of properties
+  Statement.prototype.clone = function clone() {
+    var ctor;
+    [Select, Insert, Update, Delete].forEach(function(fn) {
+      if (this instanceof fn) ctor = fn;
+    }.bind(this));
 
+    var stmt = extend(new ctor(), this);
+    if (stmt._where)
+      stmt._where = stmt._where.clone();
+    if (stmt.joins)
+      stmt.joins = stmt.joins.slice();
+    if (stmt._values) {
+      if (types.isArray(stmt._values)) {
+        stmt._values = stmt._values.map(function(val) {
+          return cloneObj(val);
+        });
+      }
+      else {
+        stmt._values = cloneObj(stmt._values);
+      }
+    }
+    return stmt;
+  };
 
-Statement.prototype._exprToString = function _exprToString(opts, expr) {
-  if (!expr)
-    expr = this._where;
-  expr.parens = false;
-  if (expr.expressions && expr.expressions.length == 1)
-    expr.expressions[0].parens = false;
-  return expr.toString(opts) + ' ';
-};
+  Statement.prototype.toParams = function toParams(opts) {
+    if (this.prev_stmt)
+      return this.prev_stmt.toParams(opts);
 
-Statement.prototype._add = function _add(arr, name) {
-  if (!this[name])
-    this[name] = [];
+    if (!opts)
+      opts = {};
+    extend(opts, {'parameterized': true, 'values': [], 'value_ix': 1});
+    opts = applyDefaults(opts);
+    var sql = this._toString(opts);
 
-  this[name] = this[name].concat(arr);
-  return this;
-};
+    return {'text': sql, 'values': opts.values};
+  };
 
-Statement.prototype._addToObj = function _addToObj(obj, name) {
-  if (!this[name])
-    this[name] = {};
+  Statement.prototype.toString = function toString(opts) {
+    if (!opts)
+      opts = {};
+    opts = applyDefaults(opts);
+
+    if (this.prev_stmt)
+      return this.prev_stmt.toString(opts);
+    else
+      return this._toString(opts).trim();
+  };
 
-  _.extend(this[name], obj);
-  return this;
-};
+  Statement.prototype._toString = function(opts) {
+    var clauses = [];
+    this.clauses.forEach(function(clause) {
+      var clause = clause.call(this, opts);
+      if (clause) clauses.push(clause);
+    }.bind(this));
+    return clauses.join(' ');
+  };
 
-Statement.prototype._addListArgs = function _addListArgs(args, name) {
-  return this._add(argsToArray(args), name);
-};
+  Statement.prototype._add = function _add(arr, name) {
+    if (!this[name])
+      this[name] = [];
 
-Statement.prototype._addExpression = function _addExpression(args, name) {
-  if (args.length <= 1 && (args[0] == null || _.isEmpty(args[0])))
+    this[name] = this[name].concat(arr);
     return this;
+  };
 
-  if (!this[name])
-    this[name] = sql.and();
-  var exprs = argsToExpressions(args);
-  this[name].expressions = this[name].expressions.concat(exprs);
-  return this;
-};
-
-Statement.prototype._addJoins = function _addJoins(args, type) {
-  if (!this.joins)
-    this.joins = [];
-
-  if (typeof args[1] == 'object') {
-    var tbls = [args[0]];
-    var on = args[1];
-    var opts = args[2];
-  }
-  else {
-    tbls = argsToArray(args);
-  }
-
-  _.forEach(tbls, function(tbl) {
-    var left_tbl = this.last_join || (this.tbls && this.tbls[this.tbls.length - 1]);
-    this.joins.push(new Join(tbl, left_tbl, on, type));
-  }.bind(this));
-
-  this.last_join = tbls[tbls.length - 1];
-  return this;
-};
-
-
-function Join(tbl, left_tbl, on, type) {
-  this.tbl = tbl;
-  this.left_tbl = left_tbl;
-  this.on = on;
-  this.type = type;
-}
-sql.Join = Join;
-Join.prototype.autoGenerateOn = function autoGenerateOn(tbl, left_tbl) {
-  return sql._joinCriteria(getTable(left_tbl), getAlias(left_tbl), getTable(tbl), getAlias(tbl));
-};
-Join.prototype.toString = function toString(opts) {
-  var on = this.on, tbl = handleTable(opts, this.tbl), left_tbl = handleTable(opts, this.left_tbl);
-  if (!on || _.isEmpty(on)) {
-    if (sql._joinCriteria)
-      on = this.autoGenerateOn(tbl, left_tbl);
-    else
-      throw new Error('No join criteria supplied for "' + getAlias(tbl) + '" join');
-  }
+  Statement.prototype._addToObj = function _addToObj(obj, name) {
+    if (!this[name])
+      this[name] = {};
+
+    extend(this[name], obj);
+    return this;
+  };
+
+  Statement.prototype._addListArgs = function _addListArgs(args, name) {
+    return this._add(argsToArray(args), name);
+  };
+
+  Statement.prototype._addExpression = function _addExpression(args, name) {
+    if (args.length <= 1 && (args[0] == null || isEmpty(args[0])))
+      return this;
+
+    if (!this[name])
+      this[name] = sql.and();
+    var exprs = argsToExpressions(args);
+    this[name].expressions = this[name].expressions.concat(exprs);
+    return this;
+  };
+
+  Statement.prototype._addJoins = function _addJoins(args, type) {
+    if (!this.joins)
+      this.joins = [];
+
+    if (typeof args[1] == 'object') {
+      var tbls = [args[0]];
+      var on = args[1];
+      var opts = args[2];
+    }
+    else {
+      tbls = argsToArray(args);
+    }
+
+    tbls.forEach(function(tbl) {
+      var left_tbl = this.last_join || (this._from && this._from[this._from.length - 1]);
+      this.joins.push(new Join(tbl, left_tbl, on, type));
+    }.bind(this));
+
+    this.last_join = tbls[tbls.length - 1];
+    return this;
+  };
 
-  if (isExpr(on)) {
-    on = on.toString(opts);
+
+  function Join(tbl, left_tbl, on, type) {
+    this.tbl = tbl;
+    this.left_tbl = left_tbl;
+    this.on = on;
+    this.type = type;
   }
-  else {
-    on = _.map(_.keys(on), function(key) {
-      return handleColOrTbl(opts, key) + ' = ' + handleColOrTbl(opts, on[key]);
-    }).join(' AND ')
+  sql.Join = Join;
+  Join.prototype.autoGenerateOn = function autoGenerateOn(tbl, left_tbl) {
+    return sql._joinCriteria(getTable(left_tbl), getAlias(left_tbl), getTable(tbl), getAlias(tbl));
+  };
+  Join.prototype.toString = function toString(opts) {
+    var on = this.on, tbl = handleTable(this.tbl, opts);
+
+    // Natural or cross join, no criteria needed.
+    // Debt: Determining whether join is natural/cross by reading the string is slightly hacky... but works.
+    if (/^(natural|cross)/i.test(this.type))
+      return this.type + ' JOIN ' + tbl;
+    
+    // Not a natural or cross, check for criteria.
+    if (!on || isEmpty(on)) {
+      if (sql._joinCriteria) {
+        var left_tbl = handleTable(this.left_tbl, opts);
+        on = this.autoGenerateOn(tbl, left_tbl);
+      }
+      else {
+        throw new Error('No join criteria supplied for "' + getAlias(tbl) + '" join');
+      }
+    }
+
+    // Array value for on indicates join using "using", rather than "on".
+    if (types.isArray(on)) {
+      on = on.map(function (column) {
+        return handleColumn(column);
+      }).join(', ');
+      return this.type + ' JOIN ' + tbl + ' USING (' + on + ')';
+    }
+
+    // Join using "on".
+    if (isExpr(on)) {
+      on = on.toString(opts);
+    }
+    else {
+      on = Object.keys(on).map(function(key) {
+        return handleColumn(key, opts) + ' = ' + handleColumn(on[key], opts);
+      }).join(' AND ')
+    }
+    return this.type + ' JOIN ' + tbl + ' ON ' + on;
+  };
+
+  // handle an array, a comma-delimited str or separate args
+  function argsToArray(args) {
+    if (types.isArray(args[0])) {
+      return args[0];
+    }
+    else if (typeof args[0] == 'string' && args[0].indexOf(',') > -1) {
+      return args[0].split(',').map(function(arg) {
+        return arg.trim();
+      });
+    }
+    else {
+      return toArray(args);
+    }
   }
-  return this.type + ' JOIN ' + tbl + ' ON ' + on;
-};
 
-// simple single-arg curry
-function curry(fn, arg) {
-  return fn.bind(null, arg);
-}
+  function argsToObject(args) {
+    if (typeof args[0] == 'object')
+      return args[0];
 
-// handle an array, a comma-delimited str or separate args
-function argsToArray(args) {
-  if (_.isArray(args[0]))
-    return args[0];
-  else if (typeof args[0] == 'string' && args[0].indexOf(',') > -1)
-    return _.invoke(args[0].split(','), 'trim');
-  else
-    return _.toArray(args);
-}
-
-function argsToObject(args) {
-  if (typeof args[0] == 'object')
-    return args[0];
-
-  var obj = {};
-  if (args[0] != null)
-    obj[args[0]] = args[1];
-  return obj;
-}
-
-function argsToExpressions(args) {
-  var flat_args = _.all(args, function(arg) {
-    return typeof arg != 'object' || arg instanceof val || arg instanceof sql;
-  });
-  if (flat_args) {
-    return [sql.equal(args[0], args[1])];
+    var obj = {};
+    if (args[0] != null)
+      obj[args[0]] = args[1];
+    return obj;
+  }
+
+  function argsToExpressions(args) {
+    var flat_args = true;
+    Object.keys(args).forEach(function(key) {
+      var arg = args[key];
+      if (!(typeof arg != 'object' || arg instanceof val || arg instanceof sql || arg == null)) {
+        flat_args = false;
+        return;
+      }
+    });
+    if (flat_args) {
+      if (args[0] instanceof sql && args.length == 1)
+        return [args[0]];
+      else
+        return [sql.equal(args[0], args[1])];
+    }
+    else {
+      var exprs = [];
+      Object.keys(args).forEach(function(key) {
+        var expr = args[key];
+        if (isExpr(expr))
+          exprs.push(expr);
+        else
+          exprs = exprs.concat(objToEquals(expr));
+      });
+      return exprs;
+    }
   }
-  else {
-    var exprs = [];
-    _.each(args, function(expr) {
+
+
+  // SQL Expression language
+  sql.and = function and() { return new Group('AND', argsToArray(arguments)); };
+  sql.or = function or() { return new Group('OR', argsToArray(arguments)); };
+
+  function Group(op, expressions) {
+    this.op = op;
+    this.expressions = [];
+    expressions.forEach(function(expr) {
       if (isExpr(expr))
-        exprs.push(expr);
+        this.expressions.push(expr);
       else
-        exprs = exprs.concat(objToEquals(expr));
-    });
-    return exprs;
+        this.expressions = this.expressions.concat(objToEquals(expr));
+    }.bind(this));
   }
-}
+  sql.Group = Group;
+  Group.prototype.clone = function clone() {
+    return new Group(this.op, this.expressions.map(function(expr) {
+      return expr.clone();
+    }));
+  };
+  Group.prototype.toString = function toString(opts) {
+    opts = opts || extend({}, default_opts);
+    var sql = Object.keys(this.expressions).map(function(expr) {
+      return this.expressions[expr].toString(opts);
+    }.bind(this)).join(' ' + this.op + ' ');
+    if (this.expressions.length > 1 && this.parens !== false)
+      sql = '(' + sql + ')';
+    return sql;
+  };
 
-// SQL Expression language
+  sql.not = function not(expr) {
+    return new Not(expr);
+  };
+  function Not(expr) {
+    if (!isExpr(expr))
+      this.expressions = [sql.and(expr)];
+    else
+      this.expressions = [expr];
+  }
+  sql.Not = Not;
+  Not.prototype.clone = function clone() {
+    return new Not(this.expressions[0].clone());
+  };
+  Not.prototype.toString = function toString(opts) {
+    return 'NOT ' + this.expressions[0].toString(opts);
+  };
 
-sql.and = function and() { return new Group('AND', argsToArray(arguments)); };
-sql.or = function or() { return new Group('OR', argsToArray(arguments)); };
+  var binary_ops = {
+    'eq': '=', 'equal': '=', 'notEq': '<>',
+    'lt': '<', 'lte': '<=', 'gt': '>', 'gte': '>='
+  };
+  var quantifiers = ['All', 'Any'];
+
+  for (var name in binary_ops) {
+    sql[name] = function(name, col, val) {
+      return new Binary(binary_ops[name], col, val);
+    }.bind(null, name);
+
+    quantifiers.forEach(function(name, quantifier) {
+      sql[name + quantifier] = function(col, val) {
+        return new Binary(binary_ops[name], col, val, quantifier.toUpperCase() + ' ');
+      };
+    }.bind(null, name));
+    sql[name + 'Some'] = sql[name + 'Any'];
+  }
 
-function Group(op, expressions) {
-  this.op = op;
-  this.expressions = [];
-  _.forEach(expressions, function(expr) {
-    if (isExpr(expr))
-      this.expressions.push(expr);
+  function Binary(op, col, val, quantifier) {
+    if (val == null) {
+      if (op == '=')
+        return sql.isNull(col);
+      else if (op == '<>')
+        return sql.isNotNull(col);
+    }
+
+    this.op = op;
+    this.col = col;
+    this.val = val;
+    this.quantifier = quantifier || '';
+  }
+  sql.Binary = Binary;
+  Binary.prototype.clone = function clone() {
+    return new Binary(this.op, this.col, this.val);
+  };
+  Binary.prototype.toString = function toString(opts) {
+    var sql = handleColumn(this.col, opts);
+    return sql + ' ' + this.op + ' ' + this.quantifier + handleValue(this.val, opts);
+  }
+
+  sql.like = function like(col, val, escape_char) { return new Like(col, val, escape_char); };
+  function Like(col, val, escape_char) {
+    this.col = col;
+    this.val = val;
+    this.escape_char = escape_char;
+  }
+  sql.Like = Like;
+  Like.prototype.clone = function clone() {
+    return new Like(this.col, this.val, this.escape_char);
+  };
+  Like.prototype.toString = function toString(opts) {
+    var sql = handleColumn(this.col, opts) + ' LIKE ' + handleValue(this.val, opts);
+    if (this.escape_char)
+      sql += " ESCAPE '" + this.escape_char + "'";
+    return sql;
+  }
+
+  sql.between = function between(col, val1, val2) { return new Between(col, val1, val2); };
+  function Between(col, val1, val2) {
+    this.col = col;
+    this.val1 = val1;
+    this.val2 = val2;
+  }
+  sql.Between = Between;
+  Between.prototype.clone = function clone() {
+    return new Between(this.col, this.val1, this.val2);
+  };
+  Between.prototype.toString = function(opts) {
+    return handleColumn(this.col, opts) + ' BETWEEN ' + handleValue(this.val1, opts) + ' AND ' + handleValue(this.val2, opts);
+  };
+
+  sql.isNull = function isNull(col) { return new Unary('IS NULL', col); };
+  sql.isNotNull = function isNotNull(col) { return new Unary('IS NOT NULL', col); };
+
+  function Unary(op, col) {
+    this.op = op;
+    this.col = col;
+  }
+  sql.Unary = Unary;
+  Unary.prototype.clone = function clone() {
+    return new Unary(this.op, this.col);
+  };
+  Unary.prototype.toString = function toString(opts) {
+    return handleColumn(this.col, opts) + ' ' + this.op;
+  };
+
+  sql['in'] = function(col, list) {
+    if (types.isArray(list) || list instanceof Statement)
+      return new In(col, list);
     else
-      this.expressions = this.expressions.concat(objToEquals(expr));
-  }.bind(this));
-}
-Group.prototype.clone = function clone() {
-  return new Group(this.op, _.invoke(this.expressions, 'clone'));
-};
-Group.prototype.toString = function toString(opts) {
-  var sql = _.map(this.expressions, function(expr) {
+      return new In(col, toArray(arguments).slice(1));
+  };
+
+  function In(col, list) {
+    this.col = col;
+    this.list = list;
+  }
+  sql.In = In;
+  In.prototype.clone = function clone() {
+    var list = (this.list instanceof Statement) ? this.list.clone() : cloneObj(this.list);
+    return new In(this.col, list);
+  };
+  In.prototype.toString = function toString(opts) {
+    var col_sql = handleColumn(this.col, opts);
+    var sql;
+    if (types.isArray(this.list))
+      sql = handleValues(this.list, opts).join(', ');
+    else if (this.list instanceof Statement)
+      sql = this.list._toString(opts);
+    
+    return col_sql + ' IN (' + sql + ')';
+  };
+
+  sql.exists = function(subquery) { return new Exists(subquery); }
+  function Exists(subquery) {
+    this.subquery = subquery;
+  };
+  sql.Exists = Exists;
+  Exists.prototype.clone = function clone() {
+    return new Exists(this.subquery.clone());
+  };
+  Exists.prototype.toString = function toString(opts) {
+    return 'EXISTS (' + this.subquery._toString(opts) + ')';
+  };
+
+
+  function getAlias(tbl) {
+    var separator = ' AS ';
+    var sep_ix = tbl.indexOf(separator);
+    if (sep_ix == -1) {
+      separator = ' ';
+      sep_ix = tbl.indexOf(separator);
+    }
+    if (sep_ix > -1)
+      return tbl.slice(sep_ix + separator.length);
+    return tbl;
+  }
+  function getTable(tbl) {
+    var space_ix = tbl.indexOf(' ');
+    if (space_ix > -1)
+      tbl = tbl.slice(0, space_ix);
+    if (tbl[0] == '"' && tbl[tbl.length - 1] == '"')
+      tbl = tbl.slice(1, -1);
+    return tbl;
+  }
+
+  function isExpr(expr) {
+    return expr instanceof sql || expr instanceof Group || expr instanceof Not || expr instanceof Binary || expr instanceof Unary || expr instanceof In || expr instanceof Like || expr instanceof Between || expr instanceof Exists;
+  }
+
+  // raw objects default to equals
+  // {first_name: 'Fred', last_name = 'Flintstone'} ->
+  //   [equals('first_name', 'Fred'), equals('last_name', 'Flintstone')]
+  function objToEquals(obj) {
+    var expressions = [];
+    for (var col in obj) {
+      expressions.push(sql.equal(col, obj[col]));
+    }
+    return expressions;
+  }
+
+  function handleExpression(expr, opts) {
+    expr.parens = false;
+    if (expr.expressions && expr.expressions.length == 1)
+      expr.expressions[0].parens = false;
     return expr.toString(opts);
-  }).join(' ' + this.op + ' ');
-  if (this.expressions.length > 1 && this.parens !== false)
-    sql = '(' + sql + ')';
-  return sql;
-};
-
-sql.not = function not(expr) {
-  return new Not(expr);
-};
-function Not(expr) {
-  if (!isExpr(expr))
-    this.expressions = [sql.and(expr)];
-  else
-    this.expressions = [expr];
-}
-Not.prototype.clone = function clone() {
-  return new Not(this.expressions[0].clone());
-};
-Not.prototype.toString = function toString(opts) {
-  return 'NOT ' + this.expressions[0].toString(opts);
-};
-
-var binary_ops = {
-  'eq': '=', 'equal': '=', 'notEq': '<>',
-  'lt': '<', 'lte': '<=', 'gt': '>', 'gte': '>='
-};
-var quantifiers = ['All', 'Any'];
-
-for (var name in binary_ops) {
-  sql[name] = function(name, col, val) {
-    return new Binary(binary_ops[name], col, val);
-  }.bind(null, name);
-
-  _.forEach(quantifiers, function(name, quantifier) {
-    sql[name + quantifier] = function(col, val) {
-      return new Binary(binary_ops[name], col, val, quantifier.toUpperCase() + ' ');
-    };
-  }.bind(null, name));
-  sql[name + 'Some'] = sql[name + 'Any'];
-}
-
-function Binary(op, col, val, quantifier) {
-  if (val == null) {
-    if (op == '=')
-      return sql.isNull(col);
-    else if (op == '<>')
-      return sql.isNotNull(col);
-  }
-
-  this.op = op;
-  this.col = col;
-  this.val = val;
-  this.quantifier = quantifier || '';
-}
-Binary.prototype.clone = function clone() {
-  return new Binary(this.op, this.col, this.val);
-};
-Binary.prototype.toString = function toString(opts) {
-  var sql = handleColOrTbl(opts, this.col);
-  return sql + ' ' + this.op + ' ' + this.quantifier + handleValue(this.val, opts);
-}
-
-sql.like = function like(col, val, escape_char) { return new Like(col, val, escape_char); };
-function Like(col, val, escape_char) {
-  this.col = col;
-  this.val = val;
-  this.escape_char = escape_char;
-}
-Like.prototype.clone = function clone() {
-  return new Like(this.col, this.val, this.escape_char);
-};
-Like.prototype.toString = function toString(opts) {
-  var sql = handleColOrTbl(opts, this.col) + ' LIKE ' + handleValue(this.val, opts);
-  if (this.escape_char)
-    sql += " ESCAPE '" + this.escape_char + "'";
-  return sql;
-}
-
-sql.between = function between(col, val1, val2) { return new Between(col, val1, val2); };
-function Between(col, val1, val2) {
-  this.col = col;
-  this.val1 = val1;
-  this.val2 = val2;
-}
-Between.prototype.clone = function clone() {
-  return new Between(this.col, this.val1, this.val2);
-};
-Between.prototype.toString = function(opts) {
-  return handleColOrTbl(opts, this.col) + ' BETWEEN ' + handleValue(this.val1, opts) + ' AND ' + handleValue(this.val2, opts);
-};
-
-sql.isNull = function isNull(col) { return new Unary('IS NULL', col); };
-sql.isNotNull = function isNotNull(col) { return new Unary('IS NOT NULL', col); };
-
-function Unary(op, col) {
-  this.op = op;
-  this.col = col;
-}
-Unary.prototype.clone = function clone() {
-  return new Unary(this.op, this.col);
-};
-Unary.prototype.toString = function toString(opts) {
-  return handleColOrTbl(opts, this.col) + ' ' + this.op;
-};
-
-sql['in'] = function(col, list) {
-  if (_.isArray(list) || list instanceof Statement)
-    return new In(col, list);
-  else
-    return new In(col, _.toArray(arguments).slice(1));
-};
-
-function In(col, list) {
-  this.col = col;
-  this.list = list;
-}
-In.prototype.clone = function clone() {
-  return new In(this.col, this.list.slice());
-};
-In.prototype.toString = function toString(opts) {
-  var col_sql = handleColOrTbl(opts, this.col);
-  var sql;
-  if (_.isArray(this.list)) {
-    sql = _.map(this.list, function(val) {
+  }
+  sql._handleExpression = handleExpression;
+
+  function handleValues(vals, opts) {
+    return vals.map(function(val) {
       return handleValue(val, opts);
-    }).join(', ');
-  }
-  else if (this.list instanceof Statement) {
-    sql = this.list._toString(opts);
-  }
-  return col_sql + ' IN (' + sql + ')';
-};
-
-sql.exists = function(subquery) { return new Exists(subquery); }
-function Exists(subquery) {
-  this.subquery = subquery;
-};
-Exists.prototype.clone = function clone() {
-  return new Exists(this.subquery.clone());
-};
-Exists.prototype.toString = function toString(opts) {
-  return 'EXISTS (' + this.subquery._toString(opts) + ')';
-};
-
-
-function getAlias(tbl) {
-  var separator = ' AS ';
-  var sep_ix = tbl.indexOf(separator);
-  if (sep_ix == -1) {
-    separator = ' ';
-    sep_ix = tbl.indexOf(separator);
-  }
-  if (sep_ix > -1)
-    return tbl.slice(sep_ix + separator.length);
-  return tbl;
-}
-function getTable(tbl) {
-  var space_ix = tbl.indexOf(' ');
-  if (space_ix > -1)
-    tbl = tbl.slice(0, space_ix);
-  if (tbl[0] == '"' && tbl[tbl.length - 1] == '"')
-    tbl = tbl.slice(1, -1);
-  return tbl;
-}
-
-function isExpr(expr) {
-  return expr instanceof Group || expr instanceof Not || expr instanceof Binary || expr instanceof Unary || expr instanceof In || expr instanceof Like || expr instanceof Between || expr instanceof Exists;
-}
-
-// raw objects default to equals
-// {first_name: 'Fred', last_name = 'Flintstone'} ->
-//   [equals('first_name', 'Fred'), equals('last_name', 'Flintstone')]
-function objToEquals(obj) {
-  var expressions = [];
-  for (var col in obj) {
-    expressions.push(sql.equal(col, obj[col]));
-  }
-  return expressions;
-}
-
-function handleValue(val, opts) {
-  if (val instanceof Statement)
-    return '(' + val._toString(opts) + ')';
-
-  if (val instanceof sql)
-    return val.toString();
-
-  if (opts.parameterized) {
-    opts.values.push(val);
-    return opts.placeholder.replace('%d', opts.value_ix++);
-  }
-
-  return sql.convert(val);
-}
-
-sql.convert = function(val) {
-  for (var type in sql.conversions)
-    if (_['is' + type].call(_, val))
-      return sql.conversions[type](val);
-
-  throw new Error('value is of an unsupported type and cannot be converted to SQL: ' + val);
-}
-
-sql.conversions = {
-  'String': function(str) { return "'" + str.replace(/'/g, "''") + "'"; },
-  'Null': function() { return 'null'; },
-  'Undefined': function() { return 'null'; },
-  'Number': function(num) { return num.toString(); },
-  'Boolean': function(bool) { return bool.toString().toUpperCase(); },
-  'Date': function(dt) { return "TIMESTAMP WITH TIME ZONE '" + dt.toISOString().replace('T', ' ').replace('Z', '+00:00') + "'"; },
-  'Array': function(arr) { return '{' + arr.map(sql.convert).join(', ') + '}'; }
-};
-
-function handleTable(opts, expr) {
-  return handleColOrTbl(opts, expandAlias(expr));
-}
-
-// handles prefixes before a '.' and suffixes after a ' '
-// for example: 'tbl.order AS tbl_order' -> 'tbl."order" AS tbl_order'
-var unquoted_regex = /^[\w\.]+(( AS)? \w+)?$/i;
-function handleColOrTbl(opts, expr) {
-  if (expr instanceof Statement) {
-    var result = '(' + expr._toString(opts) + ')';
-    if (expr._alias) {
-      result += ' ' + autoQuote(expr._alias);
+    });
+  }
+  sql._handleValues = handleValues;
+
+  function handleValue(val, opts) {
+    if (val instanceof Statement)
+      return '(' + val._toString(opts) + ')';
+
+    if (val instanceof sql)
+      return val.toString(opts);
+
+    if (opts.parameterized) {
+      opts.values.push(val);
+      return opts.placeholder.replace('%d', opts.value_ix++);
     }
-    return result;
+
+    return sql.convert(val);
   }
-  if (expr instanceof val)
-    return handleValue(expr.val, opts);
+  sql._handleValue = handleValue;
 
-  if (!(expr instanceof sql) && unquoted_regex.test(expr))
-    return quoteColOrTbl(expr);
-  else
-    return expr;
-}
-
-function quoteColOrTbl(expr) {
-  var prefix = '';
-  var dot_ix = expr.lastIndexOf('.');
-  if (dot_ix > -1) {
-    prefix = expr.slice(0, dot_ix);
-    expr = expr.slice(dot_ix + 1);
-  }
-
-  var suffix = '';
-  var space_ix = expr.indexOf(' ');
-  if (space_ix > -1) {
-    suffix = expr.slice(space_ix);
-    expr = expr.slice(0, space_ix);
-  }
-
-  return (prefix ? autoQuote(prefix) + '.' : '') + autoQuote(expr) + suffix;
-}
-
-// auto-quote tbl & col names if they have caps or are reserved words
-function autoQuote(str) {
-  if (/^\w+$/.test(str) && (/[A-Z]/.test(str) || str in reserved))
-    return '"' + str + '"';
-  return str;
-}
-
-// Postgres: Table C-1 of http://www.postgresql.org/docs/9.3/static/sql-keywords-appendix.html
-// SQLite: http://www.sqlite.org/lang_keywords.html
-var reserved = ['all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric', 'authorization', 'both', 'case', 'cast', 'check', 'collate', 'collation', 'column', 'constraint', 'create', 'cross', 'current_catalog', 'current_date', 'current_role', 'current_time', 'current_timestamp', 'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end', 'except', 'false', 'fetch', 'for', 'foreign', 'freeze', 'from', 'full', 'grant', 'group', 'having', 'ilike', 'in', 'initially', 'inner', 'intersect', 'into', 'is', 'isnull', 'join', 'lateral', 'leading', 'left', 'like', 'limit', 'localtime', 'localtimestamp', 'natural', 'not', 'notnull', 'null', 'offset', 'on', 'only', 'or', 'order', 'outer', 'over', 'overlaps', 'placing', 'primary', 'references', 'returning', 'right', 'select', 'session_user', 'similar', 'some', 'symmetric', 'table', 'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic', 'verbose', 'when', 'where', 'window', 'with', 'abort', 'action', 'add', 'after', 'all', 'alter', 'analyze', 'and', 'as', 'asc', 'attach', 'autoincrement', 'before', 'begin', 'between', 'by', 'cascade', 'case', 'cast', 'check', 'collate', 'column', 'commit', 'conflict', 'constraint', 'create', 'cross', 'current_date', 'current_time', 'current_timestamp', 'database', 'default', 'deferrable', 'deferred', 'delete', 'desc', 'detach', 'distinct', 'drop', 'each', 'else', 'end', 'escape', 'except', 'exclusive', 'exists', 'explain', 'fail', 'for', 'foreign', 'from', 'full', 'glob', 'group', 'having', 'if', 'ignore', 'immediate', 'in', 'index', 'indexed', 'initially', 'inner', 'insert', 'instead', 'intersect', 'into', 'is', 'isnull', 'join', 'key', 'left', 'like', 'limit', 'match', 'natural', 'no', 'not', 'notnull', 'null', 'of', 'offset', 'on', 'or', 'order', 'outer', 'plan', 'pragma', 'primary', 'query', 'raise', 'references', 'regexp', 'reindex', 'release', 'rename', 'replace', 'restrict', 'right', 'rollback', 'row', 'savepoint', 'select', 'set', 'table', 'temp', 'temporary', 'then', 'to', 'transaction', 'trigger', 'union', 'unique', 'update', 'using', 'vacuum', 'values', 'view', 'virtual', 'when', 'where'];
-reserved = _.object(reserved, reserved);
-
-
-function isPlainObject(val) {
-  return _.isObject(val) && !_.isArray(val);
-}
-
-
-// optional conveniences
-sql._aliases = {};
-sql.aliasExpansions = function aliasExpansions(aliases) {
-  sql._aliases = aliases;
-}
-function expandAlias(tbl) {
-  return tbl in sql._aliases ? sql._aliases[tbl] + ' ' + tbl : tbl;
-}
-
-sql.joinCriteria = function joinCriteria(fn) {
-  this._joinCriteria = fn;
-};
-
-
-// provided for browser support, based on https://gist.github.com/prust/5936064
-function inherits(ctor, superCtor) {
-  if (Object.create) {
-    ctor.super_ = superCtor;
-    ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-            value: ctor,
-            enumerable: false,
-            writable: true,
-            configurable: true
-        }
+  sql.convert = function(val) {
+    for (var type in sql.conversions) {
+      if (types['is' + type](val))
+        return sql.conversions[type](val);
+    }
+
+    throw new Error('value is of an unsupported type and cannot be converted to SQL: ' + val);
+  }
+
+  sql.conversions = {
+    'String': function(str) { return "'" + str.replace(/'/g, "''") + "'"; },
+    'Null': function() { return 'null'; },
+    'Undefined': function() { return 'null'; },
+    'Number': function(num) { return num.toString(); },
+    'Boolean': function(bool) { return bool.toString().toUpperCase(); },
+    'Date': function(dt) { return "TIMESTAMP WITH TIME ZONE '" + dt.toISOString().replace('T', ' ').replace('Z', '+00:00') + "'"; }
+  };
+
+  function handleTables(tables, opts) {
+    return tables.map(function(tbl) { return handleTable(tbl, opts); }).join(', ');
+  }
+  sql._handleTables = handleTables;
+
+  function handleTable(table, opts) {
+    return handleColumn(expandAlias(table), opts);
+  }
+  sql._handleTable = handleTable;
+
+  function handleColumns(cols, opts) {
+    return cols.map(function(col) { return handleColumn(col, opts); }).join(', ');
+  }
+  sql._handleColumns = handleColumns;
+
+  // handles prefixes before a '.' and suffixes after a ' '
+  // for example: 'tbl.order AS tbl_order' -> 'tbl."order" AS tbl_order'
+  var unquoted_regex = /^[\w\.]+(( AS)? \w+)?$/i;
+  function handleColumn(expr, opts) {
+    if (expr instanceof Statement)
+      return expr._toNestedString(opts);
+
+    if (expr instanceof val)
+      return handleValue(expr.val, opts);
+
+    if (expr instanceof sql)
+      return expr.toString(opts);
+
+    if (unquoted_regex.test(expr))
+      return quoteColOrTbl(expr);
+    else
+      return expr;
+  }
+  sql._handleColumn = handleColumn;
+
+  function quoteColOrTbl(expr) {
+    var prefix = '';
+    var dot_ix = expr.lastIndexOf('.');
+    if (dot_ix > -1) {
+      prefix = expr.slice(0, dot_ix);
+      expr = expr.slice(dot_ix + 1);
+    }
+
+    var suffix = '';
+    var space_ix = expr.indexOf(' ');
+    if (space_ix > -1) {
+      suffix = expr.slice(space_ix);
+      expr = expr.slice(0, space_ix);
+    }
+
+    return (prefix ? autoQuote(prefix) + '.' : '') + autoQuote(expr) + suffix;
+  }
+  sql._quoteColOrTbl = quoteColOrTbl;
+
+  // auto-quote tbl & col names if they have caps or are reserved words
+  sql._autoQuoteChar = '"';
+  
+  function autoQuote(str) {
+    if (/^\w+$/.test(str) && (/[A-Z]/.test(str) || str in reserved))
+      return sql._autoQuoteChar + str + sql._autoQuoteChar;
+    return str;
+  }
+  sql._autoQuote = autoQuote;
+
+  // Postgres: Table C-1 of http://www.postgresql.org/docs/9.3/static/sql-keywords-appendix.html
+  // SQLite: http://www.sqlite.org/lang_keywords.html
+  var reserved = ['all', 'analyse', 'analyze', 'and', 'any', 'array', 'as', 'asc', 'asymmetric', 'authorization', 'both', 'case', 'cast', 'check', 'collate', 'collation', 'column', 'constraint', 'create', 'cross', 'current_catalog', 'current_date', 'current_role', 'current_time', 'current_timestamp', 'current_user', 'default', 'deferrable', 'desc', 'distinct', 'do', 'else', 'end', 'except', 'false', 'fetch', 'for', 'foreign', 'freeze', 'from', 'full', 'grant', 'group', 'having', 'ilike', 'in', 'initially', 'inner', 'intersect', 'into', 'is', 'isnull', 'join', 'lateral', 'leading', 'left', 'like', 'limit', 'localtime', 'localtimestamp', 'natural', 'not', 'notnull', 'null', 'offset', 'on', 'only', 'or', 'order', 'outer', 'over', 'overlaps', 'placing', 'primary', 'references', 'returning', 'right', 'select', 'session_user', 'similar', 'some', 'symmetric', 'table', 'then', 'to', 'trailing', 'true', 'union', 'unique', 'user', 'using', 'variadic', 'verbose', 'when', 'where', 'window', 'with', 'abort', 'action', 'add', 'after', 'all', 'alter', 'analyze', 'and', 'as', 'asc', 'attach', 'autoincrement', 'before', 'begin', 'between', 'by', 'cascade', 'case', 'cast', 'check', 'collate', 'column', 'commit', 'conflict', 'constraint', 'create', 'cross', 'current_date', 'current_time', 'current_timestamp', 'database', 'default', 'deferrable', 'deferred', 'delete', 'desc', 'detach', 'distinct', 'drop', 'each', 'else', 'end', 'escape', 'except', 'exclusive', 'exists', 'explain', 'fail', 'for', 'foreign', 'from', 'full', 'glob', 'group', 'having', 'if', 'ignore', 'immediate', 'in', 'index', 'indexed', 'initially', 'inner', 'insert', 'instead', 'intersect', 'into', 'is', 'isnull', 'join', 'key', 'left', 'like', 'limit', 'match', 'natural', 'no', 'not', 'notnull', 'null', 'of', 'offset', 'on', 'or', 'order', 'outer', 'plan', 'pragma', 'primary', 'query', 'raise', 'references', 'regexp', 'reindex', 'release', 'rename', 'replace', 'restrict', 'right', 'rollback', 'row', 'savepoint', 'select', 'set', 'table', 'temp', 'temporary', 'then', 'to', 'transaction', 'trigger', 'union', 'unique', 'update', 'using', 'vacuum', 'values', 'view', 'virtual', 'when', 'where'];
+  var reserved_obj = {};
+  reserved.forEach(function(val) {
+    reserved_obj[val] = val;
+  });
+  reserved = reserved_obj;
+  sql._reserved = reserved;
+
+  function isPlainObject(val) {
+    return types.isObject(val) && !types.isArray(val);
+  }
+
+
+  // optional conveniences
+  sql._aliases = {};
+  sql.aliasExpansions = function aliasExpansions(aliases) {
+    sql._aliases = aliases;
+  }
+  function expandAlias(tbl) {
+    return typeof tbl == 'string' && tbl in sql._aliases ? sql._aliases[tbl] + ' ' + tbl : tbl;
+  }
+
+  sql.joinCriteria = function joinCriteria(fn) {
+    if (!fn) return sql._joinCriteria;
+    sql._joinCriteria = fn;
+  };
+
+
+  // provided for browser support, based on https://gist.github.com/prust/5936064
+  function inherits(ctor, superCtor) {
+    function noop() {};
+
+    if (Object.create) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+          constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+          }
+      });
+    }
+    else {
+      noop.prototype = superCtor.prototype;
+      ctor.super_ = superCtor;
+      ctor.prototype = new noop;
+      ctor.prototype.constructor = ctor;
+    }
+    return ctor;
+  }
+  sql.inherits = inherits;
+
+  sql._extension = function () {
+    var ext = subclass(sql);
+
+    Object.keys(sql).forEach(function(prop_name) {
+      ext[prop_name] = sql[prop_name];
+    });
+
+    ['select', 'insert', 'update', 'delete'].forEach(function (stmt) {
+      var cls = sql[stmt];
+      ext[stmt] = subclass(cls);
+      ext[stmt].defineClause = cls.defineClause;
+      ext[stmt].prototype.clauses = cls.prototype.clauses.slice();
     });
+    ext.insertInto = ext.insert;
+    ext.deleteFrom = ext.delete;
+
+    return ext;
+  }
+
+  function subclass(base) {
+    function cls() {
+      if (!(this instanceof cls))
+        return applyNew(cls, arguments);
+      
+      base.apply(this, arguments);
+    }
+    return inherits(cls, base);
   }
-  else {
-    noop.prototype = superCtor.prototype;
-    ctor.super_ = superCtor;
-    ctor.prototype = new noop;
-    ctor.prototype.constructor = superCtor;
+
+  // http://stackoverflow.com/a/8843181/194758
+  function applyNew(cls, args) {
+    args = toArray(args);
+    args.unshift(null);
+    return new (cls.bind.apply(cls, args));
   }
-  return ctor;
-}
 
-if (typeof module != 'undefined')
-  module.exports = sql;
-else
-  global.SqlBricks = sql;
+  if (is_common_js)
+    module.exports = sql;
+  else
+    window.SqlBricks = sql;
+
 })();
diff --git a/tests/doctests.js b/tests/doctests.js
index 5b5d067..50dedb0 100644
--- a/tests/doctests.js
+++ b/tests/doctests.js
@@ -1,10 +1,18 @@
 (function() {
 
-var global = this;
-var _ = global._ || require('underscore');
-var sql = global.SqlBricks || require('../sql-bricks.js');
+var is_common_js = typeof exports != 'undefined';
+var sql = is_common_js ? require('../sql-bricks.js') : window.SqlBricks;
+
+if (is_common_js) {
+  var args = process.argv;
+  if (args[args.length - 1] == '--empty-extension') {
+    console.log('doctests configured with an empty extension');
+    sql = sql._extension();
+  }
+}
+
 var assert;
-if (typeof require != 'undefined') {
+if (is_common_js) {
   assert = require('assert');
 }
 else {
@@ -12,8 +20,23 @@ else {
     'equal': function(actual, expected) {
       if (actual != expected) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
     },
-    'deepEqual': function(actual, expected) {
-      if (!_.isEqual(actual, expected)) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
+    '_eq': function(actual, expected) {
+      if (typeof actual != 'object') return actual === expected;
+
+      var actual_keys = Object.keys(actual), expected_keys = Object.keys(expected);
+      if (actual_keys.length != expected_keys.length)
+        return false;
+
+      var result = true;
+      actual_keys.forEach(function(key) {
+        if (!assert._eq(actual[key], expected[key])) result = false;
+      });
+
+      return result;
+    },
+    'deepEqual': function(actual, expected) {
+      if (!assert._eq(actual, expected))
+        throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
     }
   };
 }
@@ -29,6 +52,14 @@ describe('SQL Bricks', function() {
   describe('documentation examples', function() {
 
 
+function invert(obj) {
+  var inverted_obj = {};
+  Object.keys(obj).forEach(function(key) {
+    inverted_obj[obj[key]] = key;
+  });
+  return inverted_obj; 
+}
+
 it(".where(or({last_name: 'Rubble'}, $in('first_name', ['Fred', 'Wilma', 'Pebbles'])));", function() {
 
 check(select().from('person')
  .where(or({last_name: 'Rubble'}, $in('first_name', ['Fred', 'Wilma', 'Pebbles']))), "SELECT * FROM person WHERE last_name = 'Rubble' OR first_name IN ('Fred', 'Wilma', 'Pebbles')");
@@ -38,6 +69,14 @@ it("select('*').from('person').where({'billing_addr_id': sql('mailing_addr_id')}
 check(select('*').from('person').where({'billing_addr_id': sql('mailing_addr_id')}), "SELECT * FROM person WHERE billing_addr_id = mailing_addr_id");
 });
 
+it("select().where(sql('field @> $ and field @> $', { key: 'value' }, { key: 'value2' })).toParams()", function() {
+check(select().where(sql('field @> $ and field @> $', { key: 'value' }, { key: 'value2' })).toParams(), {"text": "SELECT * WHERE field @> $1 and field @> $2", "values": [{"key": "value"}, {"key": "value2"}]});
+});
+
+it("select().where({name: 'Fred'}).and(sql('f1 @> $2 and f2 @> $1', [{key: 'value' }, {key: 'value2'}])).toParams()", function() {
+check(select().where({name: 'Fred'}).and(sql('f1 @> $2 and f2 @> $1', [{key: 'value' }, {key: 'value2'}])).toParams(), {"text": "SELECT * WHERE name = $1 AND f1 @> $3 and f2 @> $2", "values": ["Fred", {"key": "value"}, {"key": "value2"}]});
+});
+
 it("select().from('person').where(sql.val('Fred'), sql('first_name'));", function() {
 check(select().from('person').where(sql.val('Fred'), sql('first_name')), "SELECT * FROM person WHERE 'Fred' = first_name");
 });
@@ -79,6 +118,42 @@ select('*').from('person').innerJoin('address').on('person.addr_id', 'address.id
 check(select('*').from('person').join('address').on({'person.addr_id': 'address.id'}), "SELECT * FROM person INNER JOIN address ON person.addr_id = address.id");
 });
 
+it("select('*').from('person').innerJoin('address').using('address_id');", function() {
+check(select('*').from('person').innerJoin('address').using('address_id'), "SELECT * FROM person INNER JOIN address USING (address_id)");
+});
+
+it("select('*').from('person').join('address').using('address_id', 'country_id');", function() {
+select('*').from('person').innerJoin('address').using('address_id');
+
+check(select('*').from('person').join('address').using('address_id', 'country_id'), "SELECT * FROM person INNER JOIN address USING (address_id, country_id)");
+});
+
+it("select('*').from('person').join('address').using('address_id, country_id');", function() {
+select('*').from('person').innerJoin('address').using('address_id');
+
+select('*').from('person').join('address').using('address_id', 'country_id');
+
+check(select('*').from('person').join('address').using('address_id, country_id'), "SELECT * FROM person INNER JOIN address USING (address_id, country_id)");
+});
+
+it("select('*').from('person').join('address').using(['address_id', 'country_id']);", function() {
+select('*').from('person').innerJoin('address').using('address_id');
+
+select('*').from('person').join('address').using('address_id', 'country_id');
+
+select('*').from('person').join('address').using('address_id, country_id');
+
+check(select('*').from('person').join('address').using(['address_id', 'country_id']), "SELECT * FROM person INNER JOIN address USING (address_id, country_id)");
+});
+
+it("select('*').from('person').join('address', ['address_id', 'country_id']);", function() {
+check(select('*').from('person').join('address', ['address_id', 'country_id']), "SELECT * FROM person INNER JOIN address USING (address_id, country_id)");
+});
+
+it("select().from('person').naturalJoin('address');", function() {
+check(select().from('person').naturalJoin('address'), "SELECT * FROM person NATURAL INNER JOIN address");
+});
+
 it("select('*').from('person').where('first_name', 'Fred');", function() {
 check(select('*').from('person').where('first_name', 'Fred'), "SELECT * FROM person WHERE first_name = 'Fred'");
 });
@@ -97,6 +172,11 @@ it("select('*').from('person').where(or(like('last_name', 'Flint%'), {'first_nam
 check(select('*').from('person').where(or(like('last_name', 'Flint%'), {'first_name': 'Fred'})), "SELECT * FROM person WHERE last_name LIKE 'Flint%' OR first_name = 'Fred'");
 });
 
+it("select('*').from('person').where(sql('LTRIM(last_name) = $', last_name));", function() {
+var last_name = 'Flintstone';
+check(select('*').from('person').where(sql('LTRIM(last_name) = $', last_name)), "SELECT * FROM person WHERE LTRIM(last_name) = 'Flintstone'");
+});
+
 it(".groupBy('city').having(lt('max(temp_lo)', 40))", function() {
 
 check(select('city', 'max(temp_lo)').from('weather')
  .groupBy('city').having(lt('max(temp_lo)', 40)), "SELECT city, max(temp_lo) FROM weather GROUP BY city HAVING max(temp_lo) < 40");
@@ -107,8 +187,8 @@ it(".select().from('person').where({'last_name': 'Rubble'});", function() {
 check(select().from('person').where({'last_name': 'Flintstone'}).union()
  .select().from('person').where({'last_name': 'Rubble'}), "SELECT * FROM person WHERE last_name = 'Flintstone' UNION SELECT * FROM person WHERE last_name = 'Rubble'");
 });
 
-it("select('addr_id').from('person').forUpdate('addr_id').noWait();", function() {
-check(select('addr_id').from('person').forUpdate('addr_id').noWait(), "SELECT addr_id FROM person FOR UPDATE addr_id NO WAIT");
+it("select('addr_id').from('person').forUpdate().of('addr_id').noWait();", function() {
+check(select('addr_id').from('person').forUpdate().of('addr_id').noWait(), "SELECT addr_id FROM person FOR UPDATE OF addr_id NOWAIT");
 });
 
 it("insert('person', {'first_name': 'Fred', 'last_name': 'Flintstone'});", function() {
@@ -119,14 +199,6 @@ it("insertInto('person', 'first_name', 'last_name').values('Fred', 'Flintstone')
 check(insertInto('person', 'first_name', 'last_name').values('Fred', 'Flintstone'), "INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')");
 });
 
-it("insert().orReplace().into('person').values({'first_name': 'Fred', 'id': 33});", function() {
-check(insert().orReplace().into('person').values({'first_name': 'Fred', 'id': 33}), "INSERT OR REPLACE INTO person (first_name, id) VALUES ('Fred', 33)");
-});
-
-it("insert().orReplace().into('person').values({'first_name': 'Fred', 'last_name': 'Flintstone'});", function() {
-check(insert().orReplace().into('person').values({'first_name': 'Fred', 'last_name': 'Flintstone'}), "INSERT OR REPLACE INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')");
-});
-
 it("insertInto('person', 'first_name', 'last_name').values('Fred', 'Flintstone');", function() {
 check(insertInto('person', 'first_name', 'last_name').values('Fred', 'Flintstone'), "INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone')");
 });
@@ -147,21 +219,10 @@ insertInto('person', 'first_name', 'last_name').values([['Fred', 'Flintstone'],
 check(insertInto('person').values([{'first_name': 'Fred', 'last_name': 'Flintstone'}, {'first_name': 'Wilma', 'last_name': 'Flintstone'}]), "INSERT INTO person (first_name, last_name) VALUES ('Fred', 'Flintstone'), ('Wilma', 'Flintstone')");
 });
 
-it("ins.returning('account.pk');", function() {
-var ins = insert('person', 'first_name, last_name');
-ins.select('first_name, last_name')
-.from('account');
-check(ins.returning('account.pk'), "INSERT INTO person (first_name, last_name) SELECT first_name, last_name FROM account RETURNING account.pk");
-});
-
 it("update('person', {'first_name': 'Fred', 'last_name': 'Flintstone'});", function() {
 check(update('person', {'first_name': 'Fred', 'last_name': 'Flintstone'}), "UPDATE person SET first_name = 'Fred', last_name = 'Flintstone'");
 });
 
-it("update('person').orReplace().set({'first_name': 'Fred', 'id': 33});", function() {
-check(update('person').orReplace().set({'first_name': 'Fred', 'id': 33}), "UPDATE OR REPLACE person SET first_name = 'Fred', id = 33");
-});
-
 it("update('person').set('first_name', 'Fred').set('last_name', 'Flintstone');", function() {
 check(update('person').set('first_name', 'Fred').set('last_name', 'Flintstone'), "UPDATE person SET first_name = 'Fred', last_name = 'Flintstone'");
 });
@@ -230,7 +291,7 @@ check(select().from('psn').join('addr', {'psn.addr_id': 'addr.id'}), "SELECT * F
 
 it("select().from('person').join('address');", function() {
 var alias_expansions = {'psn': 'person', 'addr': 'address', 'zip': 'zipcode', 'usr': 'user'};
-var table_to_alias = _.invert(alias_expansions);
+var table_to_alias = invert(alias_expansions);
 sql.joinCriteria(function(left_tbl, left_alias, right_tbl, right_alias) {
   var criteria = {};
   criteria[left_alias + '.' + table_to_alias[right_tbl] + '_id'] = right_alias + '.id';
@@ -282,7 +343,7 @@ check(select('person.order AS person_order').from('person'), "SELECT person.\"or
 });
 
 function check(actual, expected) {
-  if (actual instanceof sql.Statement)
+  if (typeof actual == 'object' && typeof expected == 'string')
     assert.equal(actual.toString(), expected);
   else
     assert.deepEqual(actual, expected);
diff --git a/tests/doctests.tmpl b/tests/doctests.tmpl
index 8fb7273..70d061c 100644
--- a/tests/doctests.tmpl
+++ b/tests/doctests.tmpl
@@ -1,10 +1,18 @@
 (function() {
 
-var global = this;
-var _ = global._ || require('underscore');
-var sql = global.SqlBricks || require('../sql-bricks.js');
+var is_common_js = typeof exports != 'undefined';
+var sql = is_common_js ? require('../sql-bricks.js') : window.SqlBricks;
+
+if (is_common_js) {
+  var args = process.argv;
+  if (args[args.length - 1] == '--empty-extension') {
+    console.log('doctests configured with an empty extension');
+    sql = sql._extension();
+  }
+}
+
 var assert;
-if (typeof require != 'undefined') {
+if (is_common_js) {
   assert = require('assert');
 }
 else {
@@ -12,8 +20,23 @@ else {
     'equal': function(actual, expected) {
       if (actual != expected) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
     },
+    '_eq': function(actual, expected) {
+      if (typeof actual != 'object') return actual === expected;
+
+      var actual_keys = Object.keys(actual), expected_keys = Object.keys(expected);
+      if (actual_keys.length != expected_keys.length)
+        return false;
+
+      var result = true;
+      actual_keys.forEach(function(key) {
+        if (!assert._eq(actual[key], expected[key])) result = false;
+      });
+
+      return result;
+    },
     'deepEqual': function(actual, expected) {
-      if (!_.isEqual(actual, expected)) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
+      if (!assert._eq(actual, expected))
+        throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
     }
   };
 }
@@ -29,6 +52,14 @@ describe('SQL Bricks', function() {
   describe('documentation examples', function() {
 
 
+function invert(obj) {
+  var inverted_obj = {};
+  Object.keys(obj).forEach(function(key) {
+    inverted_obj[obj[key]] = key;
+  });
+  return inverted_obj; 
+}
+
 {{tests}}
 
 
@@ -36,7 +67,7 @@ describe('SQL Bricks', function() {
 });
 
 function check(actual, expected) {
-  if (actual instanceof sql.Statement)
+  if (typeof actual == 'object' && typeof expected == 'string')
     assert.equal(actual.toString(), expected);
   else
     assert.deepEqual(actual, expected);
diff --git a/tests/gen-tests.js b/tests/gen-tests.js
index 2d56ddf..72cdf00 100644
--- a/tests/gen-tests.js
+++ b/tests/gen-tests.js
@@ -1,12 +1,14 @@
 var fs = require('fs');
-var _ = require('underscore');
 
 var comment = '// ';
 var readme = fs.readFileSync(__dirname + '/../index.html', 'utf8');
 var contents = '';
 readme.match(/<pre>[^<]+<\/pre>/g).forEach(function(ex) {
   ex = ex.slice('<pre>'.length, -'</pre>'.length);
-  var lines = _.compact(ex.split('\n'));
+  var lines = [];
+  ex.split('\n').forEach(function(line) {
+    if (line) lines.push(line);
+  });
   lines.forEach(function(line, ix) {
     line = line.trim();
     var next_line = (lines[ix + 1] || '').trim();
@@ -33,17 +35,24 @@ readme.match(/<pre>[^<]+<\/pre>/g).forEach(function(ex) {
     }
   });
 });
+
 var tmpl = fs.readFileSync(__dirname + '/doctests.tmpl', 'utf8');
-fs.writeFileSync(__dirname + '/doctests.js', tmpl.replace('{{tests}}', contents));
+
+// in str.replace() some $ combinations are special. To escape and just do a regular $, do $$
+// thus replace(/\$/g, '$$$$') replaces a single dollar sign with two dollar signs so they aren't misinterpreted in the other replace
+fs.writeFileSync(__dirname + '/doctests.js', tmpl.replace('{{tests}}', contents.replace(/\$/g, '$$$$')));
 
 function wrap(lines) {
   var last_line = lines[lines.length - 1];
   var match = /var (\w+) =/.exec(last_line);
   if (match)
     lines.push(match[1] + ';');
-  lines = _.compact(lines);
-  lines = _.reject(lines, isComment);
-  return lines;
+
+  var processed_lines = [];
+  lines.forEach(function(line) {
+    if (line && !isComment(line)) processed_lines.push(line);
+  });
+  return processed_lines;
 }
 function isComment(str) {
   return str.slice(0, comment.length) == comment;
@@ -58,6 +67,6 @@ function getExpected(lines, ix) {
     ix--;
   }
   comments.reverse();
-  comments = _.invoke(comments, 'trim');
+  comments = comments.map(function(comment) { return comment.trim(); });
   return comments.join(' ');
 }
diff --git a/tests/tests.js b/tests/tests.js
index 66eafcf..54bbf8d 100644
--- a/tests/tests.js
+++ b/tests/tests.js
@@ -1,10 +1,19 @@
 (function() {
 
-var global = this;
-var _ = global._ || require('underscore');
-var sql = global.SqlBricks || require('../sql-bricks.js');
+var is_common_js = typeof exports != 'undefined';
+
+var sql = is_common_js ? require('../sql-bricks.js') : window.SqlBricks;
+
+if (is_common_js) {
+  var args = process.argv;
+  if (args[args.length - 1] == '--empty-extension') {
+    console.log('tests configured with an empty extension');
+    sql = sql._extension();
+  }
+}
+
 var assert;
-if (typeof require != 'undefined') {
+if (is_common_js) {
   assert = require('assert');
 }
 else {
@@ -15,9 +24,33 @@ else {
   assert.equal = function(actual, expected) {
     if (actual != expected) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
   };
+  assert._eq = function(actual, expected) {
+    if (typeof actual != 'object') return actual === expected;
+
+    var actual_keys = Object.keys(actual), expected_keys = Object.keys(expected);
+    if (actual_keys.length != expected_keys.length)
+      return false;
+
+    var result = true;
+    actual_keys.forEach(function(key) {
+      if (!assert._eq(actual[key], expected[key])) result = false;
+    });
+
+    return result;
+  };
   assert.deepEqual = function(actual, expected) {
-    if (!_.isEqual(actual, expected)) throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
+    if (!assert._eq(actual, expected))
+      throw new Error(JSON.stringify(actual) + ' == ' + JSON.stringify(expected));
   };
+  assert.throws = function(fn) {
+    try {
+      fn();
+    }
+    catch(ex) {
+      return true;
+    }
+    throw new Error('The function passed to assert.throws() did not throw');
+  }
 }
 
 var select = sql.select, insertInto = sql.insertInto, insert = sql.insert,
@@ -29,7 +62,10 @@ var and = sql.and, or = sql.or, like = sql.like, not = sql.not, $in = sql.in,
   union = sql.union;
 
 var alias_expansions = {'usr': 'user', 'psn': 'person', 'addr': 'address'};
-var table_to_alias = _.invert(alias_expansions);
+var table_to_alias = {};
+Object.keys(alias_expansions).forEach(function(key) {
+  table_to_alias[alias_expansions[key]] = key;
+});
 sql.aliasExpansions(alias_expansions);
 
 sql.joinCriteria(function(left_tbl, left_alias, right_tbl, right_alias) {
@@ -59,6 +95,27 @@ describe('SQL Bricks', function() {
       }), 'SELECT * FROM "user" WHERE removed = $1 AND name = $2',
       [0, 'Fred Flintstone']);
     });
+    it('should generate WHERE clauses with arbitrary SQL', function() {
+      var stmt = select().from('time_limits');
+      stmt.where(sql(
+        "tsrange(start_date_time, end_date_time, '[]') @> tsrange($1, $2, '[]')"));
+      check(stmt,
+        "SELECT * FROM time_limits WHERE tsrange(start_date_time, end_date_time, '[]') @> tsrange($1, $2, '[]')");
+    });
+    it('should generate WHERE clauses with arbitrary SQL and parameters', function() {
+      var stmt = select().from('time_limits');
+      var time1 = '2014-12-06T22:35:00';
+      var time2 = '2014-12-06T22:36:00';
+      stmt.where(sql(
+        "tsrange(start_date_time, end_date_time, '[]') @> tsrange($, $, '[]')", time1, time2));
+      checkParams(stmt,
+        "SELECT * FROM time_limits WHERE tsrange(start_date_time, end_date_time, '[]') @> tsrange($1, $2, '[]')",
+        ['2014-12-06T22:35:00', '2014-12-06T22:36:00']);
+    });
+    it('should handle WHERE clauses with sql() and a null check', function() {
+      check(select().from('test').where(sql('my_col_val()'), null),
+        "SELECT * FROM test WHERE my_col_val() IS NULL");
+    });
     it('should not escape single quotes in the values returned by toParams()', function() {
       checkParams(update('user', {'name': "Muad'Dib"}),
         'UPDATE "user" SET name = $1',
@@ -98,12 +155,25 @@ describe('SQL Bricks', function() {
         'SELECT (SELECT last_name FROM "user" WHERE first_name = $1)',
         ['Fred']);
     });
+    it('should properly parameterize subqueries with a join', function() {
+      var values = {'first_name': 'Fred'};
+      var query = select().from(select().from('user').where(values).as('subuser'))
+        .join('other_table', {'other_table.id': 'subuser.id'});
+      checkParams(query,
+        'SELECT * FROM (SELECT * FROM "user" WHERE first_name = $1) subuser INNER JOIN other_table ON other_table.id = subuser.id',
+        ['Fred']);
+    });
     it('should properly parameterize subqueries in updates', function() {
       var addr_id_for_usr = select('id').from('address').where('usr_id', sql('"user".id')).and('active', true);
       checkParams(update('user').set('addr_id', addr_id_for_usr),
         'UPDATE "user" SET addr_id = (SELECT id FROM address WHERE usr_id = "user".id AND active = $1)',
         [true])
     });
+    it('should properly merge parameterized sub-expressions with $%d placeholders', function() {
+      checkParams(select().from('tbl').where(or(sql('a = $1', 444), sql('b = $1', 555), sql('c = $1', 666))),
+        'SELECT * FROM tbl WHERE a = $1 OR b = $2 OR c = $3',
+        [444, 555, 666]);
+    });
   });
 
   describe('value handling', function() {
@@ -119,16 +189,24 @@ describe('SQL Bricks', function() {
       check(select().from('user').where(sql.val('Fred'), sql('first_name')),
         "SELECT * FROM \"user\" WHERE 'Fred' = first_name");
     });
+    it('should support value objects with differing field orders', function() {
+      check(insert('user').values([{id: 1, name: 'Fred'}, {name: 'Barney', id: 2}]),
+        "INSERT INTO \"user\" (id, name) VALUES (1, 'Fred'), (2, 'Barney')")
+    })
 
     describe('.toString() value conversions', function() {
-      it('should, by default, convert arrays to SQL Array syntax', function() {
-        check(update('user', {'name': ["Paul", "Muad'Dib"]}),
-          "UPDATE \"user\" SET name = {'Paul', 'Muad''Dib'}");
-      });
       it('should, by default, convert dates to SQL TIMESTAMP WITH TIME ZONE format', function() {
         check(update('user', {'birthdate': new Date('1980-01-01T00:00:00Z')}),
           "UPDATE \"user\" SET birthdate = TIMESTAMP WITH TIME ZONE '1980-01-01 00:00:00.000+00:00'");
       });
+      it('should work with sql() SQL literal strings', function() {
+        check(select().from('person').where(sql('some_func($, $)', ['a', 'b'])),
+          "SELECT * FROM person WHERE some_func('a', 'b')");
+      });
+      it('should escape single quotes when sql() SQL literal strings are used', function() {
+        check(select().from('person').where(sql('some_func($)', ["Muad'Dib"])),
+          "SELECT * FROM person WHERE some_func('Muad''Dib')");
+      });
       it('should support user-supplied conversions', function() {
         var orig_bool = sql.conversions.Boolean;
         sql.conversions.Boolean = function(bool) { return bool ? '1' : '0'; };
@@ -146,14 +224,14 @@ describe('SQL Bricks', function() {
 
   it('should expand left_tbl on all joins', function() {
     var left_tbls = [];
-    var orig = sql._joinCriteria;
-    sql._joinCriteria = function(left_tbl) {
+    var orig = sql.joinCriteria();
+    sql.joinCriteria(function(left_tbl) {
       left_tbls.push(left_tbl);
       return orig.apply(this, arguments);
-    };
+    });
 
     select().from('test').join('psn').join('usr').toString();
-    sql._joinCriteria = orig;
+    sql.joinCriteria(orig);
     assert(left_tbls.indexOf('person') > -1 && left_tbls.indexOf('psn') == -1, 'left_tbl is not expanded: [' + left_tbls.join(',') + ']');
   });
 
@@ -229,25 +307,9 @@ describe('SQL Bricks', function() {
       check(update('user', {'name': 'Fred'}),
         "UPDATE \"user\" SET name = 'Fred'");
     });
-    it('should handle OR REPLACE (sqlite dialect)', function() {
-      check(update('user').orReplace().set({'name': 'Fred', 'id': 33}),
-        "UPDATE OR REPLACE \"user\" SET name = 'Fred', id = 33");
-    });
-    it('should handle RETURNING (postgres dialect)', function() {
-      check(update('user').set({'fname': 'Fred'}).where({'lname': 'Flintstone'}).returning('*'),
-        "UPDATE \"user\" SET fname = 'Fred' WHERE lname = 'Flintstone' RETURNING *");
-    });
   });
 
   describe('INSERT statements', function() {
-    it('should handle OR REPLACE (sqlite dialect)', function() {
-      check(insert().orReplace().into('user').values({'id': 33, 'name': 'Fred'}),
-        "INSERT OR REPLACE INTO \"user\" (id, name) VALUES (33, 'Fred')");
-    });
-    it('should handle RETURNING (postgres dialect)', function() {
-      check(insert('user').values({'fname': 'Fred'}).returning('*'),
-        "INSERT INTO \"user\" (fname) VALUES ('Fred') RETURNING *");
-    });
     it('should take an object of column/value pairs', function() {
       check(insert('user', {'id': 33, 'name': 'Fred'}),
         "INSERT INTO \"user\" (id, name) VALUES (33, 'Fred')");
@@ -322,12 +384,16 @@ describe('SQL Bricks', function() {
         'SELECT DISTINCT one, "order", two, "desc" FROM "user"');
     });
     it('should support FOR UPDATE', function() {
-      check(select().from('user').forUpdate('user'),
-        'SELECT * FROM "user" FOR UPDATE "user"');
+      check(select().from('user').forUpdate(),
+        'SELECT * FROM "user" FOR UPDATE');
     });
-    it('should support FOR UPDATE ... NO WAIT', function() {
-      check(select().from('user').forUpdateOf('user').noWait(),
-        'SELECT * FROM "user" FOR UPDATE "user" NO WAIT');
+    it('should support FOR UPDATE w/ col list', function() {
+      check(select().from('user').forUpdate().of('user'),
+        'SELECT * FROM "user" FOR UPDATE OF "user"');
+    });
+    it('should support FOR UPDATE OF ... NOWAIT', function() {
+      check(select().from('user').forUpdate().of('user').noWait(),
+        'SELECT * FROM "user" FOR UPDATE OF "user" NOWAIT');
     });
   });
 
@@ -383,11 +449,21 @@ describe('SQL Bricks', function() {
         .select('id', 'addr_id').from('user'),
         'INSERT INTO new_user (id, addr_id) SELECT id, addr_id FROM "user"');
     });
+    it('insert().into().select() with no columns', function() {
+      check(insert().into('new_user')
+        .select('id', 'addr_id').from('user'),
+        'INSERT INTO new_user SELECT id, addr_id FROM "user"');
+    });
     it('insert().select()', function() {
       check(insert('new_user', 'id', 'addr_id')
         .select('id', 'addr_id').from('user'),
         'INSERT INTO new_user (id, addr_id) SELECT id, addr_id FROM "user"');
     });
+    it('insert().select() with params', function() {
+      check(insert('new_user', 'id', 'addr_id')
+        .select('id', 'addr_id').from('user').where({active: true}).toParams().text,
+        'INSERT INTO new_user (id, addr_id) SELECT id, addr_id FROM "user" WHERE active = $1');
+    });
   });
 
   describe('GROUP BY clause', function() {
@@ -464,15 +540,19 @@ describe('SQL Bricks', function() {
     it('.crossJoin() should generate a cross join', function() {
       check(select().from('usr').crossJoin('addr'),
         'SELECT * FROM "user" usr ' + 
-        'CROSS JOIN address addr ON usr.addr_fk = addr.pk');
+        'CROSS JOIN address addr');
     });
     it('join() should accept an expression for the on argument', function() {
       check(select().from('usr').join('addr', eq('usr.addr_id', sql('addr.id'))),
         'SELECT * FROM "user" usr INNER JOIN address addr ON usr.addr_id = addr.id');
     });
+    it('join() should accept an array for the on argument (for JOIN USING)', function() {
+      check(select().from('usr').join('addr', ['addr_id', 'country_id']),
+        'SELECT * FROM "user" usr INNER JOIN address addr USING (addr_id, country_id)');
+    });
   });
 
-  describe('on()', function() {
+  describe('.on()', function() {
     it('should accept an object literal', function() {
       check(select().from('usr').join('addr').on({'usr.addr_id': 'addr.id'}),
         'SELECT * FROM "user" usr ' + 
@@ -499,6 +579,73 @@ describe('SQL Bricks', function() {
       check(select().from('usr').join('addr').on(eq('usr.addr_id', sql('addr.id'))),
         'SELECT * FROM "user" usr INNER JOIN address addr ON usr.addr_id = addr.id');
     });
+    it('should not proceed if .using() has already been used', function() {
+      assert.throws(function () {
+        select().from('t1').join('t2').using('id').on({'t1.t2_id':'t2.id'});
+      });
+    });
+  });
+
+  describe('.using()', function() {
+    it('should accept a comma-delimited string', function() {
+      check(select().from('usr').join('addr').using('addr_id, contrived_id'),
+        'SELECT * FROM "user" usr ' + 
+        'INNER JOIN address addr USING (addr_id, contrived_id)');
+    });
+    it('should accept multiple arguments', function() {
+      check(select().from('usr').join('addr').using('addr_id', 'contrived_id'),
+        'SELECT * FROM "user" usr ' + 
+        'INNER JOIN address addr USING (addr_id, contrived_id)');
+    });
+    it('should accept an array literal', function() {
+      check(select().from('usr').join('addr').using(['addr_id', 'contrived_id']),
+        'SELECT * FROM "user" usr ' + 
+        'INNER JOIN address addr USING (addr_id, contrived_id)');
+    });
+    it('should not proceed if .on() has already been used', function() {
+      assert.throws(function () {
+        select().from('t1').join('t2').on({'t1.t2_id':'t2.id'}).using('id');
+      });
+    });
+  });
+
+  describe('natural joins', function() {
+    it('.naturalJoin() should accept a comma-delimited string', function() {
+      check(select().from('usr').naturalJoin('psn, addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL INNER JOIN person psn ' +
+        'NATURAL INNER JOIN address addr');
+    });
+    it('.naturalLeftJoin() should generate a natural left join', function() {
+      check(select().from('usr').naturalLeftJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL LEFT JOIN address addr');
+    });
+    it('.naturalLeftOuterJoin() should generate a natural left join', function() {
+      check(select().from('usr').naturalLeftOuterJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL LEFT JOIN address addr');
+    });
+    it('.naturalRightJoin() should generate a natural right join', function() {
+      check(select().from('usr').naturalRightJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL RIGHT JOIN address addr');
+    });
+    it('.naturalRightOuterJoin() should generate a natural right join', function() {
+      check(select().from('usr').naturalRightOuterJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL RIGHT JOIN address addr');
+    });
+    it('.naturalFullJoin() should generate a natural full join', function() {
+      check(select().from('usr').naturalFullJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL FULL JOIN address addr');
+    });
+    it('.naturalFullOuterJoin() should generate a natural full join', function() {
+      check(select().from('usr').naturalFullOuterJoin('addr'),
+        'SELECT * FROM "user" usr ' + 
+        'NATURAL FULL JOIN address addr');
+    });
   });
 
   describe('WHERE clauses', function() {
@@ -643,7 +790,7 @@ describe('SQL Bricks', function() {
         for (var col in criteria) {
           var val = criteria[col];
           var expr;
-          if (_.isArray(val))
+          if (val instanceof Array)
             expr = or(val.map(function(val) { return eq(col, val); }));
           else
             expr = eq(col, val);
@@ -651,24 +798,26 @@ describe('SQL Bricks', function() {
         }
         return where;
       }
-    });
-  });
 
-  describe('.limit()', function() {
-    it('should add a LIMIT clause', function() {
-      check(select().from('user').limit(10),
-        'SELECT * FROM "user" LIMIT 10');
-    });
-  });
+      it('should support converting expressions to string', function() {
+        check(and({ this: 'test' }, $in('that', [ 'v1', 'v2' ])),
+          "(this = 'test' AND that IN ('v1', 'v2'))");
+      });
 
-  describe('.offset()', function() {
-    it('should add an OFFSET clause', function() {
-      check(select().from('user').offset(10),
-        'SELECT * FROM "user" OFFSET 10');
-    });
-    it('should place OFFSET after LIMIT if both are supplied', function() {
-      check(select().from('user').offset(5).limit(10),
-        'SELECT * FROM "user" LIMIT 10 OFFSET 5');
+      it('should support raw sql blocks in expressions', function() {
+        check(and({ this: 'test' }, sql('field is null')),
+          "(this = 'test' AND field is null)");
+      });
+
+      it('should support converting ?-parameterized sql blocks to string', function() {
+        check(sql('field = ?', 123).toString({ placeholder: '?' }),
+          "field = 123");
+      });
+
+      it('should support converting default-parameterized sql blocks to string', function() {
+        check(sql('field = $1', 123),
+          "field = 123");
+      });
     });
   });
 
@@ -711,9 +860,13 @@ describe('SQL Bricks', function() {
       check(select('desc').from('usr'),
         'SELECT "desc" FROM "user" usr');
     });
-    it('in JOINs', function() {
+    it('in JOIN ONs', function() {
       check(select().from('usr').join('psn', {'usr.order': 'psn.order'}),
-        'SELECT * FROM "user" usr INNER JOIN person psn ON usr."order" = psn."order"')
+        'SELECT * FROM "user" usr INNER JOIN person psn ON usr."order" = psn."order"');
+    });
+    it('in JOIN USINGs', function() {
+      check(select().from('usr').join('psn').using('order'),
+        'SELECT * FROM "user" usr INNER JOIN person psn USING ("order")');
     });
     it('in INSERT', function() {
       check(insert('user').values({'order': 1}),
@@ -779,6 +932,11 @@ describe('SQL Bricks', function() {
       ins.clone().values({'last_name': 'Flintstone'});
       check(ins, "INSERT INTO \"user\" (first_name) VALUES ('Fred')");
     });
+    it('should clone $in subqueries', function() {
+      var sel = select().from('user').where($in('first_name', select('first_name').from('user')));
+      sel.clone().where('last_name', 'Flintstone');
+      check(sel, "SELECT * FROM \"user\" WHERE first_name IN (SELECT first_name FROM \"user\")");
+    });
   });
 
   describe('the AS keyword', function() {
@@ -801,12 +959,39 @@ describe('SQL Bricks', function() {
       check(del('user').where('first_name', 'Fred'),
         "DELETE FROM \"user\" WHERE first_name = 'Fred'")
     });
-    it('should generate a DELETE with using', function() {
-      check(del('user').using('addr').where('user.addr_fk', sql('addr.pk')),
-        "DELETE FROM \"user\" USING address addr WHERE \"user\".addr_fk = addr.pk");
+  });
+
+  describe('_extension()', function() {
+    it('should shield base', function() {
+      var ext = sql._extension();
+
+      ext.prop = 1;
+      assert.equal(sql.prop, undefined);
+
+      ext.select.prop = 1;
+      assert.equal(sql.select.returning, undefined);
+
+      assert(ext.select.prototype.clauses !== sql.select.prototype.clauses)
     });
   });
+
+  describe('defineClause', function() {
+    // this extension mechanism is used by sql-bricks-postgres
+    it('should be able to inject clauses after other clauses', function() {
+      var Insert = sql.insert;
+      Insert.defineClause('returning', function(opts) {
+        return `RETURNING test_column`;
+      }, {after: 'values'});
+
+      check(insert('user', {'id': 33, 'name': 'Fred'}),
+        "INSERT INTO \"user\" (id, name) VALUES (33, 'Fred') RETURNING test_column");
+
+      // remove the newly-added clause, so subsequent INSERT tests won't fail
+      var ix = Insert.prototype.clauses.findIndex(clause => clause.clause_id == 'returning');
+      Insert.prototype.clauses.splice(ix, 1);
     });
+  })
+});
 
 function check(stmt, expected) {
   assert.equal(stmt.toString(), expected);
diff --git a/tests/underscore.js b/tests/underscore.js
deleted file mode 100644
index a12f0d9..0000000
--- a/tests/underscore.js
+++ /dev/null
@@ -1,1226 +0,0 @@
-//     Underscore.js 1.4.4
-//     http://underscorejs.org
-//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
-//     Underscore may be freely distributed under the MIT license.
-
-(function() {
-
-  // Baseline setup
-  // --------------
-
-  // Establish the root object, `window` in the browser, or `global` on the server.
-  var root = this;
-
-  // Save the previous value of the `_` variable.
-  var previousUnderscore = root._;
-
-  // Establish the object that gets returned to break out of a loop iteration.
-  var breaker = {};
-
-  // Save bytes in the minified (but not gzipped) version:
-  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
-
-  // Create quick reference variables for speed access to core prototypes.
-  var push             = ArrayProto.push,
-      slice            = ArrayProto.slice,
-      concat           = ArrayProto.concat,
-      toString         = ObjProto.toString,
-      hasOwnProperty   = ObjProto.hasOwnProperty;
-
-  // All **ECMAScript 5** native function implementations that we hope to use
-  // are declared here.
-  var
-    nativeForEach      = ArrayProto.forEach,
-    nativeMap          = ArrayProto.map,
-    nativeReduce       = ArrayProto.reduce,
-    nativeReduceRight  = ArrayProto.reduceRight,
-    nativeFilter       = ArrayProto.filter,
-    nativeEvery        = ArrayProto.every,
-    nativeSome         = ArrayProto.some,
-    nativeIndexOf      = ArrayProto.indexOf,
-    nativeLastIndexOf  = ArrayProto.lastIndexOf,
-    nativeIsArray      = Array.isArray,
-    nativeKeys         = Object.keys,
-    nativeBind         = FuncProto.bind;
-
-  // Create a safe reference to the Underscore object for use below.
-  var _ = function(obj) {
-    if (obj instanceof _) return obj;
-    if (!(this instanceof _)) return new _(obj);
-    this._wrapped = obj;
-  };
-
-  // Export the Underscore object for **Node.js**, with
-  // backwards-compatibility for the old `require()` API. If we're in
-  // the browser, add `_` as a global object via a string identifier,
-  // for Closure Compiler "advanced" mode.
-  if (typeof exports !== 'undefined') {
-    if (typeof module !== 'undefined' && module.exports) {
-      exports = module.exports = _;
-    }
-    exports._ = _;
-  } else {
-    root._ = _;
-  }
-
-  // Current version.
-  _.VERSION = '1.4.4';
-
-  // Collection Functions
-  // --------------------
-
-  // The cornerstone, an `each` implementation, aka `forEach`.
-  // Handles objects with the built-in `forEach`, arrays, and raw objects.
-  // Delegates to **ECMAScript 5**'s native `forEach` if available.
-  var each = _.each = _.forEach = function(obj, iterator, context) {
-    if (obj == null) return;
-    if (nativeForEach && obj.forEach === nativeForEach) {
-      obj.forEach(iterator, context);
-    } else if (obj.length === +obj.length) {
-      for (var i = 0, l = obj.length; i < l; i++) {
-        if (iterator.call(context, obj[i], i, obj) === breaker) return;
-      }
-    } else {
-      for (var key in obj) {
-        if (_.has(obj, key)) {
-          if (iterator.call(context, obj[key], key, obj) === breaker) return;
-        }
-      }
-    }
-  };
-
-  // Return the results of applying the iterator to each element.
-  // Delegates to **ECMAScript 5**'s native `map` if available.
-  _.map = _.collect = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
-    each(obj, function(value, index, list) {
-      results[results.length] = iterator.call(context, value, index, list);
-    });
-    return results;
-  };
-
-  var reduceError = 'Reduce of empty array with no initial value';
-
-  // **Reduce** builds up a single result from a list of values, aka `inject`,
-  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
-  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
-    var initial = arguments.length > 2;
-    if (obj == null) obj = [];
-    if (nativeReduce && obj.reduce === nativeReduce) {
-      if (context) iterator = _.bind(iterator, context);
-      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
-    }
-    each(obj, function(value, index, list) {
-      if (!initial) {
-        memo = value;
-        initial = true;
-      } else {
-        memo = iterator.call(context, memo, value, index, list);
-      }
-    });
-    if (!initial) throw new TypeError(reduceError);
-    return memo;
-  };
-
-  // The right-associative version of reduce, also known as `foldr`.
-  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
-  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
-    var initial = arguments.length > 2;
-    if (obj == null) obj = [];
-    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
-      if (context) iterator = _.bind(iterator, context);
-      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
-    }
-    var length = obj.length;
-    if (length !== +length) {
-      var keys = _.keys(obj);
-      length = keys.length;
-    }
-    each(obj, function(value, index, list) {
-      index = keys ? keys[--length] : --length;
-      if (!initial) {
-        memo = obj[index];
-        initial = true;
-      } else {
-        memo = iterator.call(context, memo, obj[index], index, list);
-      }
-    });
-    if (!initial) throw new TypeError(reduceError);
-    return memo;
-  };
-
-  // Return the first value which passes a truth test. Aliased as `detect`.
-  _.find = _.detect = function(obj, iterator, context) {
-    var result;
-    any(obj, function(value, index, list) {
-      if (iterator.call(context, value, index, list)) {
-        result = value;
-        return true;
-      }
-    });
-    return result;
-  };
-
-  // Return all the elements that pass a truth test.
-  // Delegates to **ECMAScript 5**'s native `filter` if available.
-  // Aliased as `select`.
-  _.filter = _.select = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
-    each(obj, function(value, index, list) {
-      if (iterator.call(context, value, index, list)) results[results.length] = value;
-    });
-    return results;
-  };
-
-  // Return all the elements for which a truth test fails.
-  _.reject = function(obj, iterator, context) {
-    return _.filter(obj, function(value, index, list) {
-      return !iterator.call(context, value, index, list);
-    }, context);
-  };
-
-  // Determine whether all of the elements match a truth test.
-  // Delegates to **ECMAScript 5**'s native `every` if available.
-  // Aliased as `all`.
-  _.every = _.all = function(obj, iterator, context) {
-    iterator || (iterator = _.identity);
-    var result = true;
-    if (obj == null) return result;
-    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
-    each(obj, function(value, index, list) {
-      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
-    });
-    return !!result;
-  };
-
-  // Determine if at least one element in the object matches a truth test.
-  // Delegates to **ECMAScript 5**'s native `some` if available.
-  // Aliased as `any`.
-  var any = _.some = _.any = function(obj, iterator, context) {
-    iterator || (iterator = _.identity);
-    var result = false;
-    if (obj == null) return result;
-    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
-    each(obj, function(value, index, list) {
-      if (result || (result = iterator.call(context, value, index, list))) return breaker;
-    });
-    return !!result;
-  };
-
-  // Determine if the array or object contains a given value (using `===`).
-  // Aliased as `include`.
-  _.contains = _.include = function(obj, target) {
-    if (obj == null) return false;
-    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
-    return any(obj, function(value) {
-      return value === target;
-    });
-  };
-
-  // Invoke a method (with arguments) on every item in a collection.
-  _.invoke = function(obj, method) {
-    var args = slice.call(arguments, 2);
-    var isFunc = _.isFunction(method);
-    return _.map(obj, function(value) {
-      return (isFunc ? method : value[method]).apply(value, args);
-    });
-  };
-
-  // Convenience version of a common use case of `map`: fetching a property.
-  _.pluck = function(obj, key) {
-    return _.map(obj, function(value){ return value[key]; });
-  };
-
-  // Convenience version of a common use case of `filter`: selecting only objects
-  // containing specific `key:value` pairs.
-  _.where = function(obj, attrs, first) {
-    if (_.isEmpty(attrs)) return first ? null : [];
-    return _[first ? 'find' : 'filter'](obj, function(value) {
-      for (var key in attrs) {
-        if (attrs[key] !== value[key]) return false;
-      }
-      return true;
-    });
-  };
-
-  // Convenience version of a common use case of `find`: getting the first object
-  // containing specific `key:value` pairs.
-  _.findWhere = function(obj, attrs) {
-    return _.where(obj, attrs, true);
-  };
-
-  // Return the maximum element or (element-based computation).
-  // Can't optimize arrays of integers longer than 65,535 elements.
-  // See: https://bugs.webkit.org/show_bug.cgi?id=80797
-  _.max = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
-      return Math.max.apply(Math, obj);
-    }
-    if (!iterator && _.isEmpty(obj)) return -Infinity;
-    var result = {computed : -Infinity, value: -Infinity};
-    each(obj, function(value, index, list) {
-      var computed = iterator ? iterator.call(context, value, index, list) : value;
-      computed >= result.computed && (result = {value : value, computed : computed});
-    });
-    return result.value;
-  };
-
-  // Return the minimum element (or element-based computation).
-  _.min = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
-      return Math.min.apply(Math, obj);
-    }
-    if (!iterator && _.isEmpty(obj)) return Infinity;
-    var result = {computed : Infinity, value: Infinity};
-    each(obj, function(value, index, list) {
-      var computed = iterator ? iterator.call(context, value, index, list) : value;
-      computed < result.computed && (result = {value : value, computed : computed});
-    });
-    return result.value;
-  };
-
-  // Shuffle an array.
-  _.shuffle = function(obj) {
-    var rand;
-    var index = 0;
-    var shuffled = [];
-    each(obj, function(value) {
-      rand = _.random(index++);
-      shuffled[index - 1] = shuffled[rand];
-      shuffled[rand] = value;
-    });
-    return shuffled;
-  };
-
-  // An internal function to generate lookup iterators.
-  var lookupIterator = function(value) {
-    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
-  };
-
-  // Sort the object's values by a criterion produced by an iterator.
-  _.sortBy = function(obj, value, context) {
-    var iterator = lookupIterator(value);
-    return _.pluck(_.map(obj, function(value, index, list) {
-      return {
-        value : value,
-        index : index,
-        criteria : iterator.call(context, value, index, list)
-      };
-    }).sort(function(left, right) {
-      var a = left.criteria;
-      var b = right.criteria;
-      if (a !== b) {
-        if (a > b || a === void 0) return 1;
-        if (a < b || b === void 0) return -1;
-      }
-      return left.index < right.index ? -1 : 1;
-    }), 'value');
-  };
-
-  // An internal function used for aggregate "group by" operations.
-  var group = function(obj, value, context, behavior) {
-    var result = {};
-    var iterator = lookupIterator(value || _.identity);
-    each(obj, function(value, index) {
-      var key = iterator.call(context, value, index, obj);
-      behavior(result, key, value);
-    });
-    return result;
-  };
-
-  // Groups the object's values by a criterion. Pass either a string attribute
-  // to group by, or a function that returns the criterion.
-  _.groupBy = function(obj, value, context) {
-    return group(obj, value, context, function(result, key, value) {
-      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
-    });
-  };
-
-  // Counts instances of an object that group by a certain criterion. Pass
-  // either a string attribute to count by, or a function that returns the
-  // criterion.
-  _.countBy = function(obj, value, context) {
-    return group(obj, value, context, function(result, key) {
-      if (!_.has(result, key)) result[key] = 0;
-      result[key]++;
-    });
-  };
-
-  // Use a comparator function to figure out the smallest index at which
-  // an object should be inserted so as to maintain order. Uses binary search.
-  _.sortedIndex = function(array, obj, iterator, context) {
-    iterator = iterator == null ? _.identity : lookupIterator(iterator);
-    var value = iterator.call(context, obj);
-    var low = 0, high = array.length;
-    while (low < high) {
-      var mid = (low + high) >>> 1;
-      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
-    }
-    return low;
-  };
-
-  // Safely convert anything iterable into a real, live array.
-  _.toArray = function(obj) {
-    if (!obj) return [];
-    if (_.isArray(obj)) return slice.call(obj);
-    if (obj.length === +obj.length) return _.map(obj, _.identity);
-    return _.values(obj);
-  };
-
-  // Return the number of elements in an object.
-  _.size = function(obj) {
-    if (obj == null) return 0;
-    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
-  };
-
-  // Array Functions
-  // ---------------
-
-  // Get the first element of an array. Passing **n** will return the first N
-  // values in the array. Aliased as `head` and `take`. The **guard** check
-  // allows it to work with `_.map`.
-  _.first = _.head = _.take = function(array, n, guard) {
-    if (array == null) return void 0;
-    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
-  };
-
-  // Returns everything but the last entry of the array. Especially useful on
-  // the arguments object. Passing **n** will return all the values in
-  // the array, excluding the last N. The **guard** check allows it to work with
-  // `_.map`.
-  _.initial = function(array, n, guard) {
-    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
-  };
-
-  // Get the last element of an array. Passing **n** will return the last N
-  // values in the array. The **guard** check allows it to work with `_.map`.
-  _.last = function(array, n, guard) {
-    if (array == null) return void 0;
-    if ((n != null) && !guard) {
-      return slice.call(array, Math.max(array.length - n, 0));
-    } else {
-      return array[array.length - 1];
-    }
-  };
-
-  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
-  // Especially useful on the arguments object. Passing an **n** will return
-  // the rest N values in the array. The **guard**
-  // check allows it to work with `_.map`.
-  _.rest = _.tail = _.drop = function(array, n, guard) {
-    return slice.call(array, (n == null) || guard ? 1 : n);
-  };
-
-  // Trim out all falsy values from an array.
-  _.compact = function(array) {
-    return _.filter(array, _.identity);
-  };
-
-  // Internal implementation of a recursive `flatten` function.
-  var flatten = function(input, shallow, output) {
-    each(input, function(value) {
-      if (_.isArray(value)) {
-        shallow ? push.apply(output, value) : flatten(value, shallow, output);
-      } else {
-        output.push(value);
-      }
-    });
-    return output;
-  };
-
-  // Return a completely flattened version of an array.
-  _.flatten = function(array, shallow) {
-    return flatten(array, shallow, []);
-  };
-
-  // Return a version of the array that does not contain the specified value(s).
-  _.without = function(array) {
-    return _.difference(array, slice.call(arguments, 1));
-  };
-
-  // Produce a duplicate-free version of the array. If the array has already
-  // been sorted, you have the option of using a faster algorithm.
-  // Aliased as `unique`.
-  _.uniq = _.unique = function(array, isSorted, iterator, context) {
-    if (_.isFunction(isSorted)) {
-      context = iterator;
-      iterator = isSorted;
-      isSorted = false;
-    }
-    var initial = iterator ? _.map(array, iterator, context) : array;
-    var results = [];
-    var seen = [];
-    each(initial, function(value, index) {
-      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
-        seen.push(value);
-        results.push(array[index]);
-      }
-    });
-    return results;
-  };
-
-  // Produce an array that contains the union: each distinct element from all of
-  // the passed-in arrays.
-  _.union = function() {
-    return _.uniq(concat.apply(ArrayProto, arguments));
-  };
-
-  // Produce an array that contains every item shared between all the
-  // passed-in arrays.
-  _.intersection = function(array) {
-    var rest = slice.call(arguments, 1);
-    return _.filter(_.uniq(array), function(item) {
-      return _.every(rest, function(other) {
-        return _.indexOf(other, item) >= 0;
-      });
-    });
-  };
-
-  // Take the difference between one array and a number of other arrays.
-  // Only the elements present in just the first array will remain.
-  _.difference = function(array) {
-    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
-    return _.filter(array, function(value){ return !_.contains(rest, value); });
-  };
-
-  // Zip together multiple lists into a single array -- elements that share
-  // an index go together.
-  _.zip = function() {
-    var args = slice.call(arguments);
-    var length = _.max(_.pluck(args, 'length'));
-    var results = new Array(length);
-    for (var i = 0; i < length; i++) {
-      results[i] = _.pluck(args, "" + i);
-    }
-    return results;
-  };
-
-  // Converts lists into objects. Pass either a single array of `[key, value]`
-  // pairs, or two parallel arrays of the same length -- one of keys, and one of
-  // the corresponding values.
-  _.object = function(list, values) {
-    if (list == null) return {};
-    var result = {};
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (values) {
-        result[list[i]] = values[i];
-      } else {
-        result[list[i][0]] = list[i][1];
-      }
-    }
-    return result;
-  };
-
-  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
-  // we need this function. Return the position of the first occurrence of an
-  // item in an array, or -1 if the item is not included in the array.
-  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
-  // If the array is large and already in sort order, pass `true`
-  // for **isSorted** to use binary search.
-  _.indexOf = function(array, item, isSorted) {
-    if (array == null) return -1;
-    var i = 0, l = array.length;
-    if (isSorted) {
-      if (typeof isSorted == 'number') {
-        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
-      } else {
-        i = _.sortedIndex(array, item);
-        return array[i] === item ? i : -1;
-      }
-    }
-    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
-    for (; i < l; i++) if (array[i] === item) return i;
-    return -1;
-  };
-
-  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
-  _.lastIndexOf = function(array, item, from) {
-    if (array == null) return -1;
-    var hasIndex = from != null;
-    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
-      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
-    }
-    var i = (hasIndex ? from : array.length);
-    while (i--) if (array[i] === item) return i;
-    return -1;
-  };
-
-  // Generate an integer Array containing an arithmetic progression. A port of
-  // the native Python `range()` function. See
-  // [the Python documentation](http://docs.python.org/library/functions.html#range).
-  _.range = function(start, stop, step) {
-    if (arguments.length <= 1) {
-      stop = start || 0;
-      start = 0;
-    }
-    step = arguments[2] || 1;
-
-    var len = Math.max(Math.ceil((stop - start) / step), 0);
-    var idx = 0;
-    var range = new Array(len);
-
-    while(idx < len) {
-      range[idx++] = start;
-      start += step;
-    }
-
-    return range;
-  };
-
-  // Function (ahem) Functions
-  // ------------------
-
-  // Create a function bound to a given object (assigning `this`, and arguments,
-  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
-  // available.
-  _.bind = function(func, context) {
-    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
-    var args = slice.call(arguments, 2);
-    return function() {
-      return func.apply(context, args.concat(slice.call(arguments)));
-    };
-  };
-
-  // Partially apply a function by creating a version that has had some of its
-  // arguments pre-filled, without changing its dynamic `this` context.
-  _.partial = function(func) {
-    var args = slice.call(arguments, 1);
-    return function() {
-      return func.apply(this, args.concat(slice.call(arguments)));
-    };
-  };
-
-  // Bind all of an object's methods to that object. Useful for ensuring that
-  // all callbacks defined on an object belong to it.
-  _.bindAll = function(obj) {
-    var funcs = slice.call(arguments, 1);
-    if (funcs.length === 0) funcs = _.functions(obj);
-    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
-    return obj;
-  };
-
-  // Memoize an expensive function by storing its results.
-  _.memoize = function(func, hasher) {
-    var memo = {};
-    hasher || (hasher = _.identity);
-    return function() {
-      var key = hasher.apply(this, arguments);
-      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
-    };
-  };
-
-  // Delays a function for the given number of milliseconds, and then calls
-  // it with the arguments supplied.
-  _.delay = function(func, wait) {
-    var args = slice.call(arguments, 2);
-    return setTimeout(function(){ return func.apply(null, args); }, wait);
-  };
-
-  // Defers a function, scheduling it to run after the current call stack has
-  // cleared.
-  _.defer = function(func) {
-    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
-  };
-
-  // Returns a function, that, when invoked, will only be triggered at most once
-  // during a given window of time.
-  _.throttle = function(func, wait) {
-    var context, args, timeout, result;
-    var previous = 0;
-    var later = function() {
-      previous = new Date;
-      timeout = null;
-      result = func.apply(context, args);
-    };
-    return function() {
-      var now = new Date;
-      var remaining = wait - (now - previous);
-      context = this;
-      args = arguments;
-      if (remaining <= 0) {
-        clearTimeout(timeout);
-        timeout = null;
-        previous = now;
-        result = func.apply(context, args);
-      } else if (!timeout) {
-        timeout = setTimeout(later, remaining);
-      }
-      return result;
-    };
-  };
-
-  // Returns a function, that, as long as it continues to be invoked, will not
-  // be triggered. The function will be called after it stops being called for
-  // N milliseconds. If `immediate` is passed, trigger the function on the
-  // leading edge, instead of the trailing.
-  _.debounce = function(func, wait, immediate) {
-    var timeout, result;
-    return function() {
-      var context = this, args = arguments;
-      var later = function() {
-        timeout = null;
-        if (!immediate) result = func.apply(context, args);
-      };
-      var callNow = immediate && !timeout;
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-      if (callNow) result = func.apply(context, args);
-      return result;
-    };
-  };
-
-  // Returns a function that will be executed at most one time, no matter how
-  // often you call it. Useful for lazy initialization.
-  _.once = function(func) {
-    var ran = false, memo;
-    return function() {
-      if (ran) return memo;
-      ran = true;
-      memo = func.apply(this, arguments);
-      func = null;
-      return memo;
-    };
-  };
-
-  // Returns the first function passed as an argument to the second,
-  // allowing you to adjust arguments, run code before and after, and
-  // conditionally execute the original function.
-  _.wrap = function(func, wrapper) {
-    return function() {
-      var args = [func];
-      push.apply(args, arguments);
-      return wrapper.apply(this, args);
-    };
-  };
-
-  // Returns a function that is the composition of a list of functions, each
-  // consuming the return value of the function that follows.
-  _.compose = function() {
-    var funcs = arguments;
-    return function() {
-      var args = arguments;
-      for (var i = funcs.length - 1; i >= 0; i--) {
-        args = [funcs[i].apply(this, args)];
-      }
-      return args[0];
-    };
-  };
-
-  // Returns a function that will only be executed after being called N times.
-  _.after = function(times, func) {
-    if (times <= 0) return func();
-    return function() {
-      if (--times < 1) {
-        return func.apply(this, arguments);
-      }
-    };
-  };
-
-  // Object Functions
-  // ----------------
-
-  // Retrieve the names of an object's properties.
-  // Delegates to **ECMAScript 5**'s native `Object.keys`
-  _.keys = nativeKeys || function(obj) {
-    if (obj !== Object(obj)) throw new TypeError('Invalid object');
-    var keys = [];
-    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
-    return keys;
-  };
-
-  // Retrieve the values of an object's properties.
-  _.values = function(obj) {
-    var values = [];
-    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
-    return values;
-  };
-
-  // Convert an object into a list of `[key, value]` pairs.
-  _.pairs = function(obj) {
-    var pairs = [];
-    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
-    return pairs;
-  };
-
-  // Invert the keys and values of an object. The values must be serializable.
-  _.invert = function(obj) {
-    var result = {};
-    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
-    return result;
-  };
-
-  // Return a sorted list of the function names available on the object.
-  // Aliased as `methods`
-  _.functions = _.methods = function(obj) {
-    var names = [];
-    for (var key in obj) {
-      if (_.isFunction(obj[key])) names.push(key);
-    }
-    return names.sort();
-  };
-
-  // Extend a given object with all the properties in passed-in object(s).
-  _.extend = function(obj) {
-    each(slice.call(arguments, 1), function(source) {
-      if (source) {
-        for (var prop in source) {
-          obj[prop] = source[prop];
-        }
-      }
-    });
-    return obj;
-  };
-
-  // Return a copy of the object only containing the whitelisted properties.
-  _.pick = function(obj) {
-    var copy = {};
-    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
-    each(keys, function(key) {
-      if (key in obj) copy[key] = obj[key];
-    });
-    return copy;
-  };
-
-   // Return a copy of the object without the blacklisted properties.
-  _.omit = function(obj) {
-    var copy = {};
-    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
-    for (var key in obj) {
-      if (!_.contains(keys, key)) copy[key] = obj[key];
-    }
-    return copy;
-  };
-
-  // Fill in a given object with default properties.
-  _.defaults = function(obj) {
-    each(slice.call(arguments, 1), function(source) {
-      if (source) {
-        for (var prop in source) {
-          if (obj[prop] == null) obj[prop] = source[prop];
-        }
-      }
-    });
-    return obj;
-  };
-
-  // Create a (shallow-cloned) duplicate of an object.
-  _.clone = function(obj) {
-    if (!_.isObject(obj)) return obj;
-    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
-  };
-
-  // Invokes interceptor with the obj, and then returns obj.
-  // The primary purpose of this method is to "tap into" a method chain, in
-  // order to perform operations on intermediate results within the chain.
-  _.tap = function(obj, interceptor) {
-    interceptor(obj);
-    return obj;
-  };
-
-  // Internal recursive comparison function for `isEqual`.
-  var eq = function(a, b, aStack, bStack) {
-    // Identical objects are equal. `0 === -0`, but they aren't identical.
-    // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
-    if (a === b) return a !== 0 || 1 / a == 1 / b;
-    // A strict comparison is necessary because `null == undefined`.
-    if (a == null || b == null) return a === b;
-    // Unwrap any wrapped objects.
-    if (a instanceof _) a = a._wrapped;
-    if (b instanceof _) b = b._wrapped;
-    // Compare `[[Class]]` names.
-    var className = toString.call(a);
-    if (className != toString.call(b)) return false;
-    switch (className) {
-      // Strings, numbers, dates, and booleans are compared by value.
-      case '[object String]':
-        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
-        // equivalent to `new String("5")`.
-        return a == String(b);
-      case '[object Number]':
-        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
-        // other numeric values.
-        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
-      case '[object Date]':
-      case '[object Boolean]':
-        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
-        // millisecond representations. Note that invalid dates with millisecond representations
-        // of `NaN` are not equivalent.
-        return +a == +b;
-      // RegExps are compared by their source patterns and flags.
-      case '[object RegExp]':
-        return a.source == b.source &&
-               a.global == b.global &&
-               a.multiline == b.multiline &&
-               a.ignoreCase == b.ignoreCase;
-    }
-    if (typeof a != 'object' || typeof b != 'object') return false;
-    // Assume equality for cyclic structures. The algorithm for detecting cyclic
-    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
-    var length = aStack.length;
-    while (length--) {
-      // Linear search. Performance is inversely proportional to the number of
-      // unique nested structures.
-      if (aStack[length] == a) return bStack[length] == b;
-    }
-    // Add the first object to the stack of traversed objects.
-    aStack.push(a);
-    bStack.push(b);
-    var size = 0, result = true;
-    // Recursively compare objects and arrays.
-    if (className == '[object Array]') {
-      // Compare array lengths to determine if a deep comparison is necessary.
-      size = a.length;
-      result = size == b.length;
-      if (result) {
-        // Deep compare the contents, ignoring non-numeric properties.
-        while (size--) {
-          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
-        }
-      }
-    } else {
-      // Objects with different constructors are not equivalent, but `Object`s
-      // from different frames are.
-      var aCtor = a.constructor, bCtor = b.constructor;
-      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
-                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
-        return false;
-      }
-      // Deep compare objects.
-      for (var key in a) {
-        if (_.has(a, key)) {
-          // Count the expected number of properties.
-          size++;
-          // Deep compare each member.
-          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
-        }
-      }
-      // Ensure that both objects contain the same number of properties.
-      if (result) {
-        for (key in b) {
-          if (_.has(b, key) && !(size--)) break;
-        }
-        result = !size;
-      }
-    }
-    // Remove the first object from the stack of traversed objects.
-    aStack.pop();
-    bStack.pop();
-    return result;
-  };
-
-  // Perform a deep comparison to check if two objects are equal.
-  _.isEqual = function(a, b) {
-    return eq(a, b, [], []);
-  };
-
-  // Is a given array, string, or object empty?
-  // An "empty" object has no enumerable own-properties.
-  _.isEmpty = function(obj) {
-    if (obj == null) return true;
-    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
-    for (var key in obj) if (_.has(obj, key)) return false;
-    return true;
-  };
-
-  // Is a given value a DOM element?
-  _.isElement = function(obj) {
-    return !!(obj && obj.nodeType === 1);
-  };
-
-  // Is a given value an array?
-  // Delegates to ECMA5's native Array.isArray
-  _.isArray = nativeIsArray || function(obj) {
-    return toString.call(obj) == '[object Array]';
-  };
-
-  // Is a given variable an object?
-  _.isObject = function(obj) {
-    return obj === Object(obj);
-  };
-
-  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
-  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
-    _['is' + name] = function(obj) {
-      return toString.call(obj) == '[object ' + name + ']';
-    };
-  });
-
-  // Define a fallback version of the method in browsers (ahem, IE), where
-  // there isn't any inspectable "Arguments" type.
-  if (!_.isArguments(arguments)) {
-    _.isArguments = function(obj) {
-      return !!(obj && _.has(obj, 'callee'));
-    };
-  }
-
-  // Optimize `isFunction` if appropriate.
-  if (typeof (/./) !== 'function') {
-    _.isFunction = function(obj) {
-      return typeof obj === 'function';
-    };
-  }
-
-  // Is a given object a finite number?
-  _.isFinite = function(obj) {
-    return isFinite(obj) && !isNaN(parseFloat(obj));
-  };
-
-  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
-  _.isNaN = function(obj) {
-    return _.isNumber(obj) && obj != +obj;
-  };
-
-  // Is a given value a boolean?
-  _.isBoolean = function(obj) {
-    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
-  };
-
-  // Is a given value equal to null?
-  _.isNull = function(obj) {
-    return obj === null;
-  };
-
-  // Is a given variable undefined?
-  _.isUndefined = function(obj) {
-    return obj === void 0;
-  };
-
-  // Shortcut function for checking if an object has a given property directly
-  // on itself (in other words, not on a prototype).
-  _.has = function(obj, key) {
-    return hasOwnProperty.call(obj, key);
-  };
-
-  // Utility Functions
-  // -----------------
-
-  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
-  // previous owner. Returns a reference to the Underscore object.
-  _.noConflict = function() {
-    root._ = previousUnderscore;
-    return this;
-  };
-
-  // Keep the identity function around for default iterators.
-  _.identity = function(value) {
-    return value;
-  };
-
-  // Run a function **n** times.
-  _.times = function(n, iterator, context) {
-    var accum = Array(n);
-    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
-    return accum;
-  };
-
-  // Return a random integer between min and max (inclusive).
-  _.random = function(min, max) {
-    if (max == null) {
-      max = min;
-      min = 0;
-    }
-    return min + Math.floor(Math.random() * (max - min + 1));
-  };
-
-  // List of HTML entities for escaping.
-  var entityMap = {
-    escape: {
-      '&': '&amp;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      "'": '&#x27;',
-      '/': '&#x2F;'
-    }
-  };
-  entityMap.unescape = _.invert(entityMap.escape);
-
-  // Regexes containing the keys and values listed immediately above.
-  var entityRegexes = {
-    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
-    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
-  };
-
-  // Functions for escaping and unescaping strings to/from HTML interpolation.
-  _.each(['escape', 'unescape'], function(method) {
-    _[method] = function(string) {
-      if (string == null) return '';
-      return ('' + string).replace(entityRegexes[method], function(match) {
-        return entityMap[method][match];
-      });
-    };
-  });
-
-  // If the value of the named property is a function then invoke it;
-  // otherwise, return it.
-  _.result = function(object, property) {
-    if (object == null) return null;
-    var value = object[property];
-    return _.isFunction(value) ? value.call(object) : value;
-  };
-
-  // Add your own custom functions to the Underscore object.
-  _.mixin = function(obj) {
-    each(_.functions(obj), function(name){
-      var func = _[name] = obj[name];
-      _.prototype[name] = function() {
-        var args = [this._wrapped];
-        push.apply(args, arguments);
-        return result.call(this, func.apply(_, args));
-      };
-    });
-  };
-
-  // Generate a unique integer id (unique within the entire client session).
-  // Useful for temporary DOM ids.
-  var idCounter = 0;
-  _.uniqueId = function(prefix) {
-    var id = ++idCounter + '';
-    return prefix ? prefix + id : id;
-  };
-
-  // By default, Underscore uses ERB-style template delimiters, change the
-  // following template settings to use alternative delimiters.
-  _.templateSettings = {
-    evaluate    : /<%([\s\S]+?)%>/g,
-    interpolate : /<%=([\s\S]+?)%>/g,
-    escape      : /<%-([\s\S]+?)%>/g
-  };
-
-  // When customizing `templateSettings`, if you don't want to define an
-  // interpolation, evaluation or escaping regex, we need one that is
-  // guaranteed not to match.
-  var noMatch = /(.)^/;
-
-  // Certain characters need to be escaped so that they can be put into a
-  // string literal.
-  var escapes = {
-    "'":      "'",
-    '\\':     '\\',
-    '\r':     'r',
-    '\n':     'n',
-    '\t':     't',
-    '\u2028': 'u2028',
-    '\u2029': 'u2029'
-  };
-
-  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
-
-  // JavaScript micro-templating, similar to John Resig's implementation.
-  // Underscore templating handles arbitrary delimiters, preserves whitespace,
-  // and correctly escapes quotes within interpolated code.
-  _.template = function(text, data, settings) {
-    var render;
-    settings = _.defaults({}, settings, _.templateSettings);
-
-    // Combine delimiters into one regular expression via alternation.
-    var matcher = new RegExp([
-      (settings.escape || noMatch).source,
-      (settings.interpolate || noMatch).source,
-      (settings.evaluate || noMatch).source
-    ].join('|') + '|$', 'g');
-
-    // Compile the template source, escaping string literals appropriately.
-    var index = 0;
-    var source = "__p+='";
-    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
-      source += text.slice(index, offset)
-        .replace(escaper, function(match) { return '\\' + escapes[match]; });
-
-      if (escape) {
-        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
-      }
-      if (interpolate) {
-        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
-      }
-      if (evaluate) {
-        source += "';\n" + evaluate + "\n__p+='";
-      }
-      index = offset + match.length;
-      return match;
-    });
-    source += "';\n";
-
-    // If a variable is not specified, place data values in local scope.
-    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
-
-    source = "var __t,__p='',__j=Array.prototype.join," +
-      "print=function(){__p+=__j.call(arguments,'');};\n" +
-      source + "return __p;\n";
-
-    try {
-      render = new Function(settings.variable || 'obj', '_', source);
-    } catch (e) {
-      e.source = source;
-      throw e;
-    }
-
-    if (data) return render(data, _);
-    var template = function(data) {
-      return render.call(this, data, _);
-    };
-
-    // Provide the compiled function source as a convenience for precompilation.
-    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
-
-    return template;
-  };
-
-  // Add a "chain" function, which will delegate to the wrapper.
-  _.chain = function(obj) {
-    return _(obj).chain();
-  };
-
-  // OOP
-  // ---------------
-  // If Underscore is called as a function, it returns a wrapped object that
-  // can be used OO-style. This wrapper holds altered versions of all the
-  // underscore functions. Wrapped objects may be chained.
-
-  // Helper function to continue chaining intermediate results.
-  var result = function(obj) {
-    return this._chain ? _(obj).chain() : obj;
-  };
-
-  // Add all of the Underscore functions to the wrapper object.
-  _.mixin(_);
-
-  // Add all mutator Array functions to the wrapper.
-  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
-    var method = ArrayProto[name];
-    _.prototype[name] = function() {
-      var obj = this._wrapped;
-      method.apply(obj, arguments);
-      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
-      return result.call(this, obj);
-    };
-  });
-
-  // Add all accessor Array functions to the wrapper.
-  each(['concat', 'join', 'slice'], function(name) {
-    var method = ArrayProto[name];
-    _.prototype[name] = function() {
-      return result.call(this, method.apply(this._wrapped, arguments));
-    };
-  });
-
-  _.extend(_.prototype, {
-
-    // Start chaining a wrapped Underscore object.
-    chain: function() {
-      this._chain = true;
-      return this;
-    },
-
-    // Extracts the result from a wrapped and chained object.
-    value: function() {
-      return this._wrapped;
-    }
-
-  });
-
-}).call(this);