diff --git a/README.md b/README.md
index aeb6f1c..b6e590f 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,8 @@
 [![Greenkeeper badge](https://badges.greenkeeper.io/andrejewski/himalaya.svg)](https://greenkeeper.io/)
 
 [Try online 🚀](http://andrejewski.github.io/himalaya)
+|
+[Read the specification 📖](https://github.com/andrejewski/himalaya/blob/master/text/ast-spec-v1.md)
 
 ## Usage
 
@@ -17,9 +19,10 @@ npm install himalaya
 ```
 
 ```js
-var himalaya = require('himalaya')
-var html = require('fs').readFileSync('/webpage.html', {encoding: 'utf8'})
-var json = himalaya.parse(html)
+import fs from 'fs'
+import {parse} from 'himalaya'
+const html = fs.readFileSync('/webpage.html', {encoding: 'utf8'})
+const json = parse(html)
 console.log('👉', json)
 ```
 
@@ -27,91 +30,23 @@ console.log('👉', json)
 Download [himalaya.js](https://github.com/andrejewski/himalaya/blob/master/docs/dist/himalaya.js) and put it in a `<script>` tag. Himalaya will be accessible from `window.himalaya`.
 
 ```js
-var html = '<div>Hello world</div>'
-var json = window.himalaya.parse(html)
+const html = '<div>Hello world</div>'
+const json = window.himalaya.parse(html)
 console.log('👉', json)
 ```
 
 Himalaya bundles well with Browersify and Webpack.
 
-### Command-line
-Himalaya includes a command-line tool.
-
-```bash
-npm install --global himalaya
-```
-
-```bash
-himalaya webpage.html webpage.json
-# or as a pipe
-echo "<h1>Hello</h1>" | himalaya > hello.json
-```
-
-Run `himalaya --help` for more information.
-
-## Parser AST Specification
-
-Himalaya has specifications for its output.
-
-- [Version 0](https://github.com/andrejewski/himalaya/blob/master/text/ast-spec-v0.md) – The original specification from 2015. The focus of this specification is developer convenience, processing and formatting special cases of attributes.
-- [Version 1 ](https://github.com/andrejewski/himalaya/blob/master/text/ast-spec-v1.md) – The specification that will become default when Himalaya hits v1. The focus of this specification is fixing the problems in Version 0, in particular removing lossy attribute processing.
-
-The Version 0 specification is the default. If interested, please try the Version 1 spec and report any bugs. To use Version 1, override the `format` option of the `himalaya.parse` function:
-
-```js
-const himalaya = require('himalaya')
-const format = require('himalaya/lib/format/v1').default
-const parseOptions = Object.assign({}, himalaya.parseDefaults, {format})
-const json = himalaya.parse('<p>Hello World</p>', parseOptions)
-console.log('👉', json)
-```
-
-Himalaya v1 will not support the Version 0 specification.
-
-### Example Input/Output
+## Example Input/Output
 
 ```html
 <div class='post post-featured'>
-	<p>Himalaya parsed me...</p>
-	<!-- ...and I liked it. -->
+  <p>Himalaya parsed me...</p>
+  <!-- ...and I liked it. -->
 </div>
 ```
 
 ```js
-// Version 0
-[
-  {
-    "type": "Element",
-    "tagName": "div",
-    "attributes": {
-      "className": [
-        "post",
-        "post-featured"
-      ]
-    },
-    "children": [
-      {
-        "type": "Element",
-        "tagName": "p",
-        "attributes": {},
-        "children": [
-          {
-            "type": "Text",
-            "content": "Himalaya parsed me..."
-          }
-        ]
-      },
-      {
-        "type": "Comment",
-        "content": " ...and I liked it. "
-      }
-    ]
-  }
-]
-```
-
-```js
-// Version 1
 [{
   type: 'element',
   tagName: 'div',
@@ -134,21 +69,13 @@ Himalaya v1 will not support the Version 0 specification.
 }]
 ```
 
-*Note:* Text nodes consisting of whitespace are not shown for readability.
+*Note:* In this example, text nodes consisting of whitespace are not shown for readability.
 
 ## Features
 
 ### Synchronous
 Himalaya transforms HTML into JSON, that's it. Himalaya is synchronous and does not require any complicated callbacks.
 
-### Parses Attributes
-Himalaya does a couple transformations when processing attributes:
-- Camel-cases attribute names
-- Attributes without values use their names as values. For example, `disabled` turns into `disabled="disabled"`
-- Groups `data-*` attributes into a `dataset` object
-- Attempts to cast any value to a number if `!Nan`
-- Parses the `style` attribute into a hash map
-
 ### Handles Weirdness
 Himalaya handles a lot of HTML's fringe cases, like:
 - Closes unclosed tags `<p><b>...</p>`
@@ -162,36 +89,19 @@ Himalaya handles a lot of HTML's fringe cases, like:
 Himalaya does not cut corners and returns an accurate representation of the HTML supplied. To remove whitespace, post-process the JSON; check out [an example script](https://gist.github.com/andrejewski/773487d4f4a46b16865405d7b74eabf9).
 
 ## Going back to HTML
-Himalaya provides translation functions that can take the Himalaya AST and output HTML and Pug.
-
-The following example does nothing. It parses the HTML to JSON then parses the JSON back into HTML, which is the exact same as the original. Himalaya does buff out the kinks of malformed originals.
+Himalaya provides a `stringify` method. The following example parses the HTML to JSON then parses the JSON back into HTML.
 
 ```js
-var fs = require('fs')
-var himalaya = require('himalaya')
-var toHTML = require('himalaya/translate').toHTML
+import fs from 'fs'
+import {parse, stringify} from 'himalaya'
 
-var html = fs.readFileSync('/webpage.html', {encoding: 'utf8'})
-var json = himalaya.parse(html)
-fs.writeFileSync('/webpage.html', toHTML(json))
+const html = fs.readFileSync('/webpage.html', {encoding: 'utf8'})
+const json = parse(html)
+fs.writeFileSync('/webpage.html', stringify(json))
 ```
 
-Version 0 translation supports [Pug](https://pugjs.org) using `toPug`. See the [reference document for translations](https://github.com/andrejewski/himalaya/tree/master/text/translation.md).
-
 ## Why "Himalaya"?
 
 [First, my friends weren't helpful.](https://twitter.com/compooter/status/597908517132042240) Except Josh, Josh had my back.
 
 While I was testing the parser, I threw a download of my Twitter homepage in and got a giant JSON blob out. My code editor Sublime Text has a mini-map and looking at it sideways the data looked like a never-ending mountain range. Also, "himalaya" has H, M, L in it.
-
-## Implementation
-
-My first implementation used look-ahead, found the matching closing tag, and then recursively parsed the inners until a tree results. That was problematic. This implementation uses no look-ahead and instead uses a stack to keep track of nesting while processing the source HTML. At an end tag the stack it cut to match and then parsing picks up again at the higher level.
-
-## Contributing
-
-We can always have more tests: if you find a bug, create an issue or be **fabulous** and fix the problem and write the tests up yourself in a coherent pull request.
-
-Run tests with the `npm test` command.
-
-Follow me on [Twitter](https://twitter.com/compooter) for updates or for the lolz and please check out my other [repositories](https://github.com/andrejewski) if I have earned it. I thank you for reading.
diff --git a/bin/himalaya.js b/bin/himalaya.js
deleted file mode 100644
index 8a9fbec..0000000
--- a/bin/himalaya.js
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-(function () {
-  function help () {
-/*
-    Usage: himalaya [file] [dest]
-
-    (no args):      pipe in HTML, pipe out JSON
-    file:           HTML file location
-    dest:           JSON file destination
-
-    -h, --help:     displays this
-    -v, --version:  prints himalaya's version
-
-    if dest is not provided, himalaya prints to stdout
-*/
-  }
-
-  var fs = require('fs')
-  var path = require('path')
-  var himalaya = require('..')
-
-  var args = process.argv.slice(2)
-  var root = process.cwd()
-
-  function toJSON (data) {
-    return JSON.stringify(data, null, 2)
-  }
-
-  if (!args.length) {
-    process.stdin.resume()
-    process.stdin.setEncoding('utf8')
-    process.stdin.on('data', function (text) {
-      var data = himalaya.parse(text)
-      var json = toJSON(data)
-      process.stdout.write(json)
-    })
-    process.stdin.on('end', function () {
-      process.exit(0)
-    })
-    return
-  }
-
-  var flag = args[0].toLowerCase()
-
-  if (flag === '-h' || flag === '--help') {
-    var h = help.toString()
-    var msg = h.substring(h.indexOf('*') + 2, h.lastIndexOf('*'))
-    return console.log(msg)
-  }
-
-  if (flag === '-v' || flag === '--version') {
-    var pkg = require('../package.json')
-    return console.log(pkg.version)
-  }
-
-  var src = path.join(root, args[0])
-  var dest = args[1]
-    ? path.join(root, args[1])
-    : null
-
-  var text = fs.readFileSync(src, {encoding: 'utf8'})
-  var data = himalaya.parse(text)
-  var cout = toJSON(data)
-
-  if (dest) {
-    fs.writeFileSync(dest, cout)
-  } else {
-    console.log(cout)
-  }
-})()
diff --git a/docs/dist/himalaya.js b/docs/dist/himalaya.js
index 62b7a73..0b9d5c1 100644
--- a/docs/dist/himalaya.js
+++ b/docs/dist/himalaya.js
@@ -52,13 +52,15 @@ function arrayIncludes(array, searchElement, position) {
 }
 
 },{}],2:[function(require,module,exports){
-"use strict";
+'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.splitHead = splitHead;
 exports.unquote = unquote;
+exports.format = format;
+exports.formatAttributes = formatAttributes;
 function splitHead(str, sep) {
   var idx = str.indexOf(sep);
   if (idx === -1) return [str];
@@ -75,33 +77,10 @@ function unquote(str) {
   return str;
 }
 
-},{}],3:[function(require,module,exports){
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /*
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           This format adheres to the v0 ASP spec.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         */
-
-
-exports.default = format;
-exports.capitalize = capitalize;
-exports.camelCase = camelCase;
-exports.castValue = castValue;
-exports.formatAttributes = formatAttributes;
-exports.formatStyles = formatStyles;
-
-var _compat = require('../compat');
-
-var _util = require('./util');
-
 function format(nodes) {
   return nodes.map(function (node) {
-    var type = capitalize(node.type);
-    if (type === 'Element') {
+    var type = node.type;
+    if (type === 'element') {
       var tagName = node.tagName.toLowerCase();
       var attributes = formatAttributes(node.attributes);
       var children = format(node.children);
@@ -112,65 +91,16 @@ function format(nodes) {
   });
 }
 
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-function camelCase(str) {
-  return str.split('-').reduce(function (str, word) {
-    return str + word.charAt(0).toUpperCase() + word.slice(1);
-  });
-}
-
-function castValue(str) {
-  if (typeof str !== 'string') return str;
-  if (str === '') return str;
-  var num = +str;
-  if (!isNaN(num)) return num;
-  return str;
-}
-
 function formatAttributes(attributes) {
-  return attributes.reduce(function (attrs, pair) {
-    var _splitHead = (0, _util.splitHead)(pair.trim(), '='),
-        _splitHead2 = _slicedToArray(_splitHead, 2),
-        key = _splitHead2[0],
-        value = _splitHead2[1];
-
-    value = value ? (0, _util.unquote)(value) : key;
-    if (key === 'class') {
-      attrs.className = value.split(' ');
-    } else if (key === 'style') {
-      attrs.style = formatStyles(value);
-    } else if ((0, _compat.startsWith)(key, 'data-')) {
-      attrs.dataset = attrs.dataset || {};
-      var prop = camelCase(key.slice(5));
-      attrs.dataset[prop] = castValue(value);
-    } else {
-      attrs[camelCase(key)] = castValue(value);
-    }
-    return attrs;
-  }, {});
-}
-
-function formatStyles(str) {
-  return str.trim().split(';').map(function (rule) {
-    return (0, _util.splitHead)(rule.trim(), ':');
-  }).reduce(function (styles, keyValue) {
-    var _keyValue = _slicedToArray(keyValue, 2),
-        rawKey = _keyValue[0],
-        rawValue = _keyValue[1];
-
-    if (rawValue) {
-      var key = camelCase(rawKey.trim());
-      var value = castValue(rawValue.trim());
-      styles[key] = value;
-    }
-    return styles;
-  }, {});
+  return attributes.map(function (attribute) {
+    var parts = splitHead(attribute.trim(), '=');
+    var key = parts[0];
+    var value = typeof parts[1] === 'string' ? unquote(parts[1]) : null;
+    return { key: key, value: value };
+  });
 }
 
-},{"../compat":1,"./util":2}],4:[function(require,module,exports){
+},{}],3:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -178,6 +108,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.parseDefaults = undefined;
 exports.parse = parse;
+exports.stringify = stringify;
 
 var _lexer = require('./lexer');
 
@@ -187,16 +118,15 @@ var _parser = require('./parser');
 
 var _parser2 = _interopRequireDefault(_parser);
 
-var _v = require('./formats/v0');
+var _format = require('./format');
 
-var _v2 = _interopRequireDefault(_v);
+var _stringify = require('./stringify');
 
 var _tags = require('./tags');
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var parseDefaults = exports.parseDefaults = {
-  format: _v2.default, // transform for v0 spec
   voidTags: _tags.voidTags,
   closingTags: _tags.closingTags,
   childlessTags: _tags.childlessTags,
@@ -208,12 +138,16 @@ function parse(str) {
 
   var tokens = (0, _lexer2.default)(str, options);
   var nodes = (0, _parser2.default)(tokens, options);
-  return options.format(nodes, options);
+  return (0, _format.format)(nodes, options);
 }
 
-exports.default = { parse: parse, parseDefaults: parseDefaults };
+function stringify(ast) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : parseDefaults;
+
+  return (0, _stringify.toHTML)(ast, options);
+}
 
-},{"./formats/v0":3,"./lexer":5,"./parser":6,"./tags":7}],5:[function(require,module,exports){
+},{"./format":2,"./lexer":4,"./parser":5,"./stringify":6,"./tags":7}],4:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -426,7 +360,6 @@ function lexTagAttributes(state) {
   var type = 'attribute';
   for (var i = 0; i < wLen; i++) {
     var word = words[i];
-    if (!(word && word.length)) continue;
     var isNotPair = word.indexOf('=') === -1;
     if (isNotPair) {
       var secondWord = words[i + 1];
@@ -498,7 +431,7 @@ function lexSkipTag(tagName, state) {
   }
 }
 
-},{"./compat":1}],6:[function(require,module,exports){
+},{"./compat":1}],5:[function(require,module,exports){
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -620,6 +553,50 @@ function parse(state) {
   state.cursor = cursor;
 }
 
+},{"./compat":1}],6:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatAttributes = formatAttributes;
+exports.toHTML = toHTML;
+
+var _compat = require('./compat');
+
+function formatAttributes(attributes) {
+  return attributes.reduce(function (attrs, attribute) {
+    var key = attribute.key,
+        value = attribute.value;
+
+    if (value === null) {
+      return attrs + ' ' + key;
+    }
+    var quoteEscape = value.indexOf('\'') !== -1;
+    var quote = quoteEscape ? '"' : '\'';
+    return attrs + ' ' + key + '=' + quote + value + quote;
+  }, '');
+}
+
+function toHTML(tree, options) {
+  return tree.map(function (node) {
+    if (node.type === 'text') {
+      return node.content;
+    }
+    if (node.type === 'comment') {
+      return '<!--' + node.content + '-->';
+    }
+    var tagName = node.tagName,
+        attributes = node.attributes,
+        children = node.children;
+
+    var isSelfClosing = (0, _compat.arrayIncludes)(options.voidTags, tagName.toLowerCase());
+    return isSelfClosing ? '<' + tagName + formatAttributes(attributes) + '>' : '<' + tagName + formatAttributes(attributes) + '>' + toHTML(children, options) + '</' + tagName + '>';
+  }).join('');
+}
+
+exports.default = { toHTML: toHTML };
+
 },{"./compat":1}],7:[function(require,module,exports){
 'use strict';
 
@@ -654,14 +631,13 @@ var closingTagAncestorBreakers = exports.closingTagAncestorBreakers = {
   tfoot: ['table'],
   tr: ['table'],
   td: ['table']
-};
 
-/*
-  Tags which do not need the closing tag
-  For example: <img> does not need </img>
-*/
-var voidTags = exports.voidTags = ['!doctype', 'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+  /*
+    Tags which do not need the closing tag
+    For example: <img> does not need </img>
+  */
+};var voidTags = exports.voidTags = ['!doctype', 'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 
-},{}]},{},[4])(4)
+},{}]},{},[3])(3)
 });
 //# sourceMappingURL=himalaya.js.map
diff --git a/docs/dist/himalaya.js.map b/docs/dist/himalaya.js.map
index cc7f845..139ad7a 100644
--- a/docs/dist/himalaya.js.map
+++ b/docs/dist/himalaya.js.map
@@ -1 +1 @@
-{"version":3,"names":[],"mappings":"","sources":["himalaya.js"],"sourcesContent":["(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.himalaya = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.startsWith = startsWith;\nexports.endsWith = endsWith;\nexports.stringIncludes = stringIncludes;\nexports.isRealNaN = isRealNaN;\nexports.arrayIncludes = arrayIncludes;\n/*\n  We don't want to include babel-polyfill in our project.\n    - Library authors should be using babel-runtime for non-global polyfilling\n    - Adding babel-polyfill/-runtime increases bundle size significantly\n\n  We will include our polyfill instance methods as regular functions.\n*/\n\nfunction startsWith(str, searchString, position) {\n  return str.substr(position || 0, searchString.length) === searchString;\n}\n\nfunction endsWith(str, searchString, position) {\n  var index = (position || str.length) - searchString.length;\n  var lastIndex = str.lastIndexOf(searchString, index);\n  return lastIndex !== -1 && lastIndex === index;\n}\n\nfunction stringIncludes(str, searchString, position) {\n  return str.indexOf(searchString, position || 0) !== -1;\n}\n\nfunction isRealNaN(x) {\n  return typeof x === 'number' && isNaN(x);\n}\n\nfunction arrayIncludes(array, searchElement, position) {\n  var len = array.length;\n  if (len === 0) return false;\n\n  var lookupIndex = position | 0;\n  var isNaNElement = isRealNaN(searchElement);\n  var searchIndex = lookupIndex >= 0 ? lookupIndex : len + lookupIndex;\n  while (searchIndex < len) {\n    var element = array[searchIndex++];\n    if (element === searchElement) return true;\n    if (isNaNElement && isRealNaN(element)) return true;\n  }\n\n  return false;\n}\n\n},{}],2:[function(require,module,exports){\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.splitHead = splitHead;\nexports.unquote = unquote;\nfunction splitHead(str, sep) {\n  var idx = str.indexOf(sep);\n  if (idx === -1) return [str];\n  return [str.slice(0, idx), str.slice(idx + sep.length)];\n}\n\nfunction unquote(str) {\n  var car = str.charAt(0);\n  var end = str.length - 1;\n  var isQuoteStart = car === '\"' || car === \"'\";\n  if (isQuoteStart && car === str.charAt(end)) {\n    return str.slice(1, end);\n  }\n  return str;\n}\n\n},{}],3:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }(); /*\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           This format adheres to the v0 ASP spec.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         */\n\n\nexports.default = format;\nexports.capitalize = capitalize;\nexports.camelCase = camelCase;\nexports.castValue = castValue;\nexports.formatAttributes = formatAttributes;\nexports.formatStyles = formatStyles;\n\nvar _compat = require('../compat');\n\nvar _util = require('./util');\n\nfunction format(nodes) {\n  return nodes.map(function (node) {\n    var type = capitalize(node.type);\n    if (type === 'Element') {\n      var tagName = node.tagName.toLowerCase();\n      var attributes = formatAttributes(node.attributes);\n      var children = format(node.children);\n      return { type: type, tagName: tagName, attributes: attributes, children: children };\n    }\n\n    return { type: type, content: node.content };\n  });\n}\n\nfunction capitalize(str) {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nfunction camelCase(str) {\n  return str.split('-').reduce(function (str, word) {\n    return str + word.charAt(0).toUpperCase() + word.slice(1);\n  });\n}\n\nfunction castValue(str) {\n  if (typeof str !== 'string') return str;\n  if (str === '') return str;\n  var num = +str;\n  if (!isNaN(num)) return num;\n  return str;\n}\n\nfunction formatAttributes(attributes) {\n  return attributes.reduce(function (attrs, pair) {\n    var _splitHead = (0, _util.splitHead)(pair.trim(), '='),\n        _splitHead2 = _slicedToArray(_splitHead, 2),\n        key = _splitHead2[0],\n        value = _splitHead2[1];\n\n    value = value ? (0, _util.unquote)(value) : key;\n    if (key === 'class') {\n      attrs.className = value.split(' ');\n    } else if (key === 'style') {\n      attrs.style = formatStyles(value);\n    } else if ((0, _compat.startsWith)(key, 'data-')) {\n      attrs.dataset = attrs.dataset || {};\n      var prop = camelCase(key.slice(5));\n      attrs.dataset[prop] = castValue(value);\n    } else {\n      attrs[camelCase(key)] = castValue(value);\n    }\n    return attrs;\n  }, {});\n}\n\nfunction formatStyles(str) {\n  return str.trim().split(';').map(function (rule) {\n    return (0, _util.splitHead)(rule.trim(), ':');\n  }).reduce(function (styles, keyValue) {\n    var _keyValue = _slicedToArray(keyValue, 2),\n        rawKey = _keyValue[0],\n        rawValue = _keyValue[1];\n\n    if (rawValue) {\n      var key = camelCase(rawKey.trim());\n      var value = castValue(rawValue.trim());\n      styles[key] = value;\n    }\n    return styles;\n  }, {});\n}\n\n},{\"../compat\":1,\"./util\":2}],4:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseDefaults = undefined;\nexports.parse = parse;\n\nvar _lexer = require('./lexer');\n\nvar _lexer2 = _interopRequireDefault(_lexer);\n\nvar _parser = require('./parser');\n\nvar _parser2 = _interopRequireDefault(_parser);\n\nvar _v = require('./formats/v0');\n\nvar _v2 = _interopRequireDefault(_v);\n\nvar _tags = require('./tags');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar parseDefaults = exports.parseDefaults = {\n  format: _v2.default, // transform for v0 spec\n  voidTags: _tags.voidTags,\n  closingTags: _tags.closingTags,\n  childlessTags: _tags.childlessTags,\n  closingTagAncestorBreakers: _tags.closingTagAncestorBreakers\n};\n\nfunction parse(str) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : parseDefaults;\n\n  var tokens = (0, _lexer2.default)(str, options);\n  var nodes = (0, _parser2.default)(tokens, options);\n  return options.format(nodes, options);\n}\n\nexports.default = { parse: parse, parseDefaults: parseDefaults };\n\n},{\"./formats/v0\":3,\"./lexer\":5,\"./parser\":6,\"./tags\":7}],5:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = lexer;\nexports.lex = lex;\nexports.findTextEnd = findTextEnd;\nexports.lexText = lexText;\nexports.lexComment = lexComment;\nexports.lexTag = lexTag;\nexports.isWhitespaceChar = isWhitespaceChar;\nexports.lexTagName = lexTagName;\nexports.lexTagAttributes = lexTagAttributes;\nexports.lexSkipTag = lexSkipTag;\n\nvar _compat = require('./compat');\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction lexer(str, options) {\n  var state = { str: str, options: options, cursor: 0, tokens: [] };\n  lex(state);\n  return state.tokens;\n}\n\nfunction lex(state) {\n  var str = state.str;\n\n  var len = str.length;\n  while (state.cursor < len) {\n    var start = state.cursor;\n    lexText(state);\n    if (state.cursor === start) {\n      var isComment = (0, _compat.startsWith)(str, '!--', state.cursor + 1);\n      if (isComment) {\n        lexComment(state);\n      } else {\n        var tagName = lexTag(state);\n        var safeTag = tagName.toLowerCase();\n        var childlessTags = state.options.childlessTags;\n\n        if ((0, _compat.arrayIncludes)(childlessTags, safeTag)) {\n          lexSkipTag(tagName, state);\n        }\n      }\n    }\n  }\n}\n\nvar alphanumeric = /[A-Za-z0-9]/;\nfunction findTextEnd(str, index) {\n  while (true) {\n    var textEnd = str.indexOf('<', index);\n    if (textEnd === -1) {\n      return textEnd;\n    }\n    var char = str.charAt(textEnd + 1);\n    if (char === '/' || char === '!' || alphanumeric.test(char)) {\n      return textEnd;\n    }\n    index = textEnd + 1;\n  }\n}\n\nfunction lexText(state) {\n  var type = 'text';\n  var str = state.str,\n      cursor = state.cursor;\n\n  var textEnd = findTextEnd(str, cursor);\n  if (textEnd === -1) {\n    // there is only text left\n    var _content = str.slice(cursor);\n    state.cursor = str.length;\n    state.tokens.push({ type: type, content: _content });\n    return;\n  }\n\n  if (textEnd === cursor) return;\n\n  var content = str.slice(cursor, textEnd);\n  state.cursor = textEnd;\n  state.tokens.push({ type: type, content: content });\n}\n\nfunction lexComment(state) {\n  state.cursor += 4; // \"<!--\".length\n  var str = state.str,\n      cursor = state.cursor;\n\n  var commentEnd = str.indexOf('-->', cursor);\n  var type = 'comment';\n  if (commentEnd === -1) {\n    // there is only the comment left\n    var _content2 = str.slice(cursor);\n    state.cursor = str.length;\n    state.tokens.push({ type: type, content: _content2 });\n    return;\n  }\n\n  var content = str.slice(cursor, commentEnd);\n  state.cursor = commentEnd + 3; // \"-->\".length\n  state.tokens.push({ type: type, content: content });\n}\n\nfunction lexTag(state) {\n  var str = state.str;\n\n  {\n    var secondChar = str.charAt(state.cursor + 1);\n    var close = secondChar === '/';\n    state.tokens.push({ type: 'tag-start', close: close });\n    state.cursor += close ? 2 : 1;\n  }\n  var tagName = lexTagName(state);\n  lexTagAttributes(state);\n  {\n    var firstChar = str.charAt(state.cursor);\n    var _close = firstChar === '/';\n    state.tokens.push({ type: 'tag-end', close: _close });\n    state.cursor += _close ? 2 : 1;\n  }\n  return tagName;\n}\n\n// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-white-space\nvar whitespace = /\\s/;\nfunction isWhitespaceChar(char) {\n  return whitespace.test(char);\n}\n\nfunction lexTagName(state) {\n  var str = state.str,\n      cursor = state.cursor;\n\n  var len = str.length;\n  var start = cursor;\n  while (start < len) {\n    var char = str.charAt(start);\n    var isTagChar = !(isWhitespaceChar(char) || char === '/' || char === '>');\n    if (isTagChar) break;\n    start++;\n  }\n\n  var end = start + 1;\n  while (end < len) {\n    var _char = str.charAt(end);\n    var _isTagChar = !(isWhitespaceChar(_char) || _char === '/' || _char === '>');\n    if (!_isTagChar) break;\n    end++;\n  }\n\n  state.cursor = end;\n  var tagName = str.slice(start, end);\n  state.tokens.push({ type: 'tag', content: tagName });\n  return tagName;\n}\n\nfunction lexTagAttributes(state) {\n  var str = state.str,\n      tokens = state.tokens;\n\n  var cursor = state.cursor;\n  var quote = null; // null, single-, or double-quote\n  var wordBegin = cursor; // index of word start\n  var words = []; // \"key\", \"key=value\", \"key='value'\", etc\n  var len = str.length;\n  while (cursor < len) {\n    var char = str.charAt(cursor);\n    if (quote) {\n      var isQuoteEnd = char === quote;\n      if (isQuoteEnd) {\n        quote = null;\n      }\n      cursor++;\n      continue;\n    }\n\n    var isTagEnd = char === '/' || char === '>';\n    if (isTagEnd) {\n      if (cursor !== wordBegin) {\n        words.push(str.slice(wordBegin, cursor));\n      }\n      break;\n    }\n\n    var isWordEnd = isWhitespaceChar(char);\n    if (isWordEnd) {\n      if (cursor !== wordBegin) {\n        words.push(str.slice(wordBegin, cursor));\n      }\n      wordBegin = cursor + 1;\n      cursor++;\n      continue;\n    }\n\n    var isQuoteStart = char === '\\'' || char === '\"';\n    if (isQuoteStart) {\n      quote = char;\n      cursor++;\n      continue;\n    }\n\n    cursor++;\n  }\n  state.cursor = cursor;\n\n  var wLen = words.length;\n  var type = 'attribute';\n  for (var i = 0; i < wLen; i++) {\n    var word = words[i];\n    if (!(word && word.length)) continue;\n    var isNotPair = word.indexOf('=') === -1;\n    if (isNotPair) {\n      var secondWord = words[i + 1];\n      if (secondWord && (0, _compat.startsWith)(secondWord, '=')) {\n        if (secondWord.length > 1) {\n          var newWord = word + secondWord;\n          tokens.push({ type: type, content: newWord });\n          i += 1;\n          continue;\n        }\n        var thirdWord = words[i + 2];\n        i += 1;\n        if (thirdWord) {\n          var _newWord = word + '=' + thirdWord;\n          tokens.push({ type: type, content: _newWord });\n          i += 1;\n          continue;\n        }\n      }\n    }\n    if ((0, _compat.endsWith)(word, '=')) {\n      var _secondWord = words[i + 1];\n      if (_secondWord && !(0, _compat.stringIncludes)(_secondWord, '=')) {\n        var _newWord3 = word + _secondWord;\n        tokens.push({ type: type, content: _newWord3 });\n        i += 1;\n        continue;\n      }\n\n      var _newWord2 = word.slice(0, -1);\n      tokens.push({ type: type, content: _newWord2 });\n      continue;\n    }\n\n    tokens.push({ type: type, content: word });\n  }\n}\n\nfunction lexSkipTag(tagName, state) {\n  var str = state.str,\n      cursor = state.cursor,\n      tokens = state.tokens;\n\n  var len = str.length;\n  var index = cursor;\n  while (index < len) {\n    var nextTag = str.indexOf('</', index);\n    if (nextTag === -1) {\n      lexText(state);\n      break;\n    }\n\n    var tagState = { str: str, cursor: nextTag + 2, tokens: [] };\n    var name = lexTagName(tagState);\n    var safeTagName = tagName.toLowerCase();\n    if (safeTagName !== name.toLowerCase()) {\n      index = tagState.cursor;\n      continue;\n    }\n\n    var content = str.slice(cursor, nextTag);\n    tokens.push({ type: 'text', content: content });\n    var openTag = { type: 'tag-start', close: true };\n    var closeTag = { type: 'tag-end', close: false };\n    lexTagAttributes(tagState);\n    tokens.push.apply(tokens, [openTag].concat(_toConsumableArray(tagState.tokens), [closeTag]));\n    state.cursor = tagState.cursor + 1;\n    break;\n  }\n}\n\n},{\"./compat\":1}],6:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = parser;\nexports.hasTerminalParent = hasTerminalParent;\nexports.parse = parse;\n\nvar _compat = require('./compat');\n\nfunction parser(tokens, options) {\n  var root = { tagName: null, children: [] };\n  var state = { tokens: tokens, options: options, cursor: 0, stack: [root] };\n  parse(state);\n  return root.children;\n}\n\nfunction hasTerminalParent(tagName, stack, terminals) {\n  var tagParents = terminals[tagName];\n  if (tagParents) {\n    var currentIndex = stack.length - 1;\n    while (currentIndex >= 0) {\n      var parentTagName = stack[currentIndex].tagName;\n      if (parentTagName === tagName) {\n        break;\n      }\n      if ((0, _compat.arrayIncludes)(tagParents, parentTagName)) {\n        return true;\n      }\n      currentIndex--;\n    }\n  }\n  return false;\n}\n\nfunction parse(state) {\n  var tokens = state.tokens,\n      options = state.options;\n  var stack = state.stack;\n\n  var nodes = stack[stack.length - 1].children;\n  var len = tokens.length;\n  var cursor = state.cursor;\n\n  while (cursor < len) {\n    var token = tokens[cursor];\n    if (token.type !== 'tag-start') {\n      nodes.push(token);\n      cursor++;\n      continue;\n    }\n\n    var tagToken = tokens[++cursor];\n    cursor++;\n    var tagName = tagToken.content.toLowerCase();\n    if (token.close) {\n      var item = void 0;\n      while (item = stack.pop()) {\n        if (tagName === item.tagName) break;\n      }\n      while (cursor < len) {\n        var endToken = tokens[cursor];\n        if (endToken.type !== 'tag-end') break;\n        cursor++;\n      }\n      break;\n    }\n\n    var isClosingTag = (0, _compat.arrayIncludes)(options.closingTags, tagName);\n    var shouldRewindToAutoClose = isClosingTag;\n    if (shouldRewindToAutoClose) {\n      var terminals = options.closingTagAncestorBreakers;\n\n      shouldRewindToAutoClose = !hasTerminalParent(tagName, stack, terminals);\n    }\n\n    if (shouldRewindToAutoClose) {\n      // rewind the stack to just above the previous\n      // closing tag of the same name\n      var currentIndex = stack.length - 1;\n      while (currentIndex > 0) {\n        if (tagName === stack[currentIndex].tagName) {\n          stack = stack.slice(0, currentIndex);\n          var previousIndex = currentIndex - 1;\n          nodes = stack[previousIndex].children;\n          break;\n        }\n        currentIndex = currentIndex - 1;\n      }\n    }\n\n    var attributes = [];\n    var attrToken = void 0;\n    while (cursor < len) {\n      attrToken = tokens[cursor];\n      if (attrToken.type === 'tag-end') break;\n      attributes.push(attrToken.content);\n      cursor++;\n    }\n\n    cursor++;\n    var children = [];\n    nodes.push({\n      type: 'element',\n      tagName: tagToken.content,\n      attributes: attributes,\n      children: children\n    });\n\n    var hasChildren = !(attrToken.close || (0, _compat.arrayIncludes)(options.voidTags, tagName));\n    if (hasChildren) {\n      stack.push({ tagName: tagName, children: children });\n      var innerState = { tokens: tokens, options: options, cursor: cursor, stack: stack };\n      parse(innerState);\n      cursor = innerState.cursor;\n    }\n  }\n  state.cursor = cursor;\n}\n\n},{\"./compat\":1}],7:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/*\n  Tags which contain arbitary non-parsed content\n  For example: <script> JavaScript should not be parsed\n*/\nvar childlessTags = exports.childlessTags = ['style', 'script', 'template'];\n\n/*\n  Tags which auto-close because they cannot be nested\n  For example: <p>Outer<p>Inner is <p>Outer</p><p>Inner</p>\n*/\nvar closingTags = exports.closingTags = ['html', 'head', 'body', 'p', 'dt', 'dd', 'li', 'option', 'thead', 'th', 'tbody', 'tr', 'td', 'tfoot', 'colgroup'];\n\n/*\n  Closing tags which have ancestor tags which\n  may exist within them which prevent the\n  closing tag from auto-closing.\n  For example: in <li><ul><li></ul></li>,\n  the top-level <li> should not auto-close.\n*/\nvar closingTagAncestorBreakers = exports.closingTagAncestorBreakers = {\n  li: ['ul', 'ol', 'menu'],\n  dt: ['dl'],\n  dd: ['dl'],\n  tbody: ['table'],\n  thead: ['table'],\n  tfoot: ['table'],\n  tr: ['table'],\n  td: ['table']\n};\n\n/*\n  Tags which do not need the closing tag\n  For example: <img> does not need </img>\n*/\nvar voidTags = exports.voidTags = ['!doctype', 'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];\n\n},{}]},{},[4])(4)\n});"],"file":"himalaya.js"}
\ No newline at end of file
+{"version":3,"names":[],"mappings":"","sources":["himalaya.js"],"sourcesContent":["(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.himalaya = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.startsWith = startsWith;\nexports.endsWith = endsWith;\nexports.stringIncludes = stringIncludes;\nexports.isRealNaN = isRealNaN;\nexports.arrayIncludes = arrayIncludes;\n/*\n  We don't want to include babel-polyfill in our project.\n    - Library authors should be using babel-runtime for non-global polyfilling\n    - Adding babel-polyfill/-runtime increases bundle size significantly\n\n  We will include our polyfill instance methods as regular functions.\n*/\n\nfunction startsWith(str, searchString, position) {\n  return str.substr(position || 0, searchString.length) === searchString;\n}\n\nfunction endsWith(str, searchString, position) {\n  var index = (position || str.length) - searchString.length;\n  var lastIndex = str.lastIndexOf(searchString, index);\n  return lastIndex !== -1 && lastIndex === index;\n}\n\nfunction stringIncludes(str, searchString, position) {\n  return str.indexOf(searchString, position || 0) !== -1;\n}\n\nfunction isRealNaN(x) {\n  return typeof x === 'number' && isNaN(x);\n}\n\nfunction arrayIncludes(array, searchElement, position) {\n  var len = array.length;\n  if (len === 0) return false;\n\n  var lookupIndex = position | 0;\n  var isNaNElement = isRealNaN(searchElement);\n  var searchIndex = lookupIndex >= 0 ? lookupIndex : len + lookupIndex;\n  while (searchIndex < len) {\n    var element = array[searchIndex++];\n    if (element === searchElement) return true;\n    if (isNaNElement && isRealNaN(element)) return true;\n  }\n\n  return false;\n}\n\n},{}],2:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.splitHead = splitHead;\nexports.unquote = unquote;\nexports.format = format;\nexports.formatAttributes = formatAttributes;\nfunction splitHead(str, sep) {\n  var idx = str.indexOf(sep);\n  if (idx === -1) return [str];\n  return [str.slice(0, idx), str.slice(idx + sep.length)];\n}\n\nfunction unquote(str) {\n  var car = str.charAt(0);\n  var end = str.length - 1;\n  var isQuoteStart = car === '\"' || car === \"'\";\n  if (isQuoteStart && car === str.charAt(end)) {\n    return str.slice(1, end);\n  }\n  return str;\n}\n\nfunction format(nodes) {\n  return nodes.map(function (node) {\n    var type = node.type;\n    if (type === 'element') {\n      var tagName = node.tagName.toLowerCase();\n      var attributes = formatAttributes(node.attributes);\n      var children = format(node.children);\n      return { type: type, tagName: tagName, attributes: attributes, children: children };\n    }\n\n    return { type: type, content: node.content };\n  });\n}\n\nfunction formatAttributes(attributes) {\n  return attributes.map(function (attribute) {\n    var parts = splitHead(attribute.trim(), '=');\n    var key = parts[0];\n    var value = typeof parts[1] === 'string' ? unquote(parts[1]) : null;\n    return { key: key, value: value };\n  });\n}\n\n},{}],3:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseDefaults = undefined;\nexports.parse = parse;\nexports.stringify = stringify;\n\nvar _lexer = require('./lexer');\n\nvar _lexer2 = _interopRequireDefault(_lexer);\n\nvar _parser = require('./parser');\n\nvar _parser2 = _interopRequireDefault(_parser);\n\nvar _format = require('./format');\n\nvar _stringify = require('./stringify');\n\nvar _tags = require('./tags');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar parseDefaults = exports.parseDefaults = {\n  voidTags: _tags.voidTags,\n  closingTags: _tags.closingTags,\n  childlessTags: _tags.childlessTags,\n  closingTagAncestorBreakers: _tags.closingTagAncestorBreakers\n};\n\nfunction parse(str) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : parseDefaults;\n\n  var tokens = (0, _lexer2.default)(str, options);\n  var nodes = (0, _parser2.default)(tokens, options);\n  return (0, _format.format)(nodes, options);\n}\n\nfunction stringify(ast) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : parseDefaults;\n\n  return (0, _stringify.toHTML)(ast, options);\n}\n\n},{\"./format\":2,\"./lexer\":4,\"./parser\":5,\"./stringify\":6,\"./tags\":7}],4:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = lexer;\nexports.lex = lex;\nexports.findTextEnd = findTextEnd;\nexports.lexText = lexText;\nexports.lexComment = lexComment;\nexports.lexTag = lexTag;\nexports.isWhitespaceChar = isWhitespaceChar;\nexports.lexTagName = lexTagName;\nexports.lexTagAttributes = lexTagAttributes;\nexports.lexSkipTag = lexSkipTag;\n\nvar _compat = require('./compat');\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction lexer(str, options) {\n  var state = { str: str, options: options, cursor: 0, tokens: [] };\n  lex(state);\n  return state.tokens;\n}\n\nfunction lex(state) {\n  var str = state.str;\n\n  var len = str.length;\n  while (state.cursor < len) {\n    var start = state.cursor;\n    lexText(state);\n    if (state.cursor === start) {\n      var isComment = (0, _compat.startsWith)(str, '!--', state.cursor + 1);\n      if (isComment) {\n        lexComment(state);\n      } else {\n        var tagName = lexTag(state);\n        var safeTag = tagName.toLowerCase();\n        var childlessTags = state.options.childlessTags;\n\n        if ((0, _compat.arrayIncludes)(childlessTags, safeTag)) {\n          lexSkipTag(tagName, state);\n        }\n      }\n    }\n  }\n}\n\nvar alphanumeric = /[A-Za-z0-9]/;\nfunction findTextEnd(str, index) {\n  while (true) {\n    var textEnd = str.indexOf('<', index);\n    if (textEnd === -1) {\n      return textEnd;\n    }\n    var char = str.charAt(textEnd + 1);\n    if (char === '/' || char === '!' || alphanumeric.test(char)) {\n      return textEnd;\n    }\n    index = textEnd + 1;\n  }\n}\n\nfunction lexText(state) {\n  var type = 'text';\n  var str = state.str,\n      cursor = state.cursor;\n\n  var textEnd = findTextEnd(str, cursor);\n  if (textEnd === -1) {\n    // there is only text left\n    var _content = str.slice(cursor);\n    state.cursor = str.length;\n    state.tokens.push({ type: type, content: _content });\n    return;\n  }\n\n  if (textEnd === cursor) return;\n\n  var content = str.slice(cursor, textEnd);\n  state.cursor = textEnd;\n  state.tokens.push({ type: type, content: content });\n}\n\nfunction lexComment(state) {\n  state.cursor += 4; // \"<!--\".length\n  var str = state.str,\n      cursor = state.cursor;\n\n  var commentEnd = str.indexOf('-->', cursor);\n  var type = 'comment';\n  if (commentEnd === -1) {\n    // there is only the comment left\n    var _content2 = str.slice(cursor);\n    state.cursor = str.length;\n    state.tokens.push({ type: type, content: _content2 });\n    return;\n  }\n\n  var content = str.slice(cursor, commentEnd);\n  state.cursor = commentEnd + 3; // \"-->\".length\n  state.tokens.push({ type: type, content: content });\n}\n\nfunction lexTag(state) {\n  var str = state.str;\n\n  {\n    var secondChar = str.charAt(state.cursor + 1);\n    var close = secondChar === '/';\n    state.tokens.push({ type: 'tag-start', close: close });\n    state.cursor += close ? 2 : 1;\n  }\n  var tagName = lexTagName(state);\n  lexTagAttributes(state);\n  {\n    var firstChar = str.charAt(state.cursor);\n    var _close = firstChar === '/';\n    state.tokens.push({ type: 'tag-end', close: _close });\n    state.cursor += _close ? 2 : 1;\n  }\n  return tagName;\n}\n\n// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-white-space\nvar whitespace = /\\s/;\nfunction isWhitespaceChar(char) {\n  return whitespace.test(char);\n}\n\nfunction lexTagName(state) {\n  var str = state.str,\n      cursor = state.cursor;\n\n  var len = str.length;\n  var start = cursor;\n  while (start < len) {\n    var char = str.charAt(start);\n    var isTagChar = !(isWhitespaceChar(char) || char === '/' || char === '>');\n    if (isTagChar) break;\n    start++;\n  }\n\n  var end = start + 1;\n  while (end < len) {\n    var _char = str.charAt(end);\n    var _isTagChar = !(isWhitespaceChar(_char) || _char === '/' || _char === '>');\n    if (!_isTagChar) break;\n    end++;\n  }\n\n  state.cursor = end;\n  var tagName = str.slice(start, end);\n  state.tokens.push({ type: 'tag', content: tagName });\n  return tagName;\n}\n\nfunction lexTagAttributes(state) {\n  var str = state.str,\n      tokens = state.tokens;\n\n  var cursor = state.cursor;\n  var quote = null; // null, single-, or double-quote\n  var wordBegin = cursor; // index of word start\n  var words = []; // \"key\", \"key=value\", \"key='value'\", etc\n  var len = str.length;\n  while (cursor < len) {\n    var char = str.charAt(cursor);\n    if (quote) {\n      var isQuoteEnd = char === quote;\n      if (isQuoteEnd) {\n        quote = null;\n      }\n      cursor++;\n      continue;\n    }\n\n    var isTagEnd = char === '/' || char === '>';\n    if (isTagEnd) {\n      if (cursor !== wordBegin) {\n        words.push(str.slice(wordBegin, cursor));\n      }\n      break;\n    }\n\n    var isWordEnd = isWhitespaceChar(char);\n    if (isWordEnd) {\n      if (cursor !== wordBegin) {\n        words.push(str.slice(wordBegin, cursor));\n      }\n      wordBegin = cursor + 1;\n      cursor++;\n      continue;\n    }\n\n    var isQuoteStart = char === '\\'' || char === '\"';\n    if (isQuoteStart) {\n      quote = char;\n      cursor++;\n      continue;\n    }\n\n    cursor++;\n  }\n  state.cursor = cursor;\n\n  var wLen = words.length;\n  var type = 'attribute';\n  for (var i = 0; i < wLen; i++) {\n    var word = words[i];\n    var isNotPair = word.indexOf('=') === -1;\n    if (isNotPair) {\n      var secondWord = words[i + 1];\n      if (secondWord && (0, _compat.startsWith)(secondWord, '=')) {\n        if (secondWord.length > 1) {\n          var newWord = word + secondWord;\n          tokens.push({ type: type, content: newWord });\n          i += 1;\n          continue;\n        }\n        var thirdWord = words[i + 2];\n        i += 1;\n        if (thirdWord) {\n          var _newWord = word + '=' + thirdWord;\n          tokens.push({ type: type, content: _newWord });\n          i += 1;\n          continue;\n        }\n      }\n    }\n    if ((0, _compat.endsWith)(word, '=')) {\n      var _secondWord = words[i + 1];\n      if (_secondWord && !(0, _compat.stringIncludes)(_secondWord, '=')) {\n        var _newWord3 = word + _secondWord;\n        tokens.push({ type: type, content: _newWord3 });\n        i += 1;\n        continue;\n      }\n\n      var _newWord2 = word.slice(0, -1);\n      tokens.push({ type: type, content: _newWord2 });\n      continue;\n    }\n\n    tokens.push({ type: type, content: word });\n  }\n}\n\nfunction lexSkipTag(tagName, state) {\n  var str = state.str,\n      cursor = state.cursor,\n      tokens = state.tokens;\n\n  var len = str.length;\n  var index = cursor;\n  while (index < len) {\n    var nextTag = str.indexOf('</', index);\n    if (nextTag === -1) {\n      lexText(state);\n      break;\n    }\n\n    var tagState = { str: str, cursor: nextTag + 2, tokens: [] };\n    var name = lexTagName(tagState);\n    var safeTagName = tagName.toLowerCase();\n    if (safeTagName !== name.toLowerCase()) {\n      index = tagState.cursor;\n      continue;\n    }\n\n    var content = str.slice(cursor, nextTag);\n    tokens.push({ type: 'text', content: content });\n    var openTag = { type: 'tag-start', close: true };\n    var closeTag = { type: 'tag-end', close: false };\n    lexTagAttributes(tagState);\n    tokens.push.apply(tokens, [openTag].concat(_toConsumableArray(tagState.tokens), [closeTag]));\n    state.cursor = tagState.cursor + 1;\n    break;\n  }\n}\n\n},{\"./compat\":1}],5:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = parser;\nexports.hasTerminalParent = hasTerminalParent;\nexports.parse = parse;\n\nvar _compat = require('./compat');\n\nfunction parser(tokens, options) {\n  var root = { tagName: null, children: [] };\n  var state = { tokens: tokens, options: options, cursor: 0, stack: [root] };\n  parse(state);\n  return root.children;\n}\n\nfunction hasTerminalParent(tagName, stack, terminals) {\n  var tagParents = terminals[tagName];\n  if (tagParents) {\n    var currentIndex = stack.length - 1;\n    while (currentIndex >= 0) {\n      var parentTagName = stack[currentIndex].tagName;\n      if (parentTagName === tagName) {\n        break;\n      }\n      if ((0, _compat.arrayIncludes)(tagParents, parentTagName)) {\n        return true;\n      }\n      currentIndex--;\n    }\n  }\n  return false;\n}\n\nfunction parse(state) {\n  var tokens = state.tokens,\n      options = state.options;\n  var stack = state.stack;\n\n  var nodes = stack[stack.length - 1].children;\n  var len = tokens.length;\n  var cursor = state.cursor;\n\n  while (cursor < len) {\n    var token = tokens[cursor];\n    if (token.type !== 'tag-start') {\n      nodes.push(token);\n      cursor++;\n      continue;\n    }\n\n    var tagToken = tokens[++cursor];\n    cursor++;\n    var tagName = tagToken.content.toLowerCase();\n    if (token.close) {\n      var item = void 0;\n      while (item = stack.pop()) {\n        if (tagName === item.tagName) break;\n      }\n      while (cursor < len) {\n        var endToken = tokens[cursor];\n        if (endToken.type !== 'tag-end') break;\n        cursor++;\n      }\n      break;\n    }\n\n    var isClosingTag = (0, _compat.arrayIncludes)(options.closingTags, tagName);\n    var shouldRewindToAutoClose = isClosingTag;\n    if (shouldRewindToAutoClose) {\n      var terminals = options.closingTagAncestorBreakers;\n\n      shouldRewindToAutoClose = !hasTerminalParent(tagName, stack, terminals);\n    }\n\n    if (shouldRewindToAutoClose) {\n      // rewind the stack to just above the previous\n      // closing tag of the same name\n      var currentIndex = stack.length - 1;\n      while (currentIndex > 0) {\n        if (tagName === stack[currentIndex].tagName) {\n          stack = stack.slice(0, currentIndex);\n          var previousIndex = currentIndex - 1;\n          nodes = stack[previousIndex].children;\n          break;\n        }\n        currentIndex = currentIndex - 1;\n      }\n    }\n\n    var attributes = [];\n    var attrToken = void 0;\n    while (cursor < len) {\n      attrToken = tokens[cursor];\n      if (attrToken.type === 'tag-end') break;\n      attributes.push(attrToken.content);\n      cursor++;\n    }\n\n    cursor++;\n    var children = [];\n    nodes.push({\n      type: 'element',\n      tagName: tagToken.content,\n      attributes: attributes,\n      children: children\n    });\n\n    var hasChildren = !(attrToken.close || (0, _compat.arrayIncludes)(options.voidTags, tagName));\n    if (hasChildren) {\n      stack.push({ tagName: tagName, children: children });\n      var innerState = { tokens: tokens, options: options, cursor: cursor, stack: stack };\n      parse(innerState);\n      cursor = innerState.cursor;\n    }\n  }\n  state.cursor = cursor;\n}\n\n},{\"./compat\":1}],6:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.formatAttributes = formatAttributes;\nexports.toHTML = toHTML;\n\nvar _compat = require('./compat');\n\nfunction formatAttributes(attributes) {\n  return attributes.reduce(function (attrs, attribute) {\n    var key = attribute.key,\n        value = attribute.value;\n\n    if (value === null) {\n      return attrs + ' ' + key;\n    }\n    var quoteEscape = value.indexOf('\\'') !== -1;\n    var quote = quoteEscape ? '\"' : '\\'';\n    return attrs + ' ' + key + '=' + quote + value + quote;\n  }, '');\n}\n\nfunction toHTML(tree, options) {\n  return tree.map(function (node) {\n    if (node.type === 'text') {\n      return node.content;\n    }\n    if (node.type === 'comment') {\n      return '<!--' + node.content + '-->';\n    }\n    var tagName = node.tagName,\n        attributes = node.attributes,\n        children = node.children;\n\n    var isSelfClosing = (0, _compat.arrayIncludes)(options.voidTags, tagName.toLowerCase());\n    return isSelfClosing ? '<' + tagName + formatAttributes(attributes) + '>' : '<' + tagName + formatAttributes(attributes) + '>' + toHTML(children, options) + '</' + tagName + '>';\n  }).join('');\n}\n\nexports.default = { toHTML: toHTML };\n\n},{\"./compat\":1}],7:[function(require,module,exports){\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/*\n  Tags which contain arbitary non-parsed content\n  For example: <script> JavaScript should not be parsed\n*/\nvar childlessTags = exports.childlessTags = ['style', 'script', 'template'];\n\n/*\n  Tags which auto-close because they cannot be nested\n  For example: <p>Outer<p>Inner is <p>Outer</p><p>Inner</p>\n*/\nvar closingTags = exports.closingTags = ['html', 'head', 'body', 'p', 'dt', 'dd', 'li', 'option', 'thead', 'th', 'tbody', 'tr', 'td', 'tfoot', 'colgroup'];\n\n/*\n  Closing tags which have ancestor tags which\n  may exist within them which prevent the\n  closing tag from auto-closing.\n  For example: in <li><ul><li></ul></li>,\n  the top-level <li> should not auto-close.\n*/\nvar closingTagAncestorBreakers = exports.closingTagAncestorBreakers = {\n  li: ['ul', 'ol', 'menu'],\n  dt: ['dl'],\n  dd: ['dl'],\n  tbody: ['table'],\n  thead: ['table'],\n  tfoot: ['table'],\n  tr: ['table'],\n  td: ['table']\n\n  /*\n    Tags which do not need the closing tag\n    For example: <img> does not need </img>\n  */\n};var voidTags = exports.voidTags = ['!doctype', 'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];\n\n},{}]},{},[3])(3)\n});"],"file":"himalaya.js"}
\ No newline at end of file
diff --git a/package.json b/package.json
index b7204d0..461cee2 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "himalaya",
   "description": "HTML to JSON parser",
-  "version": "0.3.1",
+  "version": "1.0.0-0",
   "author": "Chris Andrejewski <christopher.andrejewski@gmail.com>",
   "ava": {
     "require": [
@@ -22,15 +22,9 @@
       }
     }
   },
-  "bin": {
-    "himalaya": "./bin/himalaya.js"
-  },
   "bugs": {
     "url": "https://github.com/andrejewski/himalaya/issues"
   },
-  "dependencies": {
-    "paul": "0.0.3"
-  },
   "devDependencies": {
     "ava": "^0.23.0",
     "babel-core": "^6.24.0",
diff --git a/src/formats/v1.js b/src/format.js
similarity index 59%
rename from src/formats/v1.js
rename to src/format.js
index c6d8c77..b43aa09 100644
--- a/src/formats/v1.js
+++ b/src/format.js
@@ -1,6 +1,20 @@
-import {splitHead, unquote} from './util'
+export function splitHead (str, sep) {
+  const idx = str.indexOf(sep)
+  if (idx === -1) return [str]
+  return [str.slice(0, idx), str.slice(idx + sep.length)]
+}
+
+export function unquote (str) {
+  const car = str.charAt(0)
+  const end = str.length - 1
+  const isQuoteStart = car === '"' || car === "'"
+  if (isQuoteStart && car === str.charAt(end)) {
+    return str.slice(1, end)
+  }
+  return str
+}
 
-export default function format (nodes) {
+export function format (nodes) {
   return nodes.map(node => {
     const type = node.type
     if (type === 'element') {
diff --git a/src/formats/util.js b/src/formats/util.js
deleted file mode 100644
index 7881b80..0000000
--- a/src/formats/util.js
+++ /dev/null
@@ -1,15 +0,0 @@
-export function splitHead (str, sep) {
-  const idx = str.indexOf(sep)
-  if (idx === -1) return [str]
-  return [str.slice(0, idx), str.slice(idx + sep.length)]
-}
-
-export function unquote (str) {
-  const car = str.charAt(0)
-  const end = str.length - 1
-  const isQuoteStart = car === '"' || car === "'"
-  if (isQuoteStart && car === str.charAt(end)) {
-    return str.slice(1, end)
-  }
-  return str
-}
diff --git a/src/formats/v0.js b/src/formats/v0.js
deleted file mode 100644
index f798cc5..0000000
--- a/src/formats/v0.js
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-  This format adheres to the v0 ASP spec.
-*/
-import {startsWith} from '../compat'
-import {splitHead, unquote} from './util'
-
-export default function format (nodes) {
-  return nodes.map(node => {
-    const type = capitalize(node.type)
-    if (type === 'Element') {
-      const tagName = node.tagName.toLowerCase()
-      const attributes = formatAttributes(node.attributes)
-      const children = format(node.children)
-      return {type, tagName, attributes, children}
-    }
-
-    return {type, content: node.content}
-  })
-}
-
-export function capitalize (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
-}
-
-export function camelCase (str) {
-  return str.split('-').reduce((str, word) => {
-    return str + word.charAt(0).toUpperCase() + word.slice(1)
-  })
-}
-
-export function castValue (str) {
-  if (typeof str !== 'string') return str
-  if (str === '') return str
-  const num = +str
-  if (!isNaN(num)) return num
-  return str
-}
-
-export function formatAttributes (attributes) {
-  return attributes.reduce((attrs, pair) => {
-    let [key, value] = splitHead(pair.trim(), '=')
-    value = value ? unquote(value) : key
-    if (key === 'class') {
-      attrs.className = value.split(' ')
-    } else if (key === 'style') {
-      attrs.style = formatStyles(value)
-    } else if (startsWith(key, 'data-')) {
-      attrs.dataset = attrs.dataset || {}
-      const prop = camelCase(key.slice(5))
-      attrs.dataset[prop] = castValue(value)
-    } else {
-      attrs[camelCase(key)] = castValue(value)
-    }
-    return attrs
-  }, {})
-}
-
-export function formatStyles (str) {
-  return str.trim().split(';')
-    .map(rule => splitHead(rule.trim(), ':'))
-    .reduce((styles, keyValue) => {
-      const [rawKey, rawValue] = keyValue
-      if (rawValue) {
-        const key = camelCase(rawKey.trim())
-        const value = castValue(rawValue.trim())
-        styles[key] = value
-      }
-      return styles
-    }, {})
-}
diff --git a/src/index.js b/src/index.js
index 50b6b6f..07d80d3 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,6 +1,7 @@
 import lexer from './lexer'
 import parser from './parser'
-import format from './formats/v0'
+import {format} from './format'
+import {toHTML} from './stringify'
 import {
   voidTags,
   closingTags,
@@ -9,7 +10,6 @@ import {
 } from './tags'
 
 export const parseDefaults = {
-  format, // transform for v0 spec
   voidTags,
   closingTags,
   childlessTags,
@@ -19,7 +19,9 @@ export const parseDefaults = {
 export function parse (str, options = parseDefaults) {
   const tokens = lexer(str, options)
   const nodes = parser(tokens, options)
-  return options.format(nodes, options)
+  return format(nodes, options)
 }
 
-export default {parse, parseDefaults}
+export function stringify (ast, options = parseDefaults) {
+  return toHTML(ast, options)
+}
diff --git a/src/lexer.js b/src/lexer.js
index 3d25b39..0cc2a21 100644
--- a/src/lexer.js
+++ b/src/lexer.js
@@ -186,7 +186,6 @@ export function lexTagAttributes (state) {
   const type = 'attribute'
   for (let i = 0; i < wLen; i++) {
     const word = words[i]
-    if (!(word && word.length)) continue
     const isNotPair = word.indexOf('=') === -1
     if (isNotPair) {
       const secondWord = words[i + 1]
diff --git a/src/translate/v1.js b/src/stringify.js
similarity index 78%
rename from src/translate/v1.js
rename to src/stringify.js
index b75a643..b3a57de 100644
--- a/src/translate/v1.js
+++ b/src/stringify.js
@@ -1,5 +1,4 @@
-import {voidTags} from '../tags'
-import {arrayIncludes} from '../compat'
+import {arrayIncludes} from './compat'
 
 export function formatAttributes (attributes) {
   return attributes.reduce((attrs, attribute) => {
@@ -13,7 +12,7 @@ export function formatAttributes (attributes) {
   }, '')
 }
 
-export function toHTML (tree, options = {}) {
+export function toHTML (tree, options) {
   return tree.map(node => {
     if (node.type === 'text') {
       return node.content
@@ -22,10 +21,10 @@ export function toHTML (tree, options = {}) {
       return `<!--${node.content}-->`
     }
     const {tagName, attributes, children} = node
-    const isSelfClosing = arrayIncludes(voidTags, tagName.toLowerCase())
+    const isSelfClosing = arrayIncludes(options.voidTags, tagName.toLowerCase())
     return isSelfClosing
       ? `<${tagName}${formatAttributes(attributes)}>`
-      : `<${tagName}${formatAttributes(attributes)}>${toHTML(children)}</${tagName}>`
+      : `<${tagName}${formatAttributes(attributes)}>${toHTML(children, options)}</${tagName}>`
   }).join('')
 }
 
diff --git a/src/translate/v0.js b/src/translate/v0.js
deleted file mode 100644
index 952aa98..0000000
--- a/src/translate/v0.js
+++ /dev/null
@@ -1,194 +0,0 @@
-import paul from 'paul'
-import {
-  stringIncludes,
-  arrayIncludes
-} from '../compat'
-import {voidTags} from '../tags'
-
-export function serializeAttr (attr, value, isXml) {
-  if (!isXml && attr === value) return attr
-  const text = value.toString()
-  const quoteEscape = text.indexOf('\'') !== -1
-  const quote = quoteEscape ? '"' : '\''
-  return attr + '=' + quote + text + quote
-}
-
-// stolen from underscore.string
-export function dasherize (str) {
-  return str.trim()
-    .replace(/([A-Z])/g, '-$1')
-    .replace(/[-_\s]+/g, '-')
-    .toLowerCase()
-}
-
-export function inlineStyle (style) {
-  return Object.keys(style).reduce((css, key) => {
-    return `${css}; ${dasherize(key)}: ${style[key]}`
-  }, '').slice(2)
-}
-
-export function toHTML (tree, options = {}) {
-  const {doctype} = options
-  const isXml = doctype === 'xml'
-  const html = paul.walk(tree, (node, walk) => {
-    const {type, tagName, attributes, content} = node
-    if (type === 'Text') return content
-    if (type === 'Comment') return `<!--${content}-->`
-    let tag = '<' + tagName
-    for (const attr in attributes) {
-      const val = attributes[attr]
-      if (attr === 'dataset') {
-        for (const prop in val) {
-          const key = 'data-' + dasherize(prop)
-          tag += ' ' + serializeAttr(key, val[prop], isXml)
-        }
-        continue
-      }
-
-      if (attr === 'style') {
-        tag += ' ' + serializeAttr(attr, inlineStyle(val))
-        continue
-      }
-
-      if (attr === 'className') {
-        tag += ' ' + serializeAttr('class', val.join(' '))
-        continue
-      }
-
-      tag += ' ' + serializeAttr(dasherize(attr), val, isXml)
-    }
-
-    tag += '>'
-    const autoClose = !isXml && arrayIncludes(voidTags, tagName.toLowerCase())
-    if (autoClose) return tag
-
-    const innerds = walk(node.children || []).join('')
-    return tag + innerds + `</${tagName}>`
-  })
-  if (html.join) return html.join('')
-  return html
-}
-
-const newline = '\n'
-
-export function isWhitespaceNode (node) {
-  return !(node.type === 'Text' && !node.content.trim())
-}
-
-export function toPug (tree, options = {indentation: '  '}) {
-  let {doctype} = options
-  const multi = multilineText(options.indentation)
-
-  if (tree.filter) tree = tree.filter(isWhitespaceNode)
-  const jade = paul.walk(tree, (node, walk, depth) => {
-    const {type, tagName, attributes} = node
-    if (type === 'Text') {
-      return multi(node.content, depth, '| ')
-    }
-    if (type === 'Comment') {
-      const text = node.content
-      return ~text.indexOf(newline)
-        ? multi('//', depth) + newline + multi(text, depth + 1)
-        : multi('//' + text, depth)
-    }
-    let tag = tagName
-    const {id, className} = attributes
-    if (id) tag += `#${id}`
-    if (className) tag += `.${className.join('.')}`
-
-    const redundantDiv = node.tagName === 'div' && tag.length > 3
-    if (redundantDiv) tag = tag.slice(3)
-
-    tag = multi(tag, depth)
-    const attrs = node.attributes
-    const props = Object.keys(attrs).filter(key => {
-      return key !== 'className' && key !== 'id'
-    })
-    if (props.length) {
-      const isXml = doctype === 'xml'
-      tag += '('
-      tag += props.map(prop => {
-        const val = attrs[prop]
-        if (prop === 'dataset') {
-          return Object.keys(val).map(attr => {
-            return serializeAttr('data-' + dasherize(attr), val[attr], isXml)
-          }).join(', ')
-        }
-        if (prop === 'style') return serializeAttr(prop, inlineStyle(val))
-        return serializeAttr(dasherize(prop), val, isXml)
-      }).join(', ')
-      tag += ')'
-    }
-    const lowTagName = node.tagName.toLowerCase()
-    if (arrayIncludes(voidTags, lowTagName)) {
-      if (lowTagName === '!doctype') {
-        if (!doctype) doctype = doctypeShortcut(tag)
-        return multi('doctype ' + doctype, depth)
-      }
-      return tag
-    }
-
-    const {children} = node
-    if (!children.length) return tag
-    if (children.length === 1 && children[0].type === 'Text') {
-      const text = children[0].content
-      return ~text.indexOf(newline)
-        ? tag + '.' + newline + multi(text, depth + 1)
-        : tag + ' ' + text
-    }
-
-    return tag + newline +
-      walk(children.filter(isWhitespaceNode), depth + 1).join(newline)
-  }, 0)
-  if (jade.join) return jade.join(newline)
-  return jade
-}
-
-export function multilineText (indentation) {
-  let format = line => line
-  const hasTab = stringIncludes(indentation, '\t')
-  if (hasTab) {
-    format = line => line.replace(/\t/g, indentation)
-  }
-
-  function indent (depth, str) {
-    while (depth--) {
-      str = indentation + str
-    }
-    return str
-  }
-
-  return function (str, depth, lead = '') {
-    const lines = str
-      .split(newline)
-      .map(format)
-      .filter(line => !!line.trim())
-
-    const start = maxSharedIndent(lines)
-    return lines
-      .map(line => indent(depth, lead + line.slice(start)))
-      .join(newline)
-  }
-}
-
-export function maxSharedIndent (lines) {
-  return lines.reduce(function (num, line) {
-    return Math.min(num, line.length - line.trimLeft().length)
-  }, Infinity)
-}
-
-// see http://jade-lang.com/reference/doctype/
-export function doctypeShortcut (str) {
-  if (stringIncludes(str, 'Transitional')) return 'transitional'
-  if (stringIncludes(str, 'strict')) return 'strict'
-  if (stringIncludes(str, 'Frameset')) return 'frameset'
-  if (stringIncludes(str, 'Basic')) return 'basic'
-  if (stringIncludes(str, '1.1')) return '1.1'
-  if (stringIncludes(str, 'Mobile')) return 'mobile'
-  return 'html'
-}
-
-export default {
-  toHTML,
-  toPug
-}
diff --git a/test/formats/v1-integration.js b/test/format.js
similarity index 81%
rename from test/formats/v1-integration.js
rename to test/format.js
index ed697af..153085c 100644
--- a/test/formats/v1-integration.js
+++ b/test/format.js
@@ -1,6 +1,19 @@
 import test from 'ava'
-import himalaya from '../../'
-import format from '../../lib/formats/v1'
+import {parse, parseDefaults} from '../'
+import {formatAttributes} from '../lib/format'
+
+test('formatAttributes() should return a key-value array', t => {
+  const attributes = [
+    'foo="bar"',
+    'disabled',
+    'cake=\'man\''
+  ]
+  t.deepEqual(formatAttributes(attributes), [
+    {key: 'foo', value: 'bar'},
+    {key: 'disabled', value: null},
+    {key: 'cake', value: 'man'}
+  ])
+})
 
 /*
 These tests ensure the parser and v1 formatting align.
@@ -10,12 +23,6 @@ Do not add any more of these kinds of tests, instead
 test the more granular bits.
 */
 
-const parseDefaults = Object.assign(
-  {},
-  himalaya.parseDefaults,
-  {format}
-)
-
 test('parse() should pass the Hello World case', t => {
   const html = '<html><h1>Hello, World</h1></html>'
   const data = [{
@@ -32,7 +39,7 @@ test('parse() should pass the Hello World case', t => {
       }]
     }]
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('parse() should work for mixed attributes', t => {
@@ -65,7 +72,7 @@ test('parse() should work for mixed attributes', t => {
       }]
     }]
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('parse() should work for commented html', t => {
@@ -82,7 +89,7 @@ test('parse() should work for commented html', t => {
       content: 'words'
     }]
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('parse() should work for style properties', t => {
@@ -96,7 +103,7 @@ test('parse() should work for style properties', t => {
     }],
     children: []
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('parse() should work on data-* attributes', t => {
@@ -116,7 +123,7 @@ test('parse() should work on data-* attributes', t => {
     }],
     children: []
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('should work on unclosed tags', t => {
@@ -138,7 +145,7 @@ test('should work on unclosed tags', t => {
       content: 'three four'
     }]
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('should not set custom attrs to zeroes', t => {
@@ -152,7 +159,7 @@ test('should not set custom attrs to zeroes', t => {
     }],
     children: []
   }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
+  t.deepEqual(data, parse(html, parseDefaults))
 })
 
 test('custom tags should appear in the ast', t => {
@@ -167,7 +174,7 @@ test('custom tags should appear in the ast', t => {
         content: 'Hello'
       }]
     }]
-    t.deepEqual(data, himalaya.parse(html, parseDefaults))
+    t.deepEqual(data, parse(html, parseDefaults))
   }
 
   {
@@ -191,6 +198,6 @@ test('custom tags should appear in the ast', t => {
         children: []
       }]
     }]
-    t.deepEqual(data, himalaya.parse(html, parseDefaults))
+    t.deepEqual(data, parse(html, parseDefaults))
   }
 })
diff --git a/test/formats/v0-integration.js b/test/formats/v0-integration.js
deleted file mode 100644
index 3c44911..0000000
--- a/test/formats/v0-integration.js
+++ /dev/null
@@ -1,191 +0,0 @@
-import test from 'ava'
-import himalaya from '../../'
-import format from '../../lib/formats/v0'
-
-/*
-These tests ensure the parser and v0 formatting align.
-
-These tests mainly serve as a gauntlet for generic use.
-Do not add any more of these kinds of tests, instead
-test the more granular bits.
-*/
-
-const parseDefaults = Object.assign(
-  {},
-  himalaya.parseDefaults,
-  {format}
-)
-
-test('parse() should pass the Hello World case', t => {
-  const html = '<html><h1>Hello, World</h1></html>'
-  const data = [{
-    type: 'Element',
-    tagName: 'html',
-    attributes: {},
-    children: [{
-      type: 'Element',
-      tagName: 'h1',
-      attributes: {},
-      children: [{
-        type: 'Text',
-        content: 'Hello, World'
-      }]
-    }]
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('parse() should work for mixed attributes', t => {
-  const html = "<div class='section widget'><b disabled>Poop</b><p>Pee</p></div>"
-  const data = [{
-    type: 'Element',
-    tagName: 'div',
-    attributes: {
-      className: ['section', 'widget']
-    },
-    children: [{
-      type: 'Element',
-      tagName: 'b',
-      attributes: {
-        disabled: 'disabled'
-      },
-      children: [{
-        type: 'Text',
-        content: 'Poop'
-      }]
-    }, {
-      type: 'Element',
-      tagName: 'p',
-      attributes: {},
-      children: [{
-        type: 'Text',
-        content: 'Pee'
-      }]
-    }]
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('parse() should work for commented html', t => {
-  const html = '<b><!--comment text-->words</b>'
-  const data = [{
-    type: 'Element',
-    tagName: 'b',
-    attributes: {},
-    children: [{
-      type: 'Comment',
-      content: 'comment text'
-    }, {
-      type: 'Text',
-      content: 'words'
-    }]
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('parse() should work for style properties', t => {
-  const html = "<div style='width: 360px; height: 120px; background-color: #fff'></div>"
-  const data = [{
-    type: 'Element',
-    tagName: 'div',
-    attributes: {
-      style: {
-        width: '360px',
-        height: '120px',
-        backgroundColor: '#fff'
-      }
-    },
-    children: []
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('parse() should work on data-* attributes', t => {
-  const html = "<div data-num=0 data-word='poop' data-cake='2'></div>"
-  const data = [{
-    type: 'Element',
-    tagName: 'div',
-    attributes: {
-      dataset: {
-        num: 0,
-        word: 'poop',
-        cake: 2
-      }
-    },
-    children: []
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('should work on unclosed tags', t => {
-  const html = '<p>One two<p>three four'
-  const data = [{
-    type: 'Element',
-    tagName: 'p',
-    attributes: {},
-    children: [{
-      type: 'Text',
-      content: 'One two'
-    }]
-  }, {
-    type: 'Element',
-    tagName: 'p',
-    attributes: {},
-    children: [{
-      type: 'Text',
-      content: 'three four'
-    }]
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('should not set custom attrs to zeroes', t => {
-  const html = "<div custom-attr=''></div>"
-  const data = [{
-    type: 'Element',
-    tagName: 'div',
-    attributes: {customAttr: ''},
-    children: []
-  }]
-  t.deepEqual(data, himalaya.parse(html, parseDefaults))
-})
-
-test('custom tags should appear in the ast', t => {
-  {
-    const html = '<result>Hello</result>'
-    const data = [{
-      type: 'Element',
-      tagName: 'result',
-      attributes: {},
-      children: [{
-        type: 'Text',
-        content: 'Hello'
-      }]
-    }]
-    t.deepEqual(data, himalaya.parse(html, parseDefaults))
-  }
-
-  {
-    const html = `<div><h1>Hi there</h1><result></result></div>`
-    const data = [{
-      type: 'Element',
-      tagName: 'div',
-      attributes: {},
-      children: [{
-        type: 'Element',
-        tagName: 'h1',
-        attributes: {},
-        children: [{
-          type: 'Text',
-          content: 'Hi there'
-        }]
-      }, {
-        type: 'Element',
-        tagName: 'result',
-        attributes: {},
-        children: []
-      }]
-    }]
-    t.deepEqual(data, himalaya.parse(html, parseDefaults))
-  }
-})
diff --git a/test/formats/v0.js b/test/formats/v0.js
deleted file mode 100644
index 1b61fec..0000000
--- a/test/formats/v0.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import test from 'ava'
-import {castValue, formatStyles} from '../../lib/formats/v0'
-
-test('castValue() should return a number if the text is only a number', t => {
-  t.is(castValue('12'), 12)
-  t.is(castValue(''), '')
-  t.is(castValue('this has a 12'), 'this has a 12')
-  t.is(castValue('1abc'), '1abc')
-})
-
-test('formatStyles() should return an hashmap of style declarations', t => {
-  var style = 'color: #000; height: 80px'
-  var data = {
-    color: '#000',
-    height: '80px'
-  }
-  t.deepEqual(data, formatStyles(style))
-})
-
-test('formatStyles() should camelCase CSS properties', t => {
-  const style = [
-    'background-color: #fff',
-    'border-right: 1px solid #000',
-    'border-top-left-radius: 4px'
-  ].join(';')
-  const data = {
-    backgroundColor: '#fff',
-    borderRight: '1px solid #000',
-    borderTopLeftRadius: '4px'
-  }
-  t.deepEqual(data, formatStyles(style))
-})
-
-test('formatStyles() should handle colons in CSS values', t => {
-  const style = 'background-image: url(http://example.com/x.img)'
-  t.deepEqual(formatStyles(style), {
-    backgroundImage: 'url(http://example.com/x.img)'
-  })
-})
-
-test('formatStyles() should preserve quoted values', t => {
-  const doubleStyle = 'content: "hello"'
-  t.deepEqual(formatStyles(doubleStyle), {
-    content: '"hello"'
-  })
-
-  const singleStyle = "content: 'hello'"
-  t.deepEqual(formatStyles(singleStyle), {
-    content: "'hello'"
-  })
-})
diff --git a/test/formats/v1.js b/test/formats/v1.js
deleted file mode 100644
index 9b2f1eb..0000000
--- a/test/formats/v1.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import test from 'ava'
-import {formatAttributes} from '../../lib/formats/v1'
-
-test('formatAttributes() should return a key-value array', t => {
-  const attributes = [
-    'foo="bar"',
-    'disabled',
-    'cake=\'man\''
-  ]
-  t.deepEqual(formatAttributes(attributes), [
-    {key: 'foo', value: 'bar'},
-    {key: 'disabled', value: null},
-    {key: 'cake', value: 'man'}
-  ])
-})
diff --git a/test/lexer.js b/test/lexer.js
index c8ffc6a..00c8811 100644
--- a/test/lexer.js
+++ b/test/lexer.js
@@ -49,6 +49,21 @@ test('lexer should parse tags beginning with alphanumeric names', t => {
   }
 })
 
+test('lexer should skip lexing the content of childless tags', t => {
+  const str = '<template>Hello <img/></template>'
+  const options = {childlessTags: ['template']}
+  const tokens = lexer(str, options)
+  t.deepEqual(tokens, [
+    {type: 'tag-start', close: false},
+    {type: 'tag', content: 'template'},
+    {type: 'tag-end', close: false},
+    {type: 'text', content: 'Hello <img/>'},
+    {type: 'tag-start', close: true},
+    {type: 'tag', content: 'template'},
+    {type: 'tag-end', close: false}
+  ])
+})
+
 test('findTextEnd should find the end of the text segment', t => {
   t.is(findTextEnd('</end', 0), 0)
   t.is(findTextEnd('<= 4', 0), -1)
@@ -260,6 +275,40 @@ test('lexTagAttributes should handle tab separated attributes', t => {
   ])
 })
 
+test('lexTagAttributes should handle prefixed spacing', t => {
+  const str = '  \n\tyes="no">abcd'
+  const finish = str.indexOf('>abcd')
+  const state = {str, cursor: 0, tokens: []}
+  lexTagAttributes(state)
+  t.is(state.cursor, finish)
+  t.deepEqual(state.tokens, [
+    {type: 'attribute', content: 'yes="no"'}
+  ])
+})
+
+test('lexTagAttributes should handle unquoted one-word values', t => {
+  const str = 'num=8 ham = steak>abcd'
+  const finish = str.indexOf('>abcd')
+  const state = {str, cursor: 0, tokens: []}
+  lexTagAttributes(state)
+  t.is(state.cursor, finish)
+  t.deepEqual(state.tokens, [
+    {type: 'attribute', content: 'num=8'},
+    {type: 'attribute', content: 'ham=steak'}
+  ])
+})
+
+test('lexTagAttributes should handle incomplete attributes', t => {
+  const str = 'x = >abcd'
+  const finish = str.indexOf('>abcd')
+  const state = {str, cursor: 0, tokens: []}
+  lexTagAttributes(state)
+  t.is(state.cursor, finish)
+  t.deepEqual(state.tokens, [
+    {type: 'attribute', content: 'x'}
+  ])
+})
+
 test('lexSkipTag should tokenize as text until the matching tag name', t => {
   const str = 'abcd<test><h1>Test case</h1></test><x>'
   const finish = str.indexOf('<x>')
diff --git a/test/parser.js b/test/parser.js
index 53479ed..4ebd423 100644
--- a/test/parser.js
+++ b/test/parser.js
@@ -113,6 +113,42 @@ test('parser() should handle optional-close tags', t => {
   }
 })
 
+test('parser() should auto-close unmatched child tags', t => {
+  const parserOptions = {
+    voidTags: [],
+    closingTags: [],
+    closingTagAncestorBreakers: {}
+  }
+  const str = '<div>This is <b>one <span>okay</div>'
+  const tokens = lexer(str, lexerOptions)
+  const nodes = parser(tokens, parserOptions)
+  t.deepEqual(nodes, [{
+    type: 'element',
+    tagName: 'div',
+    attributes: [],
+    children: [{
+      type: 'text',
+      content: 'This is '
+    }, {
+      type: 'element',
+      tagName: 'b',
+      attributes: [],
+      children: [{
+        type: 'text',
+        content: 'one '
+      }, {
+        type: 'element',
+        tagName: 'span',
+        attributes: [],
+        children: [{
+          type: 'text',
+          content: 'okay'
+        }]
+      }]
+    }]
+  }])
+})
+
 test('parser() should handle empty token arrays', t => {
   const tokens = []
   const nodes = parser(tokens, parserOptions)
diff --git a/test/stringify.js b/test/stringify.js
new file mode 100644
index 0000000..f9e63f4
--- /dev/null
+++ b/test/stringify.js
@@ -0,0 +1,63 @@
+import test from 'ava'
+import {parse, stringify} from '../lib'
+import {formatAttributes} from '../lib/stringify'
+
+test('stringify() should handle simple conversions', t => {
+  const str1 = '<h1>Text</h1>'
+  t.is(stringify(parse(str1)), str1)
+
+  const str2 = 'Text'
+  t.is(stringify(parse(str2)), str2)
+
+  const str3 = '<!--Comment-->'
+  t.is(stringify(parse(str3)), str3)
+})
+
+test('stringify() should work for void elements', t => {
+  const meta = "<meta charset='utf8'>"
+  t.is(stringify(parse(meta)), meta)
+
+  const link = "<link rel='stylesheet' href='file.css'>"
+  t.is(stringify(parse(link)), link)
+})
+
+test('stringify() should build the class attribute properly', t => {
+  const elem = "<div class='foo bar baz'></div>"
+  t.is(stringify(parse(elem)), elem)
+})
+
+test('stringify() should build data-* attributes properly', t => {
+  const elem = "<div data-one='5' data-two='five'></div>"
+  t.is(stringify(parse(elem)), elem)
+})
+
+test('stringify() should build the style attribute properly', t => {
+  const elem = "<div style='color: #fff; font-size: 12px'></div>"
+  t.is(stringify(parse(elem)), elem)
+})
+
+test('stringify() should do basic escaping if a value contains either single or double quotes', t => {
+  const html = '<div data-val="cake is \'good\'"></div>'
+  t.is(stringify(parse(html)), html)
+})
+
+test('stringify() should preserve whitespace', t => {
+  const html = [
+    '<html>    ',
+    '    <h1>    Document    </h1>',
+    '</html>   '
+  ].join('\n')
+  t.is(stringify(parse(html)), html)
+})
+
+test('formatAttributes should stringify attribute lists correctly', t => {
+  t.is(formatAttributes([]), '')
+  t.is(formatAttributes([{
+    key: 'disabled',
+    value: null
+  }]), ' disabled')
+  t.is(formatAttributes([{
+    key: 'data-key',
+    value: '123'
+  }]), " data-key='123'")
+})
diff --git a/test/translate/v0.js b/test/translate/v0.js
deleted file mode 100644
index b5ed886..0000000
--- a/test/translate/v0.js
+++ /dev/null
@@ -1,266 +0,0 @@
-import test from 'ava'
-import himalaya from '../../lib'
-import format from '../../lib/formats/v0'
-import translate from '../../lib/translate/v0'
-const {toHTML, toPug} = translate
-
-const parseDefaults = Object.assign(
-  {},
-  himalaya.parseDefaults,
-  {format}
-)
-
-const parse = html => himalaya.parse(html, parseDefaults)
-
-test('toHTML() should handle simple conversions', t => {
-  const str1 = '<h1>Text</h1>'
-  t.is(toHTML(parse(str1)), str1)
-
-  const str2 = 'Text'
-  t.is(toHTML(parse(str2)), str2)
-
-  const str3 = '<!--Comment-->'
-  t.is(toHTML(parse(str3)), str3)
-})
-
-test('toHTML() should work for void elements', t => {
-  const meta = "<meta charset='utf8'>"
-  t.is(toHTML(parse(meta)), meta)
-
-  const link = "<link rel='stylesheet' href='file.css'>"
-  t.is(toHTML(parse(link)), link)
-})
-
-test('toHTML() should build the class attribute properly', t => {
-  const elem = "<div class='foo bar baz'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should build data-* attributes properly', t => {
-  const elem = "<div data-one='5' data-two='five'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should build the style attribute properly', t => {
-  const elem = "<div style='color: #fff; font-size: 12px'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should do basic escaping if a value contains either single or double quotes', t => {
-  const html = '<div data-val="cake is \'good\'"></div>'
-  t.is(toHTML(parse(html)), html)
-})
-
-test('toHTML() should handle receiving a single root node', t => {
-  const html = '<div><p>Words are words.</p></div>'
-  t.is(toHTML(parse(html)[0]), html)
-})
-
-test('toHTML() should preserve whitespace', t => {
-  const html = [
-    '<html>    ',
-    '    <h1>    Document    </h1>',
-    '</html>   '
-  ].join('\n')
-  t.is(toHTML(parse(html)), html)
-})
-
-test('toHTML() should close void tags when doctype is xml', t => {
-  const html = "<img src='bar.png'>"
-  const xml = "<img src='bar.png'></img>"
-  const jsonHTML = parse(html)
-  const jsonXML = parse(xml)
-
-  t.is(toHTML(jsonHTML), html)
-  t.is(toHTML(jsonHTML, {
-    doctype: 'xml'
-  }), xml)
-
-  t.is(toHTML(jsonXML), html)
-  t.is(toHTML(jsonXML, {
-    doctype: 'xml'
-  }), xml)
-})
-
-test('toHTML() should write out boolean attributes when doctype is xml', t => {
-  const html = "<script src='bar.js' async></script>"
-  const xml = "<script src='bar.js' async='async'></script>"
-  const jsonHTML = parse(html)
-  const jsonXML = parse(xml)
-
-  t.is(toHTML(jsonHTML), html)
-  t.is(toHTML(jsonHTML, {
-    doctype: 'xml'
-  }), xml)
-
-  t.is(toHTML(jsonXML), html)
-  t.is(toHTML(jsonXML, {
-    doctype: 'xml'
-  }), xml)
-})
-
-test('toPug() should handle plain text', t => {
-  const html = 'This is text.'
-  const jade = '| This is text.'
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should handle multi-line plain text', t => {
-  const html = 'This is multiline text.\nLook newlines.'
-  const jade = '| This is multiline text.\n| Look newlines.'
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should handle inline comments', t => {
-  const html = '<!-- Comment -->'
-  const jade = '// Comment '
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should handle multi-line comments', t => {
-  const html = [
-    '<!--',
-    '  This is a multiline comment.',
-    '  Look newlines.',
-    '-->'
-  ].join('\n')
-  const jade = [
-    '//',
-    '  This is a multiline comment.',
-    '  Look newlines.'
-  ].join('\n')
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should write short-hand tag ids', t => {
-  const html = "<article id='story'></article>"
-  const jade = 'article#story'
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should write short-hand tag classes', t => {
-  const html = "<article class='story story--main'></article>"
-  const jade = 'article.story.story--main'
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should ignore `div` if an id or class(es) are provided', t => {
-  const htmlId = "<div id='block'></div>"
-  const jadeId = '#block'
-  t.is(toPug(parse(htmlId)), jadeId)
-
-  const htmlClass = "<div class='block'></div>"
-  const jadeClass = '.block'
-  t.is(toPug(parse(htmlClass)), jadeClass)
-
-  const htmlClasses = "<div class='block block--jumbo'></div>"
-  const jadeClasses = '.block.block--jumbo'
-  t.is(toPug(parse(htmlClasses)), jadeClasses)
-})
-
-test('toPug() should write attributes', t => {
-  const html = "<canvas width='500' height='400'></canvas>"
-  const jade = "canvas(width='500', height='400')"
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should write data-* attributes', t => {
-  const html = "<div data-one='5' data-two='five'></div>"
-  const jade = "div(data-one='5', data-two='five')"
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should do basic escaping if a value contains either single or double quotes', t => {
-  const html = '<div data-val="cake is \'good\'"></div>'
-  const jade = 'div(data-val="cake is \'good\'")'
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should write the style attribute', t => {
-  const html = "<b style='font-weight: bold; font-style: italics'>Word</b>"
-  const jade = "b(style='font-weight: bold; font-style: italics') Word"
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should appropriate place tag inner text', t => {
-  const htmlInline = '<h1>Hello</h1>'
-  const jadeInline = 'h1 Hello'
-  t.is(toPug(parse(htmlInline)), jadeInline)
-
-  const htmlMultiline = '<h1>Hello\nWorld</h1>'
-  const jadeMultiline = 'h1.\n  Hello\n  World'
-  t.is(toPug(parse(htmlMultiline)), jadeMultiline)
-})
-
-test('toPug() should use tabs for indentation if configured', t => {
-  const html = '<h1>Hello\nWorld</h1>'
-  const jade = 'h1.\n\t\tHello\n\t\tWorld'
-  const jadeOptions = {indentation: '\t\t'}
-  t.is(toPug(parse(html), jadeOptions), jade)
-})
-
-test('toPug() should work for script and style tags', t => {
-  const htmlScript = "<script type='text/javascript'>console.log('yes');\nconsole.log('no');</script>"
-  const jadeScript = "script(type='text/javascript').\n  console.log('yes');\n  console.log('no');"
-  t.is(toPug(parse(htmlScript)), jadeScript)
-
-  const htmlStyle = '<style>\nh1 {color: #fff;}\n.text {font-size: 12px;}</style>'
-  const jadeStyle = 'style.\n  h1 {color: #fff;}\n  .text {font-size: 12px;}'
-  t.is(toPug(parse(htmlStyle)), jadeStyle)
-})
-
-test('toPug() should handle receiving a single root node', t => {
-  const html = '<div><p>Words are words.</p></div>'
-  const jade = [
-    'div',
-    '  p Words are words.'
-  ].join('\n')
-  t.is(toPug(parse(html)[0]), jade)
-})
-
-test('toPug() should work for void tags', t => {
-  const html = '<img src="cake.png"/>'
-  const jade = "img(src='cake.png')"
-  t.is(toPug(parse(html)), jade)
-})
-
-test('toPug() should prioritize using a configured doctype', t => {
-  const html = '<!doctype html>'
-  const jade = 'doctype foobar'
-  const jadeOptions = {doctype: 'foobar', indentation: '  '}
-  t.is(toPug(parse(html), jadeOptions), jade)
-})
-
-test('toPug() should produce proper shorthand doctypes', t => {
-  const cases = [
-    [
-      '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
-      'doctype transitional'
-    ],
-    [
-      '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
-      'doctype frameset'
-    ],
-    [
-      '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
-      'doctype strict'
-    ],
-    [
-      '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
-      'doctype basic'
-    ],
-    [
-      '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
-      'doctype 1.1'
-    ],
-    [
-      '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
-      'doctype mobile'
-    ],
-    ['<!doctype html>', 'doctype html']
-  ]
-
-  cases.forEach(([html, jade]) => {
-    t.is(toPug(parse(html)), jade)
-  })
-})
diff --git a/test/translate/v1.js b/test/translate/v1.js
deleted file mode 100644
index 5a1be6f..0000000
--- a/test/translate/v1.js
+++ /dev/null
@@ -1,61 +0,0 @@
-import test from 'ava'
-import himalaya from '../../lib'
-import format from '../../lib/formats/v1'
-import translate from '../../lib/translate/v1'
-const {toHTML} = translate
-
-const parseDefaults = Object.assign(
-  {},
-  himalaya.parseDefaults,
-  {format}
-)
-
-const parse = html => himalaya.parse(html, parseDefaults)
-
-test('toHTML() should handle simple conversions', t => {
-  const str1 = '<h1>Text</h1>'
-  t.is(toHTML(parse(str1)), str1)
-
-  const str2 = 'Text'
-  t.is(toHTML(parse(str2)), str2)
-
-  const str3 = '<!--Comment-->'
-  t.is(toHTML(parse(str3)), str3)
-})
-
-test('toHTML() should work for void elements', t => {
-  const meta = "<meta charset='utf8'>"
-  t.is(toHTML(parse(meta)), meta)
-
-  const link = "<link rel='stylesheet' href='file.css'>"
-  t.is(toHTML(parse(link)), link)
-})
-
-test('toHTML() should build the class attribute properly', t => {
-  const elem = "<div class='foo bar baz'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should build data-* attributes properly', t => {
-  const elem = "<div data-one='5' data-two='five'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should build the style attribute properly', t => {
-  const elem = "<div style='color: #fff; font-size: 12px'></div>"
-  t.is(toHTML(parse(elem)), elem)
-})
-
-test('toHTML() should do basic escaping if a value contains either single or double quotes', t => {
-  const html = '<div data-val="cake is \'good\'"></div>'
-  t.is(toHTML(parse(html)), html)
-})
-
-test('toHTML() should preserve whitespace', t => {
-  const html = [
-    '<html>    ',
-    '    <h1>    Document    </h1>',
-    '</html>   '
-  ].join('\n')
-  t.is(toHTML(parse(html)), html)
-})
diff --git a/text/translation.md b/text/translation.md
deleted file mode 100644
index 4a367d7..0000000
--- a/text/translation.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# Himalaya Translations
-
-This document describes the functions included with the Himalaya parser for transforming the [abstract syntax tree](https://github.com/andrejewski/himalaya/tree/master/docs/ast-spec.md) into different HTML-based languages.
-
-## Version 1 Translations
-
-```js
-import himalaya from 'himalaya'
-import {toHTML} from 'himalaya/lib/translate/v1'
-
-const source = "<img src='bar.png' async>"
-const json = himalaya.parse(source)
-
-const html = toHTML(json)
-// => "<img src='bar.png' async>"
-```
-
-*Note: Version 1 does not include the `toPug` transform.*
-
-## Version 0 Translations
-
-The language translations included are for HTML and [Pug](https://pugjs.org/api/getting-started.html).
-
-```js
-import himalaya from 'himalaya'
-import {toHTML, toPug} from 'himalaya/lib/translate/v0'
-
-const source = "<img src='bar.png' async>"
-const json = himalaya.parse(source)
-
-const html = toHTML(json)
-// => "<img src='bar.png' async>"
-
-const pug = toPug(json)
-// => "img(src='bar.png' async)"
-
-const xml = toHTML(json, {doctype: 'xml'})
-// => "<img src='bar.png' async='async'></img>"
-
-const pugXml = toPug(json, {doctype: 'xml'})
-// => "img(src='bar.png', async='async')"
-```
-
-### toHTML(ast, [options]) HTML
-The HTML translator takes a given **ast** and an optional **options** object containing:
-
-- `doctype` which if set to `"xml"` will render boolean attributes and void tags in XML format
-
-### toPug(ast, [options]) Pug
-The Pug translator takes a given **ast** and an optional **options** object containing:
-
-- `doctype` which if set to `"xml"` will render boolean attributes in XML format
-- `indentation` defaults to two spaces
-
-The Pug translator is not a one-to-one translation with HTML. HTML transformed into Pug and then into HTML will lose some of the original's whitespace.
diff --git a/translate.js b/translate.js
deleted file mode 100644
index 37c24fa..0000000
--- a/translate.js
+++ /dev/null
@@ -1 +0,0 @@
-module.exports = require('./lib/translate/v0').default