0.2.1

README.md

@@ -8,39 +8,26 @@ Inline local assets referenced in an HTML document.
 [![David](https://img.shields.io/david/panosoft/inline-html.svg)](https://david-dm.org/panosoft/inline-html)
 [![npm downloads](https://img.shields.io/npm/dm/inline-html.svg)](https://www.npmjs.com/package/inline-html)
 
-## Installation
+This library parses HTML, embeds the contents of local assets that are referenced within that HTML, and returns a new inlined HTML string.
 
-```sh
-npm install inline-html
-```
+The following HTML elements and CSS data types are inlined:
+
+- Images - The source path is replaced with a datauri.
+
+- Linked LESS stylesheets - The LESS is compiled and the result is inlined within a `<style>` element. Note that `@imports` are processed as well.
+
+- CSS url data types - The reference path is replaced with a datauri. These can be used in linked stylesheets, style elements, and element style attributes.
+
+Also, `inline-html` calls can be statically evaluated and included in Browserify bundles using the [`html-inlinify`](https://github.com/panosoft/html-inlinify) transform.
 
 ## Usage
 
-Reads an HTML file, embeds the contents of local assets that are referenced within that file, and returns the inlined `html` string.
-
-The following elements and data types are inlined:
-
-- LESS stylesheets - The LESS is compiled and the result is inlined within a `<style>` element.
-- CSS url data types - The reference path is replaced with a datauri. These can be used in linked stylesheets, style elements, and element style attributes.
-- Images - The source path is replaced with a datauri.
-
-Assuming we have the following files:
-
-- `index.html`
-
-	```html
-	<link rel="stylesheet/less" href="main.less"/>
-	<style>
-		div { background-image: url('path/to/file'); }
-	</style>
-	<div style="background-image: url('path/to/file');"></div>
-	<img src="path/to/file"/>
-	```
+Assuming ...
 
 - `main.less`
 
 	```css
-	@import (inline) 'main.css';
+	@import (less) 'main.css';
 	div { background-image: url('path/to/file'); }
 	```
 
@@ -50,57 +37,110 @@ Assuming we have the following files:
 	@font-face { src: url('path/to/file'); }
 	```
 
-We can use `inline-html`:
+Then ...
 
 ```js
-var inlineHtml = require('inline-html');
+var co = require('co');
+var inline = require('inline-html');
 
-inlineHtml('index.html').then(function (html) {
-	// ...
+co(function * () {
+	var html = `
+		<link rel="stylesheet/less" href="main.less"/>
+		<style> div { background-image: url('path/to/file'); } </style>
+		<div style="background-image: url('path/to/file');"></div>
+		<img src="path/to/file"/>
+	`;
+	html = yield inline.html(html);
+	console.log(html);
+	/**
+		<style>
+			@font-face { src: url('data:...'); }
+			div { background-image: url('data:...'); }
+		</style>
+		<style> div { background-image: url('data:...'); } </style>
+		<div style="background-image: url('data:...');"></div>
+		<img src="data:..."/>
+	 */
 });
 ```
 
-To create the following `html` string:
+## Installation
 
-```html
-<style>
-	@font-face { src: url('data:...'); }
-	div { background-image: url('data:...'); }
-</style>
-<style>
-	div { background-image: url('data:...'); }
-</style>
-<div style="background-image: url('data:...');"></div>
-<img src="data:..."/>
+```sh
+npm install inline-html
 ```
 
 ## API
 
-- [`inlineHtml`](#inlineHtml)
+- [`inline.html`](#html)
+- [`inline.file`](#file)
+- [`Results`](#results)
 
 ---
 
-<a name="inlineHtml"/>
-### inlineHtml ( html [, options] )
+<a name="html"/>
+### inline.html ( html [, options] )
 
-Reads an HTML file and embeds referenced local assets into the HTML.
+Parses an HTML string and embeds referenced local assets into the HTML.
 
-Returns a `Promise` that is fulfilled with an `html` string or an instance of [`Results`](#Results) depending on the value of `options.verbose`.
+Returns a `Promise` that is fulfilled with an `html` string or an instance of [`Results`](#results) depending on the value of `options.verbose`.
 
 __Arguments__
 
-- `html` - An HTML string or a filename of an HTML file to inline. Relative file paths are resolved relative to `options.filename` if a string or the filename's directory if a filename.
+- `html` - An HTML string to inline.
+
+
 - `options`
-	- `filename` - The filename used to resolve relative paths when `html` is a string. If `html` is a string and this option is not provided, relative paths will be resolved relative to the process's current working directory.
+	- `filename` - The filename used to resolve relative paths. If this option is not provided, relative paths will be resolved relative to the process's current working directory.
 	- `less` - An object containing LESS options to pass to the less compiler. Defaults to `{}`.
 	- `verbose` - A boolean that determines the promises fulfillment value. Supported values are:
-		- `true`: An instance of [`Results`](#Results).
-		- `false`: An `html` string. (_default_)
+		- `true`: An instance of [`Results`](#results).
+		- `false`: An `html` string. (_Default_)
 
-<a name="Results"/>
-__Results__
+__Example__
 
-The `Promise` returned by this function is optionally fulfilled with a `results` object that has the following properties:
+```js
+co(function * () {
+	var html = yield inline.html(`<img src="test.png">`);
+	console.log(html); // <img src="data:...">
+});
+```
+
+---
+
+<a name="file"/>
+### inline.file ( filename [, options] )
+
+Reads an HTML file and embeds referenced local assets into the HTML.
+
+Returns a `Promise` that is fulfilled with an `html` string or an instance of [`Results`](#results) depending on the value of `options.verbose`.
+
+__Arguments__
+
+- `html` - A filename of an HTML file to inline. Relative file paths are resolved relative to the filename's directory.
+
+
+- `options`
+	- `less` - An object containing LESS options to pass to the less compiler. Defaults to `{}`.
+	- `verbose` - A boolean that determines the promises fulfillment value. Supported values are:
+		- `true`: An instance of [`Results`](#results).
+		- `false`: An `html` string. (_Default_)
+
+__Example__
+
+```js
+co(function * () {
+	html = yield inline.file(`index.html`);
+	console.log(html); // <img src="data:...">
+});
+```
+
+---
+
+<a name="results"/>
+### Results
+
+The `Promise` returned by these functions is optionally fulfilled with a `results` object that has the following properties:
 
 - `html` - The inlined html
 - `files` - An array of filenames for the local assets that were inlined.

lib/index.js

@@ -1,57 +1,58 @@
 var co = require('co');
-var cheerio = require('cheerio');
 var fs = require('mz/fs');
 var inlineStyle = require('./inline-style');
 var inlineImg = require('./inline-img');
-var inlineLinkLess = require('./inline-link-less');
+var inlineLess = require('./inline-less');
 var R = require('ramda');
 var Ru = require('@panosoft/ramda-utils');
 
-var inline = co.wrap(function * (html, options) {
+var inlineHtml = {};
+/**
+ * Embed referenced local assets within and HTML file.
+ *
+ * @param {String} html
+ * @param {Object} options
+ *
+ * @return {Promise}
+ */
+inlineHtml.html = co.wrap(function * (html, options) {
 	options = Ru.defaults({
 		filename: null,
 		less: {},
 		verbose: false
 	}, options || {});
-	var filename;
+	var filename = options.filename;
+
+	// Embed assets
+	var files = [filename];
 	try {
-		filename = html;
-		html = yield fs.readFile(filename, 'utf8');
+		var lessResult = yield inlineLess(html, filename, options.less);
+		html = lessResult.html;
+		files = R.concat(files, lessResult.files);
+
+		var styleResult = inlineStyle(html, filename);
+		html = styleResult.html;
+		files = R.concat(files, styleResult.files);
+
+		var imgResult = inlineImg(html, filename);
+		html = imgResult.html;
+		files = R.concat(files, imgResult.files);
 	}
 	catch (error) {
-		if (error.code === 'ENOENT') {
-			filename = options.filename;
-		}
-		else {
-			throw error;
-		}
+		if (!error.filename) error.filename = filename;
+		error.files = R.uniq(R.concat(files, error.files || []));
+		throw error;
 	}
-	var files = [filename];
 
-	// Inline links
-	var lessResult = yield inlineLinkLess(html, filename, options.less);
-	html = lessResult.html;
-	files.push(lessResult.files);
-
-	// TODO inline links: css
-
-	// TODO inline scripts
-	// browserify js? => scriptify
-
-	// Inline paths -> datauris
-	var styleResult = inlineStyle(html, filename); // Inline styles
-	html = styleResult.html;
-	files.push(styleResult.files);
-
-	var imgResult = inlineImg(html, filename); // Inline images
-	html = imgResult.html;
-	files.push(imgResult.files);
-
-	var result = {
-		html: html,
-		files: R.uniq(R.flatten(files, true))
-	};
+	files = R.uniq(files);
+	var result = { html, files };
 	return (options.verbose ? result : result.html);
 });
 
-module.exports = inline;
+inlineHtml.file = co.wrap(function * (filename, options) {
+	var html = yield fs.readFile(filename, 'utf8');
+	options = R.merge(options || {}, {filename});
+	return yield inlineHtml.html(html, options);
+});
+
+module.exports = inlineHtml;

lib/inline-css-url.js

@@ -28,26 +28,34 @@ var clean = function (path) {
  * @param filename
  * @returns {{css: (css|any), files: Array}}
  */
-var inline = function (css, filename) {
+var inlineUrl = function (css, filename) {
 	var files = [];
 	var basePath = path.dirname(filename);
 	var result = postcss()
 		.use(postcssUrl({
 			url: function (urlPath) {
 				if (isLocalPath(urlPath) && !isTemplateExpression(urlPath)) {
-					urlPath = clean(urlPath);
-					urlPath = path.resolve(basePath, urlPath);
-					files.push(urlPath);
-					urlPath = datauri(urlPath);
+					try {
+						urlPath = clean(urlPath);
+						urlPath = path.resolve(basePath, urlPath);
+						files = R.append(urlPath, files);
+						urlPath = datauri(urlPath);
+					}
+					catch (error) {
+						error.filename = filename;
+						error.files = R.uniq(files);
+						throw error;
+					}
 				}
 				return urlPath;
 			}
 		}))
 		.process(css);
+	files = R.uniq(files);
 	return {
 		css: result.css,
-		files: files
+		files
 	};
 };
 
-module.exports = inline;
+module.exports = inlineUrl;

lib/inline-img.js

@@ -3,25 +3,34 @@ var datauri = require('datauri');
 var isLocalPath = require('is-local-path');
 var isTemplateExpression = require('./is-template-expression');
 var path = require('path');
+var R = require('ramda');
 
 var inline = function (html, filename) {
 	var files = [];
 	var basedir = path.dirname(filename);
 	var $ = cheerio.load(html, {decodeEntities: false});
-	var images = $('img').filter(function (index, element) {
+	var $images = $('img').filter((index, element) => {
 		var path = $(element).attr('src');
 		return isLocalPath(path) && !isTemplateExpression(path);
 	});
-	images.each(function (index, element) {
-		var src = $(element).attr('src');
-		var filename = path.resolve(basedir, src);
-		files.push(filename);
-		src = datauri(filename);
-		$(element).attr('src', src);
-	});
+	try {
+		$images.each((index, element) => {
+			var source = $(element).attr('src');
+			var filename = path.resolve(basedir, source);
+			files = R.append(filename, files);
+			var uri = datauri(filename);
+			$(element).attr('src', uri);
+		});
+	}
+	catch (error) {
+		error.filename = filename;
+		error.files = R.uniq(files);
+		throw error;
+	}
+	files = R.uniq(files);
 	return {
 		html: $.xml(),
-		files: files
+		files
 	};
 };
 

lib/inline-less.js

@@ -0,0 +1,67 @@
+var co = require('co');
+var cheerio = require('cheerio');
+var fs = require('mz/fs');
+var isLocalPath = require('is-local-path');
+var less = require('less');
+var path = require('path');
+var R = require('ramda');
+var Ru = require('@panosoft/ramda-utils');
+
+var render = co.wrap(function * (filename, options) {
+	options = R.merge(options || {}, { filename });
+	var contents = yield fs.readFile(filename, 'utf8');
+	return yield less.render(contents, options);
+});
+/**
+ * @param {String} html
+ * 	HTML source to inline
+ * @param {String} filename
+ * 	Filename to apply to the HTML source being inlined
+ * @param {Object} options
+ * 	LESS compiler options
+ */
+var inlineLess = co.wrap(function * (html, filename, options) {
+	options = Ru.defaults({
+		relativeUrls: true
+	}, options || {});
+	var basedir = path.dirname(filename);
+
+	// get links
+	var $ = cheerio.load(html, {decodeEntities: false});
+	var $links = $('link[rel="stylesheet/less"]')
+		.filter((index, element) => isLocalPath($(element).attr('href')));
+
+	// render LESS stylesheets
+	var files = [];
+	var outputs = [];
+	try {
+		$links.each((index, element) => {
+			var href = $(element).attr('href');
+			var filename = path.resolve(basedir, href);
+			files = R.append(filename, files);
+			outputs = R.append(render(filename, options), outputs);
+		});
+		outputs = yield outputs;
+	}
+	catch (error) {
+		if (!error.filename) error.filename = filename;
+		error.files = R.uniq(files);
+		throw error;
+	}
+
+	// include imported filenames in files array
+	files = R.concat(files, R.flatten(R.map(output => output.imports, outputs)));
+	files = R.uniq(files);
+
+	// replace links
+	$links.each((index, element) => {
+		var style = $('<style>').html(outputs[index].css);
+		$(element).replaceWith(style);
+	});
+
+	return {
+		html: $.xml(),
+		files
+	};
+});
+module.exports = inlineLess;

lib/inline-link-less.js

@@ -1,65 +0,0 @@
-var co = require('co');
-var cheerio = require('cheerio');
-var fs = require('mz/fs');
-var isLocalPath = require('is-local-path');
-var less = require('less');
-var path = require('path');
-var R = require('ramda');
-var Ru = require('@panosoft/ramda-utils');
-var url = require('url');
-
-var render = co.wrap(function * (filename, options) {
-	options = R.merge(options || {}, {
-		filename: filename
-	});
-	var contents = yield fs.readFile(filename, 'utf8');
-	return yield less.render(contents, options);
-});
-/**
- * @params html
- * 	HTML to inline
- * @params options
- * 	LESS compiler options
- */
-var inline = co.wrap(function * (html, filename, options) {
-	var files = [];
-	var basedir = path.dirname(filename);
-	options = Ru.defaults({
-		relativeUrls: true
-	}, options || {});
-
-	// TODO Import less links
-	// get links
-	var $ = cheerio.load(html, {decodeEntities: false});
-	var links = $('link[rel="stylesheet/less"]')
-		.filter(function (index, element) {
-			return isLocalPath($(element).attr('href'));
-		});
-
-	// render stylesheets
-	var outputs = [];
-	links.each(function (index, element) {
-		var href = $(element).attr('href');
-		var filename = path.resolve(basedir, href);
-		files.push(filename);
-		outputs.push(render(filename, options));
-	});
-	outputs = yield outputs;
-
-	// replace links
-	links.each(function (index, element) {
-		var style = $('<style>').html(outputs[index].css);
-		$(element).replaceWith(style);
-	});
-
-	// create list of imported files from all outputs, unique listing
-	files.push(R.map(function (output) {
-		return output.imports;
-	}, outputs));
-
-	return {
-		html: $.xml(),
-		files: files
-	};
-});
-module.exports = inline;

lib/inline-style.js

@@ -1,5 +1,6 @@
 var cheerio = require('cheerio');
 var inlineUrl = require('./inline-css-url');
+var R = require('ramda');
 var string = require('string');
 
 var prefix = 'element {';
@@ -11,34 +12,43 @@ var unwrap = function (value) {
 	var regexp = new RegExp('^' + prefix + '\\s*(.*)\\s*' + suffix + '$');
 	return value.replace(regexp, '$1');
 };
-var inline = function (html, filename) {
+var inlineStyle = function (html, filename) {
 	var files = [];
 	var $ = cheerio.load(html, {decodeEntities: false});
-	// style elements
-	var styles = $('style');
-	styles.each(function (index, element) {
-		var css = $(element).html();
-		var result = inlineUrl(css, filename);
-		files.push(result.files);
-		$(element).html(result.css);
-	});
 
-	// style attributes
-	var attributes = $('*').filter('[style]');
-	attributes.each(function (index, element) {
-		var css = $(element).attr('style');
-		css = wrap(css);
-		var result = inlineUrl(css, filename);
-		files.push(result.files);
-		css = string(result.css).collapseWhitespace().toString();
-		css = unwrap(css);
-		$(element).attr('style', css);
-	});
+	try {
+		// style elements
+		var $styles = $('style');
+		$styles.each((index, element) => {
+			var css = $(element).html();
+			var result = inlineUrl(css, filename);
+			files = R.concat(files, result.files);
+			$(element).html(result.css);
+		});
 
+		// style attributes
+		var $attributes = $('*').filter('[style]');
+		$attributes.each((index, element) => {
+			var css = $(element).attr('style');
+			css = wrap(css);
+			var result = inlineUrl(css, filename);
+			files = R.concat(files, result.files);
+			css = string(result.css).collapseWhitespace().toString();
+			css = unwrap(css);
+			$(element).attr('style', css);
+		});
+	}
+	catch (error) {
+		if (!error.filename) error.filename = filename;
+		error.files = R.uniq(R.concat(files, error.files || []));
+		throw error;
+	}
+
+	files = R.uniq(files);
 	return {
 		html: $.xml(),
-		files: files
+		files
 	};
 };
 
-module.exports = inline;
+module.exports = inlineStyle;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "inline-html",
-  "version": "0.1.10",
+  "version": "0.2.1",
   "description": "Inline local assets referenced in an HTML document.",
   "repository": "panosoft/inline-html",
   "main": "lib/index.js",
@@ -13,7 +13,7 @@
     "@panosoft/ramda-utils": "^0.1.12",
     "cheerio": "^0.19.0",
     "co": "^4.6.0",
-    "datauri": "^0.7.1",
+    "datauri": "^0.8.0",
     "is-local-path": "^0.1.0",
     "less": "^2.5.1",
     "mz": "^2.0.0",

test/fixtures/invalidImport.less

@@ -0,0 +1 @@
+@import (less) 'missing.css';

test/fixtures/invalidSyntax.less

@@ -0,0 +1 @@
+div {

test/fixtures/invalidUrl.less

@@ -0,0 +1,3 @@
+div {
+  background-image: url('missing.png');
+}

test/index.js

@@ -1,176 +1,337 @@
-var inline = require('../lib');
+var co = require('co');
+var datauri = require('datauri');
 var expect = require('chai')
 	.use(require('chai-as-promised'))
 	.expect;
-var datauri = require('datauri');
 var fs = require('fs');
+var inline = require('../lib');
 var path = require('path');
 
-describe('inlineHtml', function () {
+describe('inline-html', () => {
 
-	it('html: filename', function () {
-		var filename = path.resolve(__dirname, './fixtures/file.txt');
-		var content = fs.readFileSync(filename, 'utf8');
-		return expect(inline(filename)).to.eventually.equal(content);
-	});
-	it('html: string', function () {
-		var html = 'HTML';
-		return expect(inline(html)).to.eventually.equal(html);
+	describe('file()', () => {
+		it('exists', () => expect(inline).to.have.property('file').that.is.a('function'));
+
+		it('accept html filename', () => {
+			var filename = path.resolve(__dirname, './fixtures/file.txt');
+			var content = fs.readFileSync(filename, 'utf8');
+			return expect(inline.file(filename)).to.eventually.equal(content);
+		});
+
+		it('options.filename: ignored for css url path resolution', () => {
+			var filename = path.resolve(__dirname, 'fixtures/css-url.html'); // file contains url path relative to itself
+			var options = { filename: __filename }; // sets filename relative to this test file
+			return expect(inline.file(filename, options)).to.eventually.match(/"data:.*,.*"/);
+		});
+		it('options.filename: ignored for img src path resolution', () => {
+			var filename = path.resolve(__dirname, 'fixtures/img.html'); // file contains src relative to itself
+			var options = { filename: __filename }; // sets filename relative to this test file
+			return expect(inline.file(filename, options)).to.eventually.match(/"data:.*,.*"/);
+		});
+
+		it('throw error when file not found', () => expect(inline.file('missing.html')).to.eventually.be.rejected);
 	});
 
+	describe('html()', () => {
+		it('exists', () => expect(inline).to.have.property('html').that.is.a('function'));
 
-	it('inline link less', function () {
-		var filename = path.resolve(__dirname, 'fixtures/basic.less');
-		var html = `<link rel="stylesheet/less" href="${filename}"/>`;
-		return expect(inline(html)).to.eventually.match(/<style>[^]*<\/style>/);
-	});
-	it('inline link less imports', function () {
-		var filename = path.resolve(__dirname, 'fixtures/import.less');
-		var html = `<link rel="stylesheet/less" href="${filename}"/>`;
-		return expect(inline(html)).to.eventually.match(/<style>[^]*<\/style>/)
-			.and.not.match(/@import/);
-	});
-	it('inline css url path in style element', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<style>div {background-image: url("${filename}");}</style>`;
-		return expect(inline(html)).to.eventually.match(/data:.*,.*/);
-	});
-	it('inline css url path in element style attribute', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<div style="background-image: url('${filename}');"></div>`;
-		return expect(inline(html)).to.eventually.match(/data:.*,.*/);
-	});
-	it('inline img src', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<img src="${filename}"/>`;
-		return expect(inline(html)).to.eventually.match(/data:.*,.*/);
-	});
+		it('accept html string', () => {
+			var html = 'HTML';
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+
+		it('inline link less', () => {
+			var filename = path.resolve(__dirname, 'fixtures/basic.less');
+			var html = `<link rel="stylesheet/less" href="${filename}"/>`;
+			return expect(inline.html(html)).to.eventually.match(/<style>[^]*<\/style>/);
+		});
+		it('inline link less imports', () => {
+			var filename = path.resolve(__dirname, 'fixtures/import.less');
+			var html = `<link rel="stylesheet/less" href="${filename}"/>`;
+			return expect(inline.html(html)).to.eventually.match(/<style>[^]*<\/style>/)
+				.and.not.match(/@import/);
+		});
+		it('inline css url path in style element', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<style>div {background-image: url("${filename}");}</style>`;
+			return expect(inline.html(html)).to.eventually.match(/data:.*,.*/);
+		});
+		it('inline css url path in element style attribute', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<div style="background-image: url('${filename}');"></div>`;
+			return expect(inline.html(html)).to.eventually.match(/data:.*,.*/);
+		});
+		it('inline img src', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<img src="${filename}"/>`;
+			return expect(inline.html(html)).to.eventually.match(/data:.*,.*/);
+		});
 
 
-	it('options.verbose: return results object if true', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<img src="${filename}"/>`;
-		var options = { verbose: true };
-		return expect(inline(html, options)).to.eventually.be.an('object')
-			.that.contains.keys(['html', 'files']);
-	});
-	it('options.verbose: return html if false', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<img src="${filename}"/>`;
-		var options = { verbose: false };
-		return expect(inline(html, options)).to.eventually.be.a('string');
-	});
-	it('options.verbose: default false', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<img src="${filename}"/>`;
-		return expect(inline(html)).to.eventually.be.a('string');
-	});
+		it('options.verbose: return results object if true', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<img src="${filename}"/>`;
+			var options = { verbose: true };
+			return expect(inline.html(html, options)).to.eventually.be.an('object')
+				.that.contains.keys(['html', 'files']);
+		});
+		it('options.verbose: return html if false', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<img src="${filename}"/>`;
+			var options = { verbose: false };
+			return expect(inline.html(html, options)).to.eventually.be.a('string');
+		});
+		it('options.verbose: default false', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<img src="${filename}"/>`;
+			return expect(inline.html(html)).to.eventually.be.a('string');
+		});
 
 
-	it('options.filename: ignored for css url path resolution if html filename', function () {
-		var html = path.resolve(__dirname, 'fixtures/css-url.html'); // file contains url path relative to itself
-		var options = { filename: __filename }; // sets filename relative to this test file
-		return expect(inline(html, options)).to.eventually.match(/"data:.*,.*"/);
-	});
-	it('options.filename: ignored for img src path resolution if html filename', function () {
-		var html = path.resolve(__dirname, 'fixtures/img.html'); // file contains src relative to itself
-		var options = { filename: __filename }; // sets filename relative to this test file
-		return expect(inline(html, options)).to.eventually.match(/"data:.*,.*"/);
-	});
-	it('options.filename: set basepath for css url path resolution if html string', function () {
-		var filename = path.resolve(__dirname, 'fixtures/fake.html');
-		var dirname = path.dirname(filename);
+		it('options.filename: set basepath for css url path resolution', () => {
+			var filename = path.resolve(__dirname, 'fixtures/fake.html');
+			var dirname = path.dirname(filename);
 
-		var url = 'file.txt'; // Note: path relative to filename's dirname
-		var uri = datauri(path.resolve(dirname, url));
+			var url = 'file.txt'; // Note: path relative to filename's dirname
+			var uri = datauri(path.resolve(dirname, url));
 
-		var html = (path) => `<style>div { background-image: url('${path}'); }</style>`;
-		var options = { filename: filename };
-		return expect(inline(html(url), options)).to.eventually.equal(html(uri));
-	});
-	it('options.filename: set basepath for img src path resolution if html string', function () {
-		var filename = path.resolve(__dirname, 'fixtures/fake.html');
-		var dirname = path.dirname(filename);
+			var html = (path) => `<style>div { background-image: url('${path}'); }</style>`;
+			var options = { filename: filename };
+			return expect(inline.html(html(url), options)).to.eventually.equal(html(uri));
+		});
+		it('options.filename: set basepath for img src path resolution', () => {
+			var filename = path.resolve(__dirname, 'fixtures/fake.html');
+			var dirname = path.dirname(filename);
 
-		var url = 'file.txt'; // Note: path relative to filename's dirname
-		var uri = datauri(path.resolve(dirname, url));
+			var url = 'file.txt'; // Note: path relative to filename's dirname
+			var uri = datauri(path.resolve(dirname, url));
 
-		var html = (path) => `<img src="${path}"/>`;
-		var options = { filename: filename };
-		return expect(inline(html(url), options)).to.eventually.equal(html(uri));
-	});
-	it('options.filename: default to cwd for css url path resolution if html string', function () {
-		var url = 'test/fixtures/file.txt'; // Note: this is relative to cwd
-		var uri = datauri(url);
+			var html = (path) => `<img src="${path}"/>`;
+			var options = { filename: filename };
+			return expect(inline.html(html(url), options)).to.eventually.equal(html(uri));
+		});
+		it('options.filename: default to cwd for css url path resolution', () => {
+			var url = 'test/fixtures/file.txt'; // Note: this is relative to cwd
+			var uri = datauri(url);
 
-		var html = (path) => `<style>div { background-image: url('${path}'); }</style>`;
-		return expect(inline(html(url))).to.eventually.equal(html(uri));
-	});
-	it('options.filename: default to cwd for img src path resolution if html string', function () {
-		var url = 'test/fixtures/file.txt'; // Note: path relative to cwd
-		var uri = datauri(url);
+			var html = (path) => `<style>div { background-image: url('${path}'); }</style>`;
+			return expect(inline.html(html(url))).to.eventually.equal(html(uri));
+		});
+		it('options.filename: default to cwd for img src path resolution', () => {
+			var url = 'test/fixtures/file.txt'; // Note: path relative to cwd
+			var uri = datauri(url);
 
-		var html = (path) => `<img src="${path}"/>`;
-		return expect(inline(html(url))).to.eventually.equal(html(uri));
-	});
-	it('options.filename: included in results.files for img src if html string and options.verbose true', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<img src="${filename}"/>`;
-		var options = { verbose: true };
-		return expect(inline(html, options)).to.eventually.have.property('files')
-			.that.is.an('array')
-			.that.contains(filename);
-	});
-	it('options.filename: included in results.files for css url path if html string and options.verbose true', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var html = `<style>div { background-image: url('${filename}'); }</style>`;
-		var options = { verbose: true };
-		return expect(inline(html, options)).to.eventually.have.property('files')
-			.that.is.an('array')
-			.that.contains(filename);
-	});
+			var html = (path) => `<img src="${path}"/>`;
+			return expect(inline.html(html(url))).to.eventually.equal(html(uri));
+		});
+		it('options.filename: included in results.files for img src if options.verbose true', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<img src="${filename}"/>`;
+			var options = { verbose: true };
+			return expect(inline.html(html, options)).to.eventually.have.property('files')
+				.that.is.an('array')
+				.that.contains(filename);
+		});
+		it('options.filename: included in results.files for css url path if options.verbose true', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var html = `<style>div { background-image: url('${filename}'); }</style>`;
+			var options = { verbose: true };
+			return expect(inline.html(html, options)).to.eventually.have.property('files')
+				.that.is.an('array')
+				.that.contains(filename);
+		});
 
 
-	it('preserve self closing tags', function () {
-		var html = '<br/>';
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('preserve partials', function () {
-		var html = '{{> partial}}';
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('preserve helpers', function () {
-		var html = '{{helper}}';
-		return expect(inline(html)).to.eventually.equal(html);
+		it('preserve self closing tags', () => {
+			var html = '<br/>';
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('preserve partials', () => {
+			var html = '{{> partial}}';
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('preserve helpers', () => {
+			var html = '{{helper}}';
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+
+		it('ignore css url remote paths', () => {
+			var html = `<style> div { background-image: url('http://test.com/file.txt?query=string#hash'); }</style>`;
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('ignore img src remote paths', () => {
+			var html = `<img src="http://test.com/file.txt?query=string#hash"/>`;
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('ignore css url template expression paths', () => {
+			var html = `<style> div { background-image: url({{path}}); }</style>`;
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('ignore img src template expression paths', () => {
+			var html = `<img src="{{path}}"/>`;
+			return expect(inline.html(html)).to.eventually.equal(html);
+		});
+		it('ignore query strings and hashes on local paths', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file.txt');
+			var url = `${filename}?query=string#hash`;
+			var uri = datauri(filename);
+			var html = (source) => `<style> div { background-image: url('${source}'); }</style>`;
+			return expect(inline.html(html(url))).to.eventually.equal(html(uri));
+		});
+		it('handle assets with a space in their filename', () => {
+			var filename = path.resolve(__dirname, 'fixtures/file space.txt');
+			var uri = datauri(filename);
+			var html = (source) => `<style> div { background-image: url('${source}'); }</style>`;
+			return expect(inline.html(html(filename))).to.eventually.equal(html(uri));
+		});
+
+		// Error handling
+		// inline-img
+		it('throw error when html image source invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var source = 'missing.png';
+				var html = `<img src="${source}" >`;
+				var resolvedSource = path.resolve(path.dirname(filename), source);
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(resolvedSource);
+				}
+			});
+		});
+		// inline-style
+		it('throw error when html style attribute syntax invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var html = `<div style="background url()"></div>`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(filename);
+				}
+			});
+		});
+		it('throw error when html style attribute url invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var url = 'missing.png';
+				var resolvedUrl = path.resolve(path.dirname(filename), url);
+				var html = `<div style="background-image: url('${url}')"></div>`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(resolvedUrl);
+				}
+			});
+		});
+		it('throw error when html style syntax invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var html = `<style>div {</style>`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(filename);
+				}
+			});
+		});
+		it('throw error when html style url invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var url = 'missing.png';
+				var resolvedUrl = path.resolve(path.dirname(filename), url);
+				var html = `<style>div { background-image: url('${url}'); }</style>`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(resolvedUrl);
+				}
+			});
+		});
+		// inline-link-less
+		it('throw error when link href invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'index.html');
+				var href = 'missing.less';
+				var resolvedHref = path.resolve(path.dirname(filename), href);
+				var html = `<link rel="stylesheet/less" href="${href}">`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(resolvedHref);
+				}
+			});
+		});
+		it('throw error when less import invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'fixtures/index.html');
+				var lessBasename = 'invalidImport.less';
+				var lessFilename = path.resolve(path.dirname(filename), lessBasename);
+				var html = `<link rel="stylesheet/less" href="${lessBasename}">`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(lessFilename);
+					expect(error).to.have.property('files').that.contains(lessFilename);
+				}
+			});
+		});
+		it('throw error when less syntax invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'fixtures/index.html');
+				var lessBasename = 'invalidSyntax.less';
+				var lessFilename = path.resolve(path.dirname(filename), lessBasename);
+				var html = `<link rel="stylesheet/less" href="${lessBasename}">`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					expect(error).to.have.property('filename').that.equals(lessFilename);
+					expect(error).to.have.property('files').that.contains(lessFilename);
+				}
+			});
+		});
+		it('throw error when less url invalid', () => {
+			return co(function * () {
+				var filename = path.resolve(__dirname, 'fixtures/index.html');
+				var lessBasename = 'invalidUrl.less';
+				var lessFilename = path.resolve(path.dirname(filename), lessBasename);
+				var badUrl = path.resolve(path.dirname(filename), 'missing.png');
+				var html = `<link rel="stylesheet/less" href="${lessBasename}">`;
+				try {
+					yield inline.html(html, {filename});
+					throw new Error('No error thrown');
+				}
+				catch (error) {
+					// expect error.filename to be html file, not less file, since images
+					// aren't inlined until after the compiled less has been inlined into the html.
+					expect(error).to.have.property('filename').that.equals(filename);
+					expect(error).to.have.property('files').that.contains(badUrl);
+				}
+			});
+		});
 	});
 
-	it('ignore css url remote paths', function () {
-		var html = `<style> div { background-image: url('http://test.com/file.txt?query=string#hash'); }</style>`;
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('ignore img src remote paths', function () {
-		var html = `<img src="http://test.com/file.txt?query=string#hash"/>`;
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('ignore css url template expression paths', function () {
-		var html = `<style> div { background-image: url({{path}}); }</style>`;
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('ignore img src template expression paths', function () {
-		var html = `<img src="{{path}}"/>`;
-		return expect(inline(html)).to.eventually.equal(html);
-	});
-	it('ignore query strings and hashes on local paths', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file.txt');
-		var url = `${filename}?query=string#hash`;
-		var uri = datauri(filename);
-		var html = (source) => `<style> div { background-image: url('${source}'); }</style>`;
-		return expect(inline(html(url))).to.eventually.equal(html(uri));
-	});
-	it('handle assets with a space in their filename', function () {
-		var filename = path.resolve(__dirname, 'fixtures/file space.txt');
-		var uri = datauri(filename);
-		var html = (source) => `<style> div { background-image: url('${source}'); }</style>`;
-		return expect(inline(html(filename))).to.eventually.equal(html(uri));
-	});
 });