From 1da64f85f4739dad4fc1e06bcbb315281adbcbf9 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 12:27:29 +1200
Subject: [PATCH 01/66] Added tests.

---
 tests/minifier.js | 243 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 243 insertions(+)

diff --git a/tests/minifier.js b/tests/minifier.js
index 4f71d662..16cf76cf 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3397,3 +3397,246 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
     canCollapseWhitespace: canCollapseAndTrimWhitespace
   }), output);
 });
+
+QUnit.test('style minification with callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; color: white }</style>';
+  var output = '<style>div#foo { background-color: red; color: white } callback!</style>';
+  var done = assert.async();
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('script minification with callback', function(assert) {
+  var input = '<script>(function(){ console.log("Hello"); })()</script>';
+  var output = '<script>(function(){ console.log("Hello"); })()(function(){ console.log("World"); })()</script>';
+  var done = assert.async();
+  assert.notOk(minify(
+    input,
+    {
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + '(function(){ console.log("World"); })()');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('style async minification with script sync minification', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var output = '<style>div#foo { background-color: red; } callback!</style><script>console.log("Hello World")</script>';
+  var done = assert.async();
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      },
+      minifyJS: true
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('style sync minification with script async minification', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var output = '<style>div#foo{background-color:red}</style><script>console . log("Hello World") ; callback!</script>';
+  var done = assert.async();
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: true,
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('style async minification with script async minification', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
+  var done = assert.async();
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      },
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+
+QUnit.test('async minification along side sync minification', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var syncOutput = '<style>div#foo{background-color:red}</style><script>console.log("Hello World")</script>';
+  var asyncOutput = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
+  var done = assert.async();
+
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      },
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, asyncOutput);
+      done();
+    }
+  ));
+
+  assert.equal(minify(input, {
+    minifyCSS: true,
+    minifyJS: true
+  }), syncOutput);
+});
+
+QUnit.test('multiple async minifications', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
+  var done = assert.async(2);
+
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      },
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          cb(css + ' callback!');
+        }, 0);
+      },
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          cb(js + ' callback!');
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('sync minify with callback', function(assert) {
+  var input = '<html><head><title>Test</title></head><body>Hello World</body></html>';
+  var output = input;
+  var done = assert.async();
+  assert.equal(minify(
+    input,
+    {},
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ), output);
+});
+
+
+QUnit.test('minify error with callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><invalid html';
+  var done = assert.async();
+
+  minify(
+    input,
+    {},
+    function(error) {
+      assert.ok(error);
+      done();
+    }
+  );
+});
+
+QUnit.test('error in callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style>';
+  var error = new Error();
+  var done = assert.async();
+
+  minify(
+    input,
+    {
+      minifyCSS: function() {
+        throw error;
+      }
+    },
+    function(err) {
+      assert.strictEqual(err, error);
+      done();
+    }
+  );
+});

From 736a572123356e5eade4741132eeb54aff49b6a4 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 12:29:02 +1200
Subject: [PATCH 02/66] Added callback parameter to minify.

---
 src/htmlminifier.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 7748f1c6..1ab95f8b 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -803,7 +803,7 @@ function createSortFns(value, options, uidIgnore, uidAttr) {
   }
 }
 
-function minify(value, options, partialMarkup) {
+function minify(value, options, partialMarkup, cb) {
   options = options || {};
   var optionsStack = [];
   processOptions(options);
@@ -1300,6 +1300,6 @@ function joinResultSegments(results, options) {
   return options.collapseWhitespace ? collapseWhitespace(str, options, true, true) : str;
 }
 
-exports.minify = function(value, options) {
-  return minify(value, options);
+exports.minify = function(value, options, cb) {
+  return minify(value, options, null, cb);
 };

From b773ab494909342a05c656e4ee789ae1511cb91d Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 12:30:08 +1200
Subject: [PATCH 03/66] Added callback parameter to minifyCSS and minifyJS.

---
 src/htmlminifier.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 1ab95f8b..ea298d5f 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -867,14 +867,14 @@ function minify(value, options, partialMarkup, cb) {
         uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)(\\s*)', 'g');
         var minifyCSS = options.minifyCSS;
         if (minifyCSS) {
-          options.minifyCSS = function(text) {
-            return minifyCSS(escapeFragments(text));
+          options.minifyCSS = function(text, cb) {
+            return minifyCSS(escapeFragments(text), cb);
           };
         }
         var minifyJS = options.minifyJS;
         if (minifyJS) {
-          options.minifyJS = function(text, inline) {
-            return minifyJS(escapeFragments(text), inline);
+          options.minifyJS = function(text, inline, cb) {
+            return minifyJS(escapeFragments(text), inline, cb);
           };
         }
       }

From fdf4ca38bb32409dd27f7ff3958fe85c3bc61a6f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 14:22:20 +1200
Subject: [PATCH 04/66] Create a placeholder class for async text.

---
 src/htmlminifier.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index ea298d5f..68d8c39b 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -803,6 +803,29 @@ function createSortFns(value, options, uidIgnore, uidAttr) {
   }
 }
 
+/**
+ * A placeholder for text that will be set later.
+ *
+ * @constructor
+ */
+function AsyncTextPlaceholder() {}
+
+/**
+ * Set the value this placeholder has.
+ *
+ * @param {string} value
+ */
+AsyncTextPlaceholder.prototype.setValue = function(value) {
+  this.value = value;
+};
+
+AsyncTextPlaceholder.prototype.toString = function() {
+  if (this.value) {
+    return this.value;
+  }
+  return '[[Placeholder]]';
+};
+
 function minify(value, options, partialMarkup, cb) {
   options = options || {};
   var optionsStack = [];

From b71cc2fbd278942555199bc1af0479d2a30954a4 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 14:24:31 +1200
Subject: [PATCH 05/66] When processing entries in the buffer, make sure they
 are a string.

This allows instances of AsyncTextPlaceholder to be put into the buffer.
---
 src/htmlminifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 68d8c39b..25890c37 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1304,7 +1304,7 @@ function joinResultSegments(results, options) {
     var lines = [];
     var line = '';
     for (var i = 0, len = results.length; i < len; i++) {
-      token = results[i];
+      token = String(results[i]);
       if (line.length + token.length < maxLineLength) {
         line += token;
       }

From d9104aca702107cb47902df4ec1928641c521f45 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 14:31:22 +1200
Subject: [PATCH 06/66] The result is only finalize and returned if there are
 no async tasks running.

---
 src/htmlminifier.js | 84 ++++++++++++++++++++++++++-------------------
 1 file changed, 48 insertions(+), 36 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 25890c37..fd1e52ad 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -964,6 +964,7 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
+  var asyncTasksWaitingFor = 0;
   new HTMLParser(value, {
     partialMarkup: partialMarkup,
     html5: options.html5,
@@ -1251,49 +1252,60 @@ function minify(value, options, partialMarkup, cb) {
     customAttrSurround: options.customAttrSurround
   });
 
-  if (options.removeOptionalTags) {
-    // <html> may be omitted if first thing inside is not comment
-    // <head> or <body> may be omitted if empty
-    if (topLevelTags(optionalStartTag)) {
-      removeStartTag();
+  function finalize() {
+    if (options.removeOptionalTags) {
+      // <html> may be omitted if first thing inside is not comment
+      // <head> or <body> may be omitted if empty
+      if (topLevelTags(optionalStartTag)) {
+        removeStartTag();
+      }
+      // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
+      if (optionalEndTag && !trailingTags(optionalEndTag)) {
+        removeEndTag();
+      }
     }
-    // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
-    if (optionalEndTag && !trailingTags(optionalEndTag)) {
-      removeEndTag();
+    if (options.collapseWhitespace) {
+      squashTrailingWhitespace('br');
     }
-  }
-  if (options.collapseWhitespace) {
-    squashTrailingWhitespace('br');
-  }
 
-  var str = joinResultSegments(buffer, options);
+    var str = joinResultSegments(buffer, options);
 
-  if (uidPattern) {
-    str = str.replace(uidPattern, function(match, prefix, index, suffix) {
-      var chunk = ignoredCustomMarkupChunks[+index][0];
-      if (options.collapseWhitespace) {
-        if (prefix !== '\t') {
-          chunk = prefix + chunk;
-        }
-        if (suffix !== '\t') {
-          chunk += suffix;
+    if (uidPattern) {
+      str = str.replace(uidPattern, function(match, prefix, index, suffix) {
+        var chunk = ignoredCustomMarkupChunks[+index][0];
+        if (options.collapseWhitespace) {
+          if (prefix !== '\t') {
+            chunk = prefix + chunk;
+          }
+          if (suffix !== '\t') {
+            chunk += suffix;
+          }
+          return collapseWhitespace(chunk, {
+            preserveLineBreaks: options.preserveLineBreaks,
+            conservativeCollapse: !options.trimCustomFragments
+          }, /^[ \n\r\t\f]/.test(chunk), /[ \n\r\t\f]$/.test(chunk));
         }
-        return collapseWhitespace(chunk, {
-          preserveLineBreaks: options.preserveLineBreaks,
-          conservativeCollapse: !options.trimCustomFragments
-        }, /^[ \n\r\t\f]/.test(chunk), /[ \n\r\t\f]$/.test(chunk));
-      }
-      return chunk;
-    });
-  }
-  if (uidIgnore) {
-    str = str.replace(new RegExp('<!--' + uidIgnore + '([0-9]+)-->', 'g'), function(match, index) {
-      return ignoredMarkupChunks[+index];
-    });
+        return chunk;
+      });
+    }
+    if (uidIgnore) {
+      str = str.replace(new RegExp('<!--' + uidIgnore + '([0-9]+)-->', 'g'), function(match, index) {
+        return ignoredMarkupChunks[+index];
+      });
+    }
+
+    options.log('minified in: ' + (Date.now() - t) + 'ms');
+    return str;
   }
 
-  options.log('minified in: ' + (Date.now() - t) + 'ms');
-  return str;
+  // No async tasks running?
+  if (asyncTasksWaitingFor === 0) {
+    var result = finalize();
+    if (typeof cb === 'function') {
+      cb(null, result);
+    }
+    return result;
+  }
 }
 
 function joinResultSegments(results, options) {

From 79e5f8dc2196483e72dbadd0bfc58c64c25ca82f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 14:36:33 +1200
Subject: [PATCH 07/66] Set up minifyJS and minifyCSS to be able to complete
 asynchronously.

---
 src/htmlminifier.js | 64 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 61 insertions(+), 3 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index fd1e52ad..ba640e09 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1184,11 +1184,66 @@ function minify(value, options, partialMarkup, cb) {
       if (options.processScripts && specialContentTags(currentTag)) {
         text = processScript(text, options, currentAttrs);
       }
+
+      var runningAsyncTask = false;
+
+      /**
+       * To be called when running an async task.
+       *
+       * @param {AsyncTextPlaceholder} placeholder
+       */
+      function onAsyncTask(placeholder) {
+        buffer.push(placeholder);
+        runningAsyncTask = true;
+        asyncTasksWaitingFor++;
+      }
+
+      /**
+       * Returns the callback function for an async task.
+       *
+       * @param {AsyncTextPlaceholder} placeholder
+       * @returns {Function}
+       */
+      function getAsyncTaskCallback(placeholder) {
+        return function(result) {
+          if (!runningAsyncTask) {
+            throw new Error('Async completion has already occurred.');
+          }
+          runningAsyncTask = false;
+          placeholder.setValue(result);
+          if (--asyncTasksWaitingFor === 0) {
+            if (typeof cb === 'function') {
+              cb(null, finalize());
+            }
+          }
+        };
+      }
+
       if (isExecutableScript(currentTag, currentAttrs)) {
-        text = options.minifyJS(text);
+        var minifyJSPlaceholder = new AsyncTextPlaceholder();
+        var minifyJSResult = options.minifyJS(text, null, getAsyncTaskCallback(minifyJSPlaceholder));
+
+        // Running asynchronously?
+        if (typeof minifyJSResult === 'undefined') {
+          onAsyncTask(minifyJSPlaceholder);
+        }
+        // Finished synchronously?
+        else {
+          text = minifyJSResult;
+        }
       }
       if (isStyleSheet(currentTag, currentAttrs)) {
-        text = options.minifyCSS(text);
+        var minifyCSSPlaceholder = new AsyncTextPlaceholder();
+        var minifyCSSResult = options.minifyCSS(text, getAsyncTaskCallback(minifyCSSPlaceholder));
+
+        // Running asynchronously?
+        if (typeof minifyCSSResult === 'undefined') {
+          onAsyncTask(minifyCSSPlaceholder);
+        }
+        // Finished synchronously?
+        else {
+          text = minifyCSSResult;
+        }
       }
       if (options.removeOptionalTags && text) {
         // <html> may be omitted if first thing inside is not comment
@@ -1219,7 +1274,10 @@ function minify(value, options, partialMarkup, cb) {
       if (text) {
         hasChars = true;
       }
-      buffer.push(text);
+      // Not running an async task?
+      if (!runningAsyncTask) {
+        buffer.push(text);
+      }
     },
     comment: function(text, nonStandard) {
       var prefix = nonStandard ? '<!' : '<!--';

From 7b2864fd681ff893626c496a815c1bbb6e7d9b14 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 14:56:34 +1200
Subject: [PATCH 08/66] Added error handling.

---
 src/htmlminifier.js | 598 +++++++++++++++++++++++---------------------
 1 file changed, 306 insertions(+), 292 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index ba640e09..90abbe78 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -965,350 +965,357 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   var asyncTasksWaitingFor = 0;
-  new HTMLParser(value, {
-    partialMarkup: partialMarkup,
-    html5: options.html5,
-
-    start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-      var lowerTag = tag.toLowerCase();
-
-      if (lowerTag === 'svg') {
-        optionsStack.push(options);
-        var nextOptions = {};
-        for (var key in options) {
-          nextOptions[key] = options[key];
-        }
-        nextOptions.keepClosingSlash = true;
-        nextOptions.caseSensitive = true;
-        options = nextOptions;
-      }
+  var error;
 
-      tag = options.caseSensitive ? tag : lowerTag;
+  try {
+    new HTMLParser(value, {
+      partialMarkup: partialMarkup,
+      html5: options.html5,
 
-      currentTag = tag;
-      charsPrevTag = tag;
-      if (!inlineTextTags(tag)) {
-        currentChars = '';
-      }
-      hasChars = false;
-      currentAttrs = attrs;
-
-      var optional = options.removeOptionalTags;
-      if (optional) {
-        var htmlTag = htmlTags(tag);
-        // <html> may be omitted if first thing inside is not comment
-        // <head> may be omitted if first thing inside is an element
-        // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-        // <colgroup> may be omitted if first thing inside is <col>
-        // <tbody> may be omitted if first thing inside is <tr>
-        if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
-          removeStartTag();
-        }
-        optionalStartTag = '';
-        // end-tag-followed-by-start-tag omission rules
-        if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
-          removeEndTag();
-          // <colgroup> cannot be omitted if preceding </colgroup> is omitted
-          // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
-          optional = !isStartTagMandatory(optionalEndTag, tag);
+      start: function(tag, attrs, unary, unarySlash, autoGenerated) {
+        var lowerTag = tag.toLowerCase();
+
+        if (lowerTag === 'svg') {
+          optionsStack.push(options);
+          var nextOptions = {};
+          for (var key in options) {
+            nextOptions[key] = options[key];
+          }
+          nextOptions.keepClosingSlash = true;
+          nextOptions.caseSensitive = true;
+          options = nextOptions;
         }
-        optionalEndTag = '';
-      }
 
-      // set whitespace flags for nested tags (eg. <code> within a <pre>)
-      if (options.collapseWhitespace) {
-        if (!stackNoTrimWhitespace.length) {
-          squashTrailingWhitespace(tag);
+        tag = options.caseSensitive ? tag : lowerTag;
+
+        currentTag = tag;
+        charsPrevTag = tag;
+        if (!inlineTextTags(tag)) {
+          currentChars = '';
         }
-        if (!unary) {
-          if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
-            stackNoTrimWhitespace.push(tag);
+        hasChars = false;
+        currentAttrs = attrs;
+
+        var optional = options.removeOptionalTags;
+        if (optional) {
+          var htmlTag = htmlTags(tag);
+          // <html> may be omitted if first thing inside is not comment
+          // <head> may be omitted if first thing inside is an element
+          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+          // <colgroup> may be omitted if first thing inside is <col>
+          // <tbody> may be omitted if first thing inside is <tr>
+          if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
+            removeStartTag();
           }
-          if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
-            stackNoCollapseWhitespace.push(tag);
+          optionalStartTag = '';
+          // end-tag-followed-by-start-tag omission rules
+          if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
+            removeEndTag();
+            // <colgroup> cannot be omitted if preceding </colgroup> is omitted
+            // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
+            optional = !isStartTagMandatory(optionalEndTag, tag);
           }
+          optionalEndTag = '';
         }
-      }
 
-      var openTag = '<' + tag;
-      var hasUnarySlash = unarySlash && options.keepClosingSlash;
+        // set whitespace flags for nested tags (eg. <code> within a <pre>)
+        if (options.collapseWhitespace) {
+          if (!stackNoTrimWhitespace.length) {
+            squashTrailingWhitespace(tag);
+          }
+          if (!unary) {
+            if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
+              stackNoTrimWhitespace.push(tag);
+            }
+            if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
+              stackNoCollapseWhitespace.push(tag);
+            }
+          }
+        }
 
-      buffer.push(openTag);
+        var openTag = '<' + tag;
+        var hasUnarySlash = unarySlash && options.keepClosingSlash;
 
-      if (options.sortAttributes) {
-        options.sortAttributes(tag, attrs);
-      }
+        buffer.push(openTag);
 
-      var parts = [];
-      for (var i = attrs.length, isLast = true; --i >= 0;) {
-        var normalized = normalizeAttr(attrs[i], attrs, tag, options);
-        if (normalized) {
-          parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
-          isLast = false;
+        if (options.sortAttributes) {
+          options.sortAttributes(tag, attrs);
         }
-      }
-      if (parts.length > 0) {
-        buffer.push(' ');
-        buffer.push.apply(buffer, parts);
-      }
-      // start tag must never be omitted if it has any attributes
-      else if (optional && optionalStartTags(tag)) {
-        optionalStartTag = tag;
-      }
-
-      buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
-
-      if (autoGenerated && !options.includeAutoGeneratedTags) {
-        removeStartTag();
-        optionalStartTag = '';
-      }
-    },
-    end: function(tag, attrs, autoGenerated) {
-      var lowerTag = tag.toLowerCase();
-      if (lowerTag === 'svg') {
-        options = optionsStack.pop();
-      }
-      tag = options.caseSensitive ? tag : lowerTag;
 
-      // check if current tag is in a whitespace stack
-      if (options.collapseWhitespace) {
-        if (stackNoTrimWhitespace.length) {
-          if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
-            stackNoTrimWhitespace.pop();
+        var parts = [];
+        for (var i = attrs.length, isLast = true; --i >= 0;) {
+          var normalized = normalizeAttr(attrs[i], attrs, tag, options);
+          if (normalized) {
+            parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
+            isLast = false;
           }
         }
-        else {
-          squashTrailingWhitespace('/' + tag);
+        if (parts.length > 0) {
+          buffer.push(' ');
+          buffer.push.apply(buffer, parts);
         }
-        if (stackNoCollapseWhitespace.length &&
-          tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
-          stackNoCollapseWhitespace.pop();
+        // start tag must never be omitted if it has any attributes
+        else if (optional && optionalStartTags(tag)) {
+          optionalStartTag = tag;
         }
-      }
 
-      var isElementEmpty = false;
-      if (tag === currentTag) {
-        currentTag = '';
-        isElementEmpty = !hasChars;
-      }
+        buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
 
-      if (options.removeOptionalTags) {
-        // <html>, <head> or <body> may be omitted if the element is empty
-        if (isElementEmpty && topLevelTags(optionalStartTag)) {
+        if (autoGenerated && !options.includeAutoGeneratedTags) {
           removeStartTag();
+          optionalStartTag = '';
+        }
+      },
+      end: function(tag, attrs, autoGenerated) {
+        var lowerTag = tag.toLowerCase();
+        if (lowerTag === 'svg') {
+          options = optionsStack.pop();
         }
-        optionalStartTag = '';
-        // </html> or </body> may be omitted if not followed by comment
-        // </head> may be omitted if not followed by space or comment
-        // </p> may be omitted if no more content in non-</a> parent
-        // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
-        if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
-          removeEndTag();
+        tag = options.caseSensitive ? tag : lowerTag;
+
+        // check if current tag is in a whitespace stack
+        if (options.collapseWhitespace) {
+          if (stackNoTrimWhitespace.length) {
+            if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+              stackNoTrimWhitespace.pop();
+            }
+          }
+          else {
+            squashTrailingWhitespace('/' + tag);
+          }
+          if (stackNoCollapseWhitespace.length &&
+            tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+            stackNoCollapseWhitespace.pop();
+          }
         }
-        optionalEndTag = optionalEndTags(tag) ? tag : '';
-      }
 
-      if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // remove last "element" from buffer
-        removeStartTag();
-        optionalStartTag = '';
-        optionalEndTag = '';
-      }
-      else {
-        if (autoGenerated && !options.includeAutoGeneratedTags) {
+        var isElementEmpty = false;
+        if (tag === currentTag) {
+          currentTag = '';
+          isElementEmpty = !hasChars;
+        }
+
+        if (options.removeOptionalTags) {
+          // <html>, <head> or <body> may be omitted if the element is empty
+          if (isElementEmpty && topLevelTags(optionalStartTag)) {
+            removeStartTag();
+          }
+          optionalStartTag = '';
+          // </html> or </body> may be omitted if not followed by comment
+          // </head> may be omitted if not followed by space or comment
+          // </p> may be omitted if no more content in non-</a> parent
+          // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
+          if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
+            removeEndTag();
+          }
+          optionalEndTag = optionalEndTags(tag) ? tag : '';
+        }
+
+        if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
+          // remove last "element" from buffer
+          removeStartTag();
+          optionalStartTag = '';
           optionalEndTag = '';
         }
         else {
-          buffer.push('</' + tag + '>');
-        }
-        charsPrevTag = '/' + tag;
-        if (!inlineTags(tag)) {
-          currentChars = '';
+          if (autoGenerated && !options.includeAutoGeneratedTags) {
+            optionalEndTag = '';
+          }
+          else {
+            buffer.push('</' + tag + '>');
+          }
+          charsPrevTag = '/' + tag;
+          if (!inlineTags(tag)) {
+            currentChars = '';
+          }
+          else if (isElementEmpty) {
+            currentChars += '|';
+          }
         }
-        else if (isElementEmpty) {
-          currentChars += '|';
+      },
+      chars: function(text, prevTag, nextTag) {
+        prevTag = prevTag === '' ? 'comment' : prevTag;
+        nextTag = nextTag === '' ? 'comment' : nextTag;
+        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+          text = decode(text);
         }
-      }
-    },
-    chars: function(text, prevTag, nextTag) {
-      prevTag = prevTag === '' ? 'comment' : prevTag;
-      nextTag = nextTag === '' ? 'comment' : nextTag;
-      if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-        text = decode(text);
-      }
-      if (options.collapseWhitespace) {
-        if (!stackNoTrimWhitespace.length) {
-          if (prevTag === 'comment') {
-            var prevComment = buffer[buffer.length - 1];
-            if (prevComment.indexOf(uidIgnore) === -1) {
-              if (!prevComment) {
-                prevTag = charsPrevTag;
-              }
-              if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
-                var charsIndex = buffer.length - 2;
-                buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
-                  text = trailingSpaces + text;
-                  return '';
-                });
+        if (options.collapseWhitespace) {
+          if (!stackNoTrimWhitespace.length) {
+            if (prevTag === 'comment') {
+              var prevComment = buffer[buffer.length - 1];
+              if (prevComment.indexOf(uidIgnore) === -1) {
+                if (!prevComment) {
+                  prevTag = charsPrevTag;
+                }
+                if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
+                  var charsIndex = buffer.length - 2;
+                  buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
+                    text = trailingSpaces + text;
+                    return '';
+                  });
+                }
               }
             }
-          }
-          if (prevTag) {
-            if (prevTag === '/nobr' || prevTag === 'wbr') {
-              if (/^\s/.test(text)) {
-                var tagIndex = buffer.length - 1;
-                while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
-                  tagIndex--;
+            if (prevTag) {
+              if (prevTag === '/nobr' || prevTag === 'wbr') {
+                if (/^\s/.test(text)) {
+                  var tagIndex = buffer.length - 1;
+                  while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
+                    tagIndex--;
+                  }
+                  trimTrailingWhitespace(tagIndex - 1, 'br');
                 }
-                trimTrailingWhitespace(tagIndex - 1, 'br');
+              }
+              else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+                text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
               }
             }
-            else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
-              text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
+            if (prevTag || nextTag) {
+              text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
+            }
+            else {
+              text = collapseWhitespace(text, options, true, true);
+            }
+            if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
+              trimTrailingWhitespace(buffer.length - 1, nextTag);
             }
           }
-          if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
-          }
-          else {
-            text = collapseWhitespace(text, options, true, true);
-          }
-          if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
-            trimTrailingWhitespace(buffer.length - 1, nextTag);
+          if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
+            text = collapseWhitespace(text, options, false, false, true);
           }
         }
-        if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
-          text = collapseWhitespace(text, options, false, false, true);
+        if (options.processScripts && specialContentTags(currentTag)) {
+          text = processScript(text, options, currentAttrs);
         }
-      }
-      if (options.processScripts && specialContentTags(currentTag)) {
-        text = processScript(text, options, currentAttrs);
-      }
 
-      var runningAsyncTask = false;
-
-      /**
-       * To be called when running an async task.
-       *
-       * @param {AsyncTextPlaceholder} placeholder
-       */
-      function onAsyncTask(placeholder) {
-        buffer.push(placeholder);
-        runningAsyncTask = true;
-        asyncTasksWaitingFor++;
-      }
+        var runningAsyncTask = false;
+
+        /**
+         * To be called when running an async task.
+         *
+         * @param {AsyncTextPlaceholder} placeholder
+         */
+        function onAsyncTask(placeholder) {
+          buffer.push(placeholder);
+          runningAsyncTask = true;
+          asyncTasksWaitingFor++;
+        }
 
-      /**
-       * Returns the callback function for an async task.
-       *
-       * @param {AsyncTextPlaceholder} placeholder
-       * @returns {Function}
-       */
-      function getAsyncTaskCallback(placeholder) {
-        return function(result) {
-          if (!runningAsyncTask) {
-            throw new Error('Async completion has already occurred.');
-          }
-          runningAsyncTask = false;
-          placeholder.setValue(result);
-          if (--asyncTasksWaitingFor === 0) {
-            if (typeof cb === 'function') {
-              cb(null, finalize());
+        /**
+         * Returns the callback function for an async task.
+         *
+         * @param {AsyncTextPlaceholder} placeholder
+         * @returns {Function}
+         */
+        function getAsyncTaskCallback(placeholder) {
+          return function(result) {
+            if (!runningAsyncTask) {
+              throw new Error('Async completion has already occurred.');
             }
-          }
-        };
-      }
+            runningAsyncTask = false;
+            placeholder.setValue(result);
+            if (--asyncTasksWaitingFor === 0) {
+              if (typeof cb === 'function') {
+                cb(null, finalize());
+              }
+            }
+          };
+        }
 
-      if (isExecutableScript(currentTag, currentAttrs)) {
-        var minifyJSPlaceholder = new AsyncTextPlaceholder();
-        var minifyJSResult = options.minifyJS(text, null, getAsyncTaskCallback(minifyJSPlaceholder));
+        if (isExecutableScript(currentTag, currentAttrs)) {
+          var minifyJSPlaceholder = new AsyncTextPlaceholder();
+          var minifyJSResult = options.minifyJS(text, null, getAsyncTaskCallback(minifyJSPlaceholder));
 
-        // Running asynchronously?
-        if (typeof minifyJSResult === 'undefined') {
-          onAsyncTask(minifyJSPlaceholder);
-        }
-        // Finished synchronously?
-        else {
-          text = minifyJSResult;
+          // Running asynchronously?
+          if (typeof minifyJSResult === 'undefined') {
+            onAsyncTask(minifyJSPlaceholder);
+          }
+          // Finished synchronously?
+          else {
+            text = minifyJSResult;
+          }
         }
-      }
-      if (isStyleSheet(currentTag, currentAttrs)) {
-        var minifyCSSPlaceholder = new AsyncTextPlaceholder();
-        var minifyCSSResult = options.minifyCSS(text, getAsyncTaskCallback(minifyCSSPlaceholder));
+        if (isStyleSheet(currentTag, currentAttrs)) {
+          var minifyCSSPlaceholder = new AsyncTextPlaceholder();
+          var minifyCSSResult = options.minifyCSS(text, getAsyncTaskCallback(minifyCSSPlaceholder));
 
-        // Running asynchronously?
-        if (typeof minifyCSSResult === 'undefined') {
-          onAsyncTask(minifyCSSPlaceholder);
+          // Running asynchronously?
+          if (typeof minifyCSSResult === 'undefined') {
+            onAsyncTask(minifyCSSPlaceholder);
+          }
+          // Finished synchronously?
+          else {
+            text = minifyCSSResult;
+          }
         }
-        // Finished synchronously?
-        else {
-          text = minifyCSSResult;
+        if (options.removeOptionalTags && text) {
+          // <html> may be omitted if first thing inside is not comment
+          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+          if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
+            removeStartTag();
+          }
+          optionalStartTag = '';
+          // </html> or </body> may be omitted if not followed by comment
+          // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
+          if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
+            removeEndTag();
+          }
+          optionalEndTag = '';
         }
-      }
-      if (options.removeOptionalTags && text) {
-        // <html> may be omitted if first thing inside is not comment
-        // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-        if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-          removeStartTag();
+        charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+          // semi-colon can be omitted
+          // https://mathiasbynens.be/notes/ambiguous-ampersands
+          text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
         }
-        optionalStartTag = '';
-        // </html> or </body> may be omitted if not followed by comment
-        // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-        if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-          removeEndTag();
+        if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+          text = text.replace(uidPattern, function(match, prefix, index) {
+            return ignoredCustomMarkupChunks[+index][0];
+          });
         }
-        optionalEndTag = '';
-      }
-      charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-      if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-        // semi-colon can be omitted
-        // https://mathiasbynens.be/notes/ambiguous-ampersands
-        text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
-      }
-      if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-        text = text.replace(uidPattern, function(match, prefix, index) {
-          return ignoredCustomMarkupChunks[+index][0];
-        });
-      }
-      currentChars += text;
-      if (text) {
-        hasChars = true;
-      }
-      // Not running an async task?
-      if (!runningAsyncTask) {
-        buffer.push(text);
-      }
-    },
-    comment: function(text, nonStandard) {
-      var prefix = nonStandard ? '<!' : '<!--';
-      var suffix = nonStandard ? '>' : '-->';
-      if (isConditionalComment(text)) {
-        text = prefix + cleanConditionalComment(text, options) + suffix;
-      }
-      else if (options.removeComments) {
-        if (isIgnoredComment(text, options)) {
-          text = '<!--' + text + '-->';
+        currentChars += text;
+        if (text) {
+          hasChars = true;
+        }
+        // Not running an async task?
+        if (!runningAsyncTask) {
+          buffer.push(text);
+        }
+      },
+      comment: function(text, nonStandard) {
+        var prefix = nonStandard ? '<!' : '<!--';
+        var suffix = nonStandard ? '>' : '-->';
+        if (isConditionalComment(text)) {
+          text = prefix + cleanConditionalComment(text, options) + suffix;
+        }
+        else if (options.removeComments) {
+          if (isIgnoredComment(text, options)) {
+            text = '<!--' + text + '-->';
+          }
+          else {
+            text = '';
+          }
         }
         else {
-          text = '';
+          text = prefix + text + suffix;
         }
-      }
-      else {
-        text = prefix + text + suffix;
-      }
-      if (options.removeOptionalTags && text) {
-        // preceding comments suppress tag omissions
-        optionalStartTag = '';
-        optionalEndTag = '';
-      }
-      buffer.push(text);
-    },
-    doctype: function(doctype) {
-      buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
-    },
-    customAttrAssign: options.customAttrAssign,
-    customAttrSurround: options.customAttrSurround
-  });
+        if (options.removeOptionalTags && text) {
+          // preceding comments suppress tag omissions
+          optionalStartTag = '';
+          optionalEndTag = '';
+        }
+        buffer.push(text);
+      },
+      doctype: function(doctype) {
+        buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
+      },
+      customAttrAssign: options.customAttrAssign,
+      customAttrSurround: options.customAttrSurround
+    });
+  }
+  catch (err) {
+    error = err;
+  }
 
   function finalize() {
     if (options.removeOptionalTags) {
@@ -1359,9 +1366,16 @@ function minify(value, options, partialMarkup, cb) {
   // No async tasks running?
   if (asyncTasksWaitingFor === 0) {
     var result = finalize();
+
     if (typeof cb === 'function') {
-      cb(null, result);
+      // Call the callback.
+      cb(error, result);
     }
+    else if (error) {
+      // No callback to handle the error?
+      throw error;
+    }
+
     return result;
   }
 }

From 99b55ed8499f7e11d1966545f5dad8d2e9cdaa81 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 15:06:40 +1200
Subject: [PATCH 09/66] Removed extra empty lines.

---
 tests/minifier.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 16cf76cf..085c3ed0 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3510,7 +3510,6 @@ QUnit.test('style async minification with script async minification', function(a
   ));
 });
 
-
 QUnit.test('async minification along side sync minification', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
   var syncOutput = '<style>div#foo{background-color:red}</style><script>console.log("Hello World")</script>';
@@ -3607,7 +3606,6 @@ QUnit.test('sync minify with callback', function(assert) {
   ), output);
 });
 
-
 QUnit.test('minify error with callback', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><invalid html';
   var done = assert.async();

From a7c0584ddda5087671dd1621911cdb91a8523772 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 15:07:32 +1200
Subject: [PATCH 10/66] "along side" --> "alongside"

---
 tests/minifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 085c3ed0..0b5e56c6 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3510,7 +3510,7 @@ QUnit.test('style async minification with script async minification', function(a
   ));
 });
 
-QUnit.test('async minification along side sync minification', function(assert) {
+QUnit.test('async minification alongside sync minification', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
   var syncOutput = '<style>div#foo{background-color:red}</style><script>console.log("Hello World")</script>';
   var asyncOutput = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';

From ee14967a2bce791d6b4390e6694143eb825705dd Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 15:08:21 +1200
Subject: [PATCH 11/66] Added extra check to 'minify error with callback' test.

---
 tests/minifier.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/minifier.js b/tests/minifier.js
index 0b5e56c6..59567a62 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3615,6 +3615,7 @@ QUnit.test('minify error with callback', function(assert) {
     {},
     function(error) {
       assert.ok(error);
+      assert.equal(error.message, 'Parse Error: <invalid html');
       done();
     }
   );

From 3a6846d35f16f256f16faa7c4cd1e3e2d37c5b95 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 15:09:53 +1200
Subject: [PATCH 12/66] Added a test to ensure the minifyCSS and miniftJS
 callbacks can only be called once.

---
 tests/minifier.js | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/tests/minifier.js b/tests/minifier.js
index 59567a62..381ab646 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3639,3 +3639,50 @@ QUnit.test('error in callback', function(assert) {
     }
   );
 });
+
+QUnit.test('call callback multiple times', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
+  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
+  var done = assert.async(3);
+
+  minify(
+    input,
+    {
+      minifyCSS: function(css, cb) {
+        setTimeout(function() {
+          try {
+            cb(css + ' callback!');
+            cb(css + ' callback!');
+
+            assert.ok(false, 'An error should be thrown.');
+            done();
+          }
+          catch (error) {
+            assert.equal(error.message, 'Async completion has already occurred.');
+            done();
+          }
+        }, 0);
+      },
+      minifyJS: function(js, inline, cb) {
+        setTimeout(function() {
+          try {
+            cb(js + ' callback!');
+            cb(js + ' callback!');
+
+            assert.ok(false, 'An error should be thrown.');
+            done();
+          }
+          catch (error) {
+            assert.equal(error.message, 'Async completion has already occurred.');
+            done();
+          }
+        }, 0);
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  );
+});

From 390eacb4044416cdfccb854017be53a8e25954dc Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 17:26:57 +1200
Subject: [PATCH 13/66] Fixed bug with AsyncTextPlaceholder not being able to
 have the emptyString as its value.

---
 src/htmlminifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 90abbe78..4c82d624 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -820,7 +820,7 @@ AsyncTextPlaceholder.prototype.setValue = function(value) {
 };
 
 AsyncTextPlaceholder.prototype.toString = function() {
-  if (this.value) {
+  if (typeof this.value !== 'undefined') {
     return this.value;
   }
   return '[[Placeholder]]';

From e74fcf195fd8b2c59b2fc64841676f377aa46639 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 17:31:46 +1200
Subject: [PATCH 14/66] Fixed bug with error not being given to callback after
 all async tasks have completed.

---
 src/htmlminifier.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 4c82d624..e929fa7a 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1216,7 +1216,12 @@ function minify(value, options, partialMarkup, cb) {
             placeholder.setValue(result);
             if (--asyncTasksWaitingFor === 0) {
               if (typeof cb === 'function') {
-                cb(null, finalize());
+                if (error) {
+                  cb(error, null);
+                }
+                else {
+                  cb(null, finalize());
+                }
               }
             }
           };

From d77176a7540b9e4fe4bdec02e94f5e25981e9f04 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 12 Apr 2018 17:36:52 +1200
Subject: [PATCH 15/66] Added callback information to the readme.

---
 README.md | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 60 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index b925130e..9fc93921 100644
--- a/README.md
+++ b/README.md
@@ -58,8 +58,8 @@ Most of the options are disabled by default.
 | `includeAutoGeneratedTags`     | Insert tags generated by HTML parser | `true` |
 | `keepClosingSlash`             | Keep the trailing slash on singleton elements | `false` |
 | `maxLineLength`                | Specify a maximum line length. Compressed output will be split by newlines at valid HTML split-points |
-| `minifyCSS`                    | Minify CSS in style elements and style attributes (uses [clean-css](https://github.com/jakubpawlowicz/clean-css)) | `false` (could be `true`, `Object`, `Function(text)`) |
-| `minifyJS`                     | Minify JavaScript in script elements and event attributes (uses [UglifyJS](https://github.com/mishoo/UglifyJS2)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
+| `minifyCSS`                    | Minify CSS in style elements and style attributes (uses [clean-css](https://github.com/jakubpawlowicz/clean-css)) | `false` (could be `true`, `Object`, `Function(text[, cb])`) |
+| `minifyJS`                     | Minify JavaScript in script elements and event attributes (uses [UglifyJS](https://github.com/mishoo/UglifyJS2)) | `false` (could be `true`, `Object`, `Function(text, inline[, cb])`) |
 | `minifyURLs`                   | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `String`, `Object`, `Function(text)`) |
 | `preserveLineBreaks`           | Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break. Must be used in conjunction with `collapseWhitespace=true` | `false` |
 | `preventAttributesEscaping`    | Prevents the escaping of the values of attributes | `false` |
@@ -142,6 +142,8 @@ For command line usage please see `html-minifier --help`
 
 ### Node.js
 
+#### Synchronous Usage
+
 ```js
 var minify = require('html-minifier').minify;
 var result = minify('<p title="blah" id="moo">foo</p>', {
@@ -150,6 +152,62 @@ var result = minify('<p title="blah" id="moo">foo</p>', {
 result; // '<p title=blah id=moo>foo</p>'
 ```
 
+#### Asynchronous Usage
+
+`minify` can take an optional callback function that will be invoked once the
+minification is complete (or an error occurs).
+
+This allows for the following functions to complete asynchronously:
+
+* minifyCSS
+* minifyJS
+
+```js
+var minify = require('html-minifier').minify;
+
+minify(
+  '<style>body { margin: 0; display: flex; }</style>',
+  {
+    minifyCSS: function(css, cb) {
+      doSomethingAsync(css, function(updatedCss) {
+        cb(updatedCss);
+      });
+    },
+  },
+  function(error, result) {
+    if (error) {
+      // Handle error.
+    } else {
+      // Do something with the result.
+    }
+  }
+);
+```
+
+##### Promisify
+
+`minify` is compatable with NodeJS's [`util.promisify`](https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original)
+function added in v8.0.0
+
+```js
+const util = require('util');
+const minify = util.promisify(require('html-minifier').minify);
+
+minify('<style>body { margin: 0; display: flex; }</style>', {
+  minifyCSS: (css, cb) => {
+    doSomethingAsync(css, updatedCss => {
+      cb(updatedCss);
+    });
+  }
+})
+  .then(result => {
+    // Do something with the result.
+  })
+  .catch(error => {
+    // Handle error.
+  });
+```
+
 ## Running benchmarks
 
 Benchmarks for minified HTML:

From cdc653bd2ceca57385be6e37bc940c02e02710e5 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Fri, 13 Apr 2018 00:28:20 +1200
Subject: [PATCH 16/66] Refactored.

---
 src/htmlminifier.js | 192 ++++++++++++++++++++------------------------
 tests/minifier.js   |  16 ++--
 2 files changed, 97 insertions(+), 111 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index e929fa7a..65039774 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -803,29 +803,6 @@ function createSortFns(value, options, uidIgnore, uidAttr) {
   }
 }
 
-/**
- * A placeholder for text that will be set later.
- *
- * @constructor
- */
-function AsyncTextPlaceholder() {}
-
-/**
- * Set the value this placeholder has.
- *
- * @param {string} value
- */
-AsyncTextPlaceholder.prototype.setValue = function(value) {
-  this.value = value;
-};
-
-AsyncTextPlaceholder.prototype.toString = function() {
-  if (typeof this.value !== 'undefined') {
-    return this.value;
-  }
-  return '[[Placeholder]]';
-};
-
 function minify(value, options, partialMarkup, cb) {
   options = options || {};
   var optionsStack = [];
@@ -851,6 +828,8 @@ function minify(value, options, partialMarkup, cb) {
       uidAttr,
       uidPattern;
 
+  var asyncExecution = typeof cb === 'function';
+
   // temporarily replace ignored chunks with comments,
   // so that we don't have to worry what's there.
   // for all we care there might be
@@ -964,8 +943,9 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
-  var asyncTasksWaitingFor = 0;
-  var error;
+  // Number of tasks waiting to complete (includes current function).
+  var asyncTasksWaitingFor = 1;
+  var asyncError;
 
   try {
     new HTMLParser(value, {
@@ -1136,6 +1116,7 @@ function minify(value, options, partialMarkup, cb) {
       chars: function(text, prevTag, nextTag) {
         prevTag = prevTag === '' ? 'comment' : prevTag;
         nextTag = nextTag === '' ? 'comment' : nextTag;
+        var usingAsyncText = false;
         if (options.decodeEntities && text && !specialContentTags(currentTag)) {
           text = decode(text);
         }
@@ -1188,36 +1169,24 @@ function minify(value, options, partialMarkup, cb) {
           text = processScript(text, options, currentAttrs);
         }
 
-        var runningAsyncTask = false;
-
-        /**
-         * To be called when running an async task.
-         *
-         * @param {AsyncTextPlaceholder} placeholder
-         */
-        function onAsyncTask(placeholder) {
-          buffer.push(placeholder);
-          runningAsyncTask = true;
-          asyncTasksWaitingFor++;
-        }
-
         /**
          * Returns the callback function for an async task.
          *
-         * @param {AsyncTextPlaceholder} placeholder
+         * @param {number} index - The index in the buffer to insert the updated text into
          * @returns {Function}
          */
-        function getAsyncTaskCallback(placeholder) {
+        function getAsyncTaskCallback(index) {
+          var runningAsyncTask = true;
           return function(result) {
             if (!runningAsyncTask) {
               throw new Error('Async completion has already occurred.');
             }
             runningAsyncTask = false;
-            placeholder.setValue(result);
+            buffer[index] = result;
             if (--asyncTasksWaitingFor === 0) {
               if (typeof cb === 'function') {
-                if (error) {
-                  cb(error, null);
+                if (asyncError) {
+                  cb(asyncError, null);
                 }
                 else {
                   cb(null, finalize());
@@ -1228,62 +1197,72 @@ function minify(value, options, partialMarkup, cb) {
         }
 
         if (isExecutableScript(currentTag, currentAttrs)) {
-          var minifyJSPlaceholder = new AsyncTextPlaceholder();
-          var minifyJSResult = options.minifyJS(text, null, getAsyncTaskCallback(minifyJSPlaceholder));
-
-          // Running asynchronously?
-          if (typeof minifyJSResult === 'undefined') {
-            onAsyncTask(minifyJSPlaceholder);
+          if (asyncExecution) {
+            asyncTasksWaitingFor++;
+            usingAsyncText = true;
+            var minifyJS_cb = getAsyncTaskCallback(buffer.length);
+            var minifyJS_result = options.minifyJS(text, null, minifyJS_cb);
+
+            // Finished synchronously?
+            if (typeof minifyJS_result !== 'undefined') {
+              // Call the callback manually.
+              minifyJS_cb(minifyJS_result);
+            }
           }
-          // Finished synchronously?
           else {
-            text = minifyJSResult;
+            text = options.minifyJS(text);
           }
         }
         if (isStyleSheet(currentTag, currentAttrs)) {
-          var minifyCSSPlaceholder = new AsyncTextPlaceholder();
-          var minifyCSSResult = options.minifyCSS(text, getAsyncTaskCallback(minifyCSSPlaceholder));
-
-          // Running asynchronously?
-          if (typeof minifyCSSResult === 'undefined') {
-            onAsyncTask(minifyCSSPlaceholder);
+          if (asyncExecution) {
+            asyncTasksWaitingFor++;
+            usingAsyncText = true;
+            var minifyCSS_cb = getAsyncTaskCallback(buffer.length);
+            var minifyCSS_result = options.minifyCSS(text, minifyCSS_cb);
+
+            // Finished synchronously?
+            if (typeof minifyCSS_result !== 'undefined') {
+              // Call the callback manually.
+              minifyCSS_cb(minifyCSS_result);
+            }
           }
-          // Finished synchronously?
           else {
-            text = minifyCSSResult;
+            text = options.minifyCSS(text);
           }
         }
-        if (options.removeOptionalTags && text) {
-          // <html> may be omitted if first thing inside is not comment
-          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-          if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-            removeStartTag();
+        if (usingAsyncText) {
+          buffer.push(null);
+        }
+        else {
+          if (options.removeOptionalTags && text) {
+            // <html> may be omitted if first thing inside is not comment
+            // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+            if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
+              removeStartTag();
+            }
+            optionalStartTag = '';
+            // </html> or </body> may be omitted if not followed by comment
+            // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
+            if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
+              removeEndTag();
+            }
+            optionalEndTag = '';
           }
-          optionalStartTag = '';
-          // </html> or </body> may be omitted if not followed by comment
-          // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-          if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-            removeEndTag();
+          charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+          if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+            // semi-colon can be omitted
+            // https://mathiasbynens.be/notes/ambiguous-ampersands
+            text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+          }
+          if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+            text = text.replace(uidPattern, function(match, prefix, index) {
+              return ignoredCustomMarkupChunks[+index][0];
+            });
+          }
+          currentChars += text;
+          if (text) {
+            hasChars = true;
           }
-          optionalEndTag = '';
-        }
-        charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-          // semi-colon can be omitted
-          // https://mathiasbynens.be/notes/ambiguous-ampersands
-          text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
-        }
-        if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-          text = text.replace(uidPattern, function(match, prefix, index) {
-            return ignoredCustomMarkupChunks[+index][0];
-          });
-        }
-        currentChars += text;
-        if (text) {
-          hasChars = true;
-        }
-        // Not running an async task?
-        if (!runningAsyncTask) {
           buffer.push(text);
         }
       },
@@ -1318,8 +1297,13 @@ function minify(value, options, partialMarkup, cb) {
       customAttrSurround: options.customAttrSurround
     });
   }
-  catch (err) {
-    error = err;
+  catch (error) {
+    if (asyncExecution) {
+      asyncError = error;
+    }
+    else {
+      throw error;
+    }
   }
 
   function finalize() {
@@ -1368,21 +1352,20 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  // No async tasks running?
-  if (asyncTasksWaitingFor === 0) {
-    var result = finalize();
+  if (asyncExecution) {
+    // This task just finished.
+    asyncTasksWaitingFor--;
 
-    if (typeof cb === 'function') {
-      // Call the callback.
-      cb(error, result);
+    if (asyncError) {
+      cb(asyncError);
     }
-    else if (error) {
-      // No callback to handle the error?
-      throw error;
+    else if (asyncTasksWaitingFor === 0) {
+      // No async tasks running?
+      cb(asyncError, finalize());
     }
-
-    return result;
+    return;
   }
+  return finalize();
 }
 
 function joinResultSegments(results, options) {
@@ -1393,8 +1376,11 @@ function joinResultSegments(results, options) {
     var lines = [];
     var line = '';
     for (var i = 0, len = results.length; i < len; i++) {
-      token = String(results[i]);
-      if (line.length + token.length < maxLineLength) {
+      token = results[i];
+      if (token === null) {
+        line += '[[Placeholder]]';
+      }
+      else if (line.length + token.length < maxLineLength) {
         line += token;
       }
       else {
diff --git a/tests/minifier.js b/tests/minifier.js
index 381ab646..9bcfb10a 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3595,7 +3595,7 @@ QUnit.test('sync minify with callback', function(assert) {
   var input = '<html><head><title>Test</title></head><body>Hello World</body></html>';
   var output = input;
   var done = assert.async();
-  assert.equal(minify(
+  assert.notOk(minify(
     input,
     {},
     function(error, result) {
@@ -3603,14 +3603,14 @@ QUnit.test('sync minify with callback', function(assert) {
       assert.equal(result, output);
       done();
     }
-  ), output);
+  ));
 });
 
 QUnit.test('minify error with callback', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><invalid html';
   var done = assert.async();
 
-  minify(
+  assert.notOk(minify(
     input,
     {},
     function(error) {
@@ -3618,7 +3618,7 @@ QUnit.test('minify error with callback', function(assert) {
       assert.equal(error.message, 'Parse Error: <invalid html');
       done();
     }
-  );
+  ));
 });
 
 QUnit.test('error in callback', function(assert) {
@@ -3626,7 +3626,7 @@ QUnit.test('error in callback', function(assert) {
   var error = new Error();
   var done = assert.async();
 
-  minify(
+  assert.notOk(minify(
     input,
     {
       minifyCSS: function() {
@@ -3637,7 +3637,7 @@ QUnit.test('error in callback', function(assert) {
       assert.strictEqual(err, error);
       done();
     }
-  );
+  ));
 });
 
 QUnit.test('call callback multiple times', function(assert) {
@@ -3645,7 +3645,7 @@ QUnit.test('call callback multiple times', function(assert) {
   var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
   var done = assert.async(3);
 
-  minify(
+  assert.notOk(minify(
     input,
     {
       minifyCSS: function(css, cb) {
@@ -3684,5 +3684,5 @@ QUnit.test('call callback multiple times', function(assert) {
       assert.equal(result, output);
       done();
     }
-  );
+  ));
 });

From 28c1ac3a3aeff7ef3375679ddb9dd6b9bebfcad9 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 13 Apr 2018 17:35:07 +1200
Subject: [PATCH 17/66] Refactored - Async tasks now do not start until after
 all sync code has finished.

---
 src/htmlminifier.js | 271 ++++++++++++++++++++++++++++----------------
 1 file changed, 173 insertions(+), 98 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 65039774..9b15bac7 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -828,8 +828,111 @@ function minify(value, options, partialMarkup, cb) {
       uidAttr,
       uidPattern;
 
+  /**
+   * Running using async exectution?
+   *
+   * @type {boolean}
+   */
   var asyncExecution = typeof cb === 'function';
 
+  /**
+   * Set of tasks to perform asynchronously.
+   *
+   * @type {AsyncTask[]}
+   */
+  var asyncTasks = [];
+
+  /**
+   * The number of async tasks that have completed.
+   *
+   * @type {number}
+   */
+  var asyncTasksComplete = 0;
+
+  /**
+   * A task that will be executed asynchronously after all the synchronous
+   * code has executed.
+   *
+   * @constructor
+   *
+   * @param {AsyncSubtask[]} tasks
+   * @param {string} content
+   * @param {Function<string>} cb
+   */
+  function AsyncTask(tasks, content, cb) {
+    this.tasks = tasks;
+    this.content = content;
+    this.cb = cb;
+  }
+
+  /**
+   * Run the subtasks at the given index, giving it a callback to run the next
+   * subtask the same way. This therefore asynchronously runs all subtasks from
+   * the given index in series.
+   *
+   * @private
+   * @param {string} content
+   * @param {number} index
+   */
+  AsyncTask.prototype.runSubtask = function(content, index) {
+    if (index < this.tasks.length) {
+      try {
+        this.tasks[index].exec(
+          content,
+          function(result) {
+            if (this.tasks[index].cbExecuted) {
+              throw new Error('Async completion has already occurred.');
+            }
+            this.tasks[index].cbExecuted = true;
+
+            this.runSubtask(result, index + 1);
+          }.bind(this)
+        );
+      }
+      catch (error) {
+        cb(error);
+      }
+    }
+    else {
+      this.cb(content);
+      if (++asyncTasksComplete === asyncTasks.length) {
+        cb(null, finalize());
+      }
+    }
+  };
+
+  /**
+   * Execute this task.
+   */
+  AsyncTask.prototype.exec = function() {
+    // Recursively run all subtasks.
+    this.runSubtask(this.content, 0);
+  };
+
+  /**
+   * A subtask in an AsyncTask.
+   *
+   * @constructor
+   *
+   * @param {Function<string, Function<string>>} task
+   */
+  function AsyncSubtask(task) {
+    this.task = task;
+  }
+
+  /**
+   * Execute this subtask.
+   */
+  AsyncSubtask.prototype.exec = function(content, cb) {
+    var result = this.task(content, cb);
+
+    // Finished synchronously?
+    if (typeof result !== 'undefined') {
+      // Call the callback manually.
+      cb(result);
+    }
+  };
+
   // temporarily replace ignored chunks with comments,
   // so that we don't have to worry what's there.
   // for all we care there might be
@@ -943,10 +1046,6 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
-  // Number of tasks waiting to complete (includes current function).
-  var asyncTasksWaitingFor = 1;
-  var asyncError;
-
   try {
     new HTMLParser(value, {
       partialMarkup: partialMarkup,
@@ -1116,7 +1215,7 @@ function minify(value, options, partialMarkup, cb) {
       chars: function(text, prevTag, nextTag) {
         prevTag = prevTag === '' ? 'comment' : prevTag;
         nextTag = nextTag === '' ? 'comment' : nextTag;
-        var usingAsyncText = false;
+        var asyncSubtasks = [];
         if (options.decodeEntities && text && !specialContentTags(currentTag)) {
           text = decode(text);
         }
@@ -1169,45 +1268,12 @@ function minify(value, options, partialMarkup, cb) {
           text = processScript(text, options, currentAttrs);
         }
 
-        /**
-         * Returns the callback function for an async task.
-         *
-         * @param {number} index - The index in the buffer to insert the updated text into
-         * @returns {Function}
-         */
-        function getAsyncTaskCallback(index) {
-          var runningAsyncTask = true;
-          return function(result) {
-            if (!runningAsyncTask) {
-              throw new Error('Async completion has already occurred.');
-            }
-            runningAsyncTask = false;
-            buffer[index] = result;
-            if (--asyncTasksWaitingFor === 0) {
-              if (typeof cb === 'function') {
-                if (asyncError) {
-                  cb(asyncError, null);
-                }
-                else {
-                  cb(null, finalize());
-                }
-              }
-            }
-          };
-        }
-
         if (isExecutableScript(currentTag, currentAttrs)) {
           if (asyncExecution) {
-            asyncTasksWaitingFor++;
-            usingAsyncText = true;
-            var minifyJS_cb = getAsyncTaskCallback(buffer.length);
-            var minifyJS_result = options.minifyJS(text, null, minifyJS_cb);
-
-            // Finished synchronously?
-            if (typeof minifyJS_result !== 'undefined') {
-              // Call the callback manually.
-              minifyJS_cb(minifyJS_result);
-            }
+            // Run minifyJS asynchronously after all synchronous code has finished.
+            asyncSubtasks.push(new AsyncSubtask(function(content, cb) {
+              return options.minifyJS(content, null, cb);
+            }));
           }
           else {
             text = options.minifyJS(text);
@@ -1215,56 +1281,64 @@ function minify(value, options, partialMarkup, cb) {
         }
         if (isStyleSheet(currentTag, currentAttrs)) {
           if (asyncExecution) {
-            asyncTasksWaitingFor++;
-            usingAsyncText = true;
-            var minifyCSS_cb = getAsyncTaskCallback(buffer.length);
-            var minifyCSS_result = options.minifyCSS(text, minifyCSS_cb);
-
-            // Finished synchronously?
-            if (typeof minifyCSS_result !== 'undefined') {
-              // Call the callback manually.
-              minifyCSS_cb(minifyCSS_result);
-            }
+            // Run minifyCSS asynchronously after all synchronous code has finished.
+            asyncSubtasks.push(new AsyncSubtask(function(content, cb) {
+              return options.minifyCSS(content, cb);
+            }));
           }
           else {
             text = options.minifyCSS(text);
           }
         }
-        if (usingAsyncText) {
-          buffer.push(null);
-        }
-        else {
-          if (options.removeOptionalTags && text) {
-            // <html> may be omitted if first thing inside is not comment
-            // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-            if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-              removeStartTag();
-            }
-            optionalStartTag = '';
-            // </html> or </body> may be omitted if not followed by comment
-            // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-            if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-              removeEndTag();
-            }
-            optionalEndTag = '';
-          }
-          charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-          if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-            // semi-colon can be omitted
-            // https://mathiasbynens.be/notes/ambiguous-ampersands
-            text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
-          }
-          if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-            text = text.replace(uidPattern, function(match, prefix, index) {
-              return ignoredCustomMarkupChunks[+index][0];
-            });
+        if (options.removeOptionalTags && text) {
+          // <html> may be omitted if first thing inside is not comment
+          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+          if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
+            removeStartTag();
           }
-          currentChars += text;
-          if (text) {
-            hasChars = true;
+          optionalStartTag = '';
+          // </html> or </body> may be omitted if not followed by comment
+          // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
+          if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
+            removeEndTag();
           }
+          optionalEndTag = '';
+        }
+        charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+          // semi-colon can be omitted
+          // https://mathiasbynens.be/notes/ambiguous-ampersands
+          text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+        }
+        if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+          text = text.replace(uidPattern, function(match, prefix, index) {
+            return ignoredCustomMarkupChunks[+index][0];
+          });
+        }
+        currentChars += text;
+        if (text) {
+          hasChars = true;
+        }
+
+        // Nothing to do asynchronously?
+        if (asyncSubtasks.length === 0) {
           buffer.push(text);
+          return;
         }
+
+        var insertIndex = buffer.length;
+        buffer.push(null);
+
+        // Create a new AsyncTask that will update the buffer once complete.
+        asyncTasks.push(
+          new AsyncTask(
+            asyncSubtasks,
+            text,
+            function(result) {
+              buffer[insertIndex] = result;
+            }
+          )
+        );
       },
       comment: function(text, nonStandard) {
         var prefix = nonStandard ? '<!' : '<!--';
@@ -1299,11 +1373,10 @@ function minify(value, options, partialMarkup, cb) {
   }
   catch (error) {
     if (asyncExecution) {
-      asyncError = error;
-    }
-    else {
-      throw error;
+      cb(error);
+      return;
     }
+    throw error;
   }
 
   function finalize() {
@@ -1352,20 +1425,22 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  if (asyncExecution) {
-    // This task just finished.
-    asyncTasksWaitingFor--;
+  // Sync execution?
+  if (!asyncExecution) {
+    return finalize();
+  }
 
-    if (asyncError) {
-      cb(asyncError);
-    }
-    else if (asyncTasksWaitingFor === 0) {
-      // No async tasks running?
-      cb(asyncError, finalize());
-    }
+  // No async tasks?
+  if (asyncTasks.length === 0) {
+    cb(null, finalize());
     return;
   }
-  return finalize();
+
+  // Execute all the async tasks.
+  for (var i = 0; i < asyncTasks.length; i++) {
+    asyncTasks[i].exec();
+  }
+  return;
 }
 
 function joinResultSegments(results, options) {

From 80f5ad9b6c05f7120fe600792b04009d42d7dabc Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 13 Apr 2018 18:04:45 +1200
Subject: [PATCH 18/66] Added inline callback tests.

---
 src/htmlminifier.js |  6 ++---
 tests/minifier.js   | 61 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 3 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 9b15bac7..b68a52df 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -260,7 +260,7 @@ function isSrcset(attrName, tag) {
 function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   if (attrValue && isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
-    return options.minifyJS(attrValue, true);
+    return options.minifyJS(attrValue, true); // TODO: add callback.
   }
   else if (attrName === 'class') {
     attrValue = trimWhitespace(attrValue);
@@ -285,7 +285,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
       if (/;$/.test(attrValue) && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
         attrValue = attrValue.replace(/\s*;$/, ';');
       }
-      attrValue = unwrapInlineCSS(options.minifyCSS(wrapInlineCSS(attrValue)));
+      attrValue = unwrapInlineCSS(options.minifyCSS(wrapInlineCSS(attrValue))); // TODO: Add callback.
     }
     return attrValue;
   }
@@ -322,7 +322,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   }
   else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
-    return unwrapMediaQuery(options.minifyCSS(wrapMediaQuery(attrValue)));
+    return unwrapMediaQuery(options.minifyCSS(wrapMediaQuery(attrValue))); // TODO: Add callback.
   }
   return attrValue;
 }
diff --git a/tests/minifier.js b/tests/minifier.js
index 9bcfb10a..95c3a458 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3686,3 +3686,64 @@ QUnit.test('call callback multiple times', function(assert) {
     }
   ));
 });
+
+QUnit.test('inline script with callback', function(assert) {
+  var input = '<p onclick="alert(1 + 2);">';
+  var output = '<p onclick="JS"></p>';
+  var done = assert.async();
+
+  assert.notOk(minify(
+    input,
+    {
+      customEventAttributes: [/^on*/],
+      minifyJS: function(text, inline, cb) {
+        cb('JS');
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('inline style with callback', function(assert) {
+  var input = '<p style="display: none;">';
+  var output = '<p style="CSS"></p>';
+  var done = assert.async();
+
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(text, cb) {
+        cb('CSS');
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});
+
+QUnit.test('inline style media with callback', function(assert) {
+  var input = '<style media="{max-width: 100px}"></style>';
+  var output = '<style media="CSS">CSS</style>';
+  var done = assert.async();
+
+  assert.notOk(minify(
+    input,
+    {
+      minifyCSS: function(text, cb) {
+        cb('CSS');
+      }
+    },
+    function(error, result) {
+      assert.notOk(error);
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});

From c64327a6ed6d48367bce17b981ad8b8975f5bc0b Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 13:16:16 +1200
Subject: [PATCH 19/66] All test now test both synchronously and
 asynchronously.

---
 tests/minifier.js | 2342 ++++++++++++++++++++-------------------------
 1 file changed, 1022 insertions(+), 1320 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 95c3a458..cc0183b6 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -6,6 +6,58 @@ if (typeof minify === 'undefined') {
   self.minify = require('html-minifier').minify;
 }
 
+/**
+ * Test the minify function both synchronously and asynchronously.
+ *
+ * @param {QUnit.assert} assert
+ * @param {string} input
+ * @param {Object} [options]
+ * @param {string} output
+ * @param {string} [description]
+ */
+function test_minify(assert, input, options, output, description) {
+  // Remove optional options parameter if it is not given.
+  if (typeof options === 'string') {
+    description = output;
+    output = options;
+    options = null;
+  }
+
+  // Set default description as input.
+  if (typeof description === 'undefined') {
+    description = input;
+  }
+
+  // Synchronously test.
+  assert.equal(minify(input, options), output, 'Synchronous Test: ' + description);
+
+  // Asynchronously test setup.
+  if (options) {
+    // Convert `minifyJS` to use a callback.
+    if (typeof options.minifyJS === 'function') {
+      var minifyJS = options.minifyJS;
+      options.minifyJS = function(text, inline, callback) {
+        callback(minifyJS(text, inline));
+      };
+    }
+    // Convert `minifyCSS` to use a callback.
+    if (typeof options.minifyCSS === 'function') {
+      var minifyCSS = options.minifyCSS;
+      options.minifyCSS = function(text, type, callback) {
+        callback(minifyCSS(text, type));
+      };
+    }
+  }
+  var done = assert.async();
+
+  // Asynchronously test.
+  assert.notOk(minify(input, options, function(error, result) {
+    assert.notOk(error);
+    assert.equal(result, output, 'Asynchronous Test: ' + description);
+    done();
+  }));
+}
+
 QUnit.test('`minifiy` exists', function(assert) {
   assert.ok(minify);
 });
@@ -13,52 +65,52 @@ QUnit.test('`minifiy` exists', function(assert) {
 QUnit.test('parsing non-trivial markup', function(assert) {
   var input, output;
 
-  assert.equal(minify('</td>'), '');
-  assert.equal(minify('</p>'), '<p></p>');
-  assert.equal(minify('</br>'), '<br>');
-  assert.equal(minify('<br>x</br>'), '<br>x<br>');
-  assert.equal(minify('<p title="</p>">x</p>'), '<p title="</p>">x</p>');
-  assert.equal(minify('<p title=" <!-- hello world --> ">x</p>'), '<p title=" <!-- hello world --> ">x</p>');
-  assert.equal(minify('<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>'), '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  assert.equal(minify('<p foo-bar=baz>xxx</p>'), '<p foo-bar="baz">xxx</p>');
-  assert.equal(minify('<p foo:bar=baz>xxx</p>'), '<p foo:bar="baz">xxx</p>');
-  assert.equal(minify('<p foo.bar=baz>xxx</p>'), '<p foo.bar="baz">xxx</p>');
+  test_minify(assert, '</td>', '');
+  test_minify(assert, '</p>', '<p></p>');
+  test_minify(assert, '</br>', '<br>');
+  test_minify(assert, '<br>x</br>', '<br>x<br>');
+  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
+  test_minify(assert, '<p foo.bar=baz>xxx</p>', '<p foo.bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
 
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
-  assert.equal(minify('<script>alert(\'<!--\')</script>'), '<script>alert(\'<!--\')</script>');
-  assert.equal(minify('<script>alert(\'<!-- foo -->\')</script>'), '<script>alert(\'<!-- foo -->\')</script>');
-  assert.equal(minify('<script>alert(\'-->\')</script>'), '<script>alert(\'-->\')</script>');
+  test_minify(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')</script>');
+  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', '<script>alert(\'<!-- foo -->\')</script>');
+  test_minify(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')</script>');
 
-  assert.equal(minify('<a title="x"href=" ">foo</a>'), '<a title="x" href="">foo</a>');
-  assert.equal(minify('<p id=""class=""title="">x'), '<p id="" class="" title="">x</p>');
-  assert.equal(minify('<p x="x\'"">x</p>'), '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  assert.equal(minify('<a href="#"><p>Click me</p></a>'), '<a href="#"><p>Click me</p></a>');
-  assert.equal(minify('<span><button>Hit me</button></span>'), '<span><button>Hit me</button></span>');
-  assert.equal(minify('<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>'),
+  test_minify(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
+  test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
+  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
+  test_minify(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
+  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>',
     '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>'
   );
 
-  assert.equal(minify('<ng-include src="x"></ng-include>'), '<ng-include src="x"></ng-include>');
-  assert.equal(minify('<ng:include src="x"></ng:include>'), '<ng:include src="x"></ng:include>');
-  assert.equal(minify('<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>'),
+  test_minify(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x"></ng-include>');
+  test_minify(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x"></ng:include>');
+  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>',
     '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>'
   );
 
   // will cause test to time-out if fail
   input = '<p>For more information, read <a href=https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685>this Stack Overflow answer</a>.</p>';
   output = '<p>For more information, read <a href="https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685">this Stack Overflow answer</a>.</p>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<html ⚡></html>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   input = '<h:ællæ></h:ællæ>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   input = '<$unicorn>';
   assert.throws(function() {
@@ -66,33 +118,33 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   }, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   // https://github.com/kangax/html-minifier/issues/41
-  assert.equal(minify('<some-tag-1></some-tag-1><some-tag-2></some-tag-2>'),
+  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>',
     '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>'
   );
 
   // https://github.com/kangax/html-minifier/issues/40
-  assert.equal(minify('[\']["]'), '[\']["]');
+  test_minify(assert, '[\']["]', '[\']["]');
 
   // https://github.com/kangax/html-minifier/issues/21
-  assert.equal(minify('<a href="test.html"><div>hey</div></a>'), '<a href="test.html"><div>hey</div></a>');
+  test_minify(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html"><div>hey</div></a>');
 
   // https://github.com/kangax/html-minifier/issues/17
-  assert.equal(minify(':) <a href="http://example.com">link</a>'), ':) <a href="http://example.com">link</a>');
+  test_minify(assert, ':) <a href="http://example.com">link</a>', ':) <a href="http://example.com">link</a>');
 
   // https://github.com/kangax/html-minifier/issues/169
-  assert.equal(minify('<a href>ok</a>'), '<a href>ok</a>');
+  test_minify(assert, '<a href>ok</a>', '<a href>ok</a>');
 
-  assert.equal(minify('<a onclick></a>'), '<a onclick></a>');
+  test_minify(assert, '<a onclick></a>', '<a onclick></a>');
 
   // https://github.com/kangax/html-minifier/issues/229
-  assert.equal(minify('<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>'), '<custom-tag></custom-tag><div>Hello :)</div>');
+  test_minify(assert, '<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>', '<custom-tag></custom-tag><div>Hello :)</div>');
 
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   assert.throws(function() {
     minify('<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>');
   }, 'invalid attribute name');
@@ -105,7 +157,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-model-options="{ debounce: 1000 }"' +
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   assert.throws(function() {
     minify(
       '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
@@ -121,112 +173,112 @@ QUnit.test('parsing non-trivial markup', function(assert) {
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
   output = '<br a="\u00A0"b="\u00A0"c="\u00A0">';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     decodeEntities: true,
     removeTagWhitespace: true,
-  }), output);
+  }, output);
   output = '<br a=\u00A0 b=\u00A0 c=\u00A0>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     decodeEntities: true,
     removeAttributeQuotes: true
-  }), output);
-  assert.equal(minify(input, {
+  }, output);
+  test_minify(assert, input, {
     decodeEntities: true,
     removeAttributeQuotes: true,
     removeTagWhitespace: true,
-  }), output);
+  }, output);
 });
 
 QUnit.test('options', function(assert) {
   var input = '<p>blah<span>blah 2<span>blah 3</span></span></p>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {}), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, {}, input);
 });
 
 QUnit.test('case normalization', function(assert) {
-  assert.equal(minify('<P>foo</p>'), '<p>foo</p>');
-  assert.equal(minify('<DIV>boo</DIV>'), '<div>boo</div>');
-  assert.equal(minify('<DIV title="moo">boo</DiV>'), '<div title="moo">boo</div>');
-  assert.equal(minify('<DIV TITLE="blah">boo</DIV>'), '<div title="blah">boo</div>');
-  assert.equal(minify('<DIV tItLe="blah">boo</DIV>'), '<div title="blah">boo</div>');
-  assert.equal(minify('<DiV tItLe="blah">boo</DIV>'), '<div title="blah">boo</div>');
+  test_minify(assert, '<P>foo</p>', '<p>foo</p>');
+  test_minify(assert, '<DIV>boo</DIV>', '<div>boo</div>');
+  test_minify(assert, '<DIV title="moo">boo</DiV>', '<div title="moo">boo</div>');
+  test_minify(assert, '<DIV TITLE="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify(assert, '<DIV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify(assert, '<DiV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
 });
 
 QUnit.test('space normalization between attributes', function(assert) {
-  assert.equal(minify('<p title="bar">foo</p>'), '<p title="bar">foo</p>');
-  assert.equal(minify('<img src="test"/>'), '<img src="test">');
-  assert.equal(minify('<p title = "bar">foo</p>'), '<p title="bar">foo</p>');
-  assert.equal(minify('<p title\n\n\t  =\n     "bar">foo</p>'), '<p title="bar">foo</p>');
-  assert.equal(minify('<img src="test" \n\t />'), '<img src="test">');
-  assert.equal(minify('<input title="bar"       id="boo"    value="hello world">'), '<input title="bar" id="boo" value="hello world">');
+  test_minify(assert, '<p title="bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<img src="test"/>', '<img src="test">');
+  test_minify(assert, '<p title = "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<p title\n\n\t  =\n     "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<img src="test" \n\t />', '<img src="test">');
+  test_minify(assert, '<input title="bar"       id="boo"    value="hello world">', '<input title="bar" id="boo" value="hello world">');
 });
 
 QUnit.test('space normalization around text', function(assert) {
   var input, output;
   input = '   <p>blah</p>\n\n\n   ';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<p>blah</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   output = ' <p>blah</p> ';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
   output = '<p>blah</p>\n';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
   output = ' <p>blah</p>\n';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
   [
     'a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd',
     'mark', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup',
     'time', 'tt', 'u', 'var'
   ].forEach(function(el) {
-    assert.equal(minify('foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }), 'foo <' + el + '>baz </' + el + '>bar');
-    assert.equal(minify('foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }), 'foo<' + el + '> baz </' + el + '>bar');
-    assert.equal(minify('foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }), 'foo <' + el + '>baz </' + el + '>bar');
-    assert.equal(minify('foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }), 'foo<' + el + '> baz </' + el + '>bar');
-    assert.equal(minify('<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    assert.equal(minify('<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    assert.equal(minify('<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    assert.equal(minify('<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '> baz </' + el + '>bar</div>');
-    assert.equal(minify('<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    assert.equal(minify('<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '> baz </' + el + '>bar</div>');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
   });
   // Don't trim whitespace around element, but do trim within
   [
     'bdi', 'bdo', 'button', 'cite', 'code', 'dfn', 'math', 'q', 'rt', 'rtc', 'ruby', 'svg'
   ].forEach(function(el) {
-    assert.equal(minify('foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }), 'foo <' + el + '>baz</' + el + '>bar');
-    assert.equal(minify('foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }), 'foo<' + el + '>baz</' + el + '> bar');
-    assert.equal(minify('<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    assert.equal(minify('<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    assert.equal(minify('<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    assert.equal(minify('<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }), '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    assert.equal(minify('<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }), '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
   });
   [
     ['<span> foo </span>', '<span>foo</span>'],
@@ -252,39 +304,39 @@ QUnit.test('space normalization around text', function(assert) {
     ['a <nobr> b</nobr> c', 'a <nobr>b</nobr> c'],
     ['a <nobr> b </nobr> c', 'a <nobr>b</nobr> c']
   ].forEach(function(inputs) {
-    assert.equal(minify(inputs[0], {
+    test_minify(assert, inputs[0], {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }), inputs[0], inputs[0]);
-    assert.equal(minify(inputs[0], { collapseWhitespace: true }), inputs[1], inputs[0]);
+    }, inputs[0], inputs[0]);
+    test_minify(assert, inputs[0], { collapseWhitespace: true }, inputs[1], inputs[0]);
     var input = '<div>' + inputs[0] + '</div>';
-    assert.equal(minify(input, {
+    test_minify(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }), input, input);
+    }, input, input);
     var output = '<div>' + inputs[1] + '</div>';
-    assert.equal(minify(input, { collapseWhitespace: true }), output, input);
+    test_minify(assert, input, { collapseWhitespace: true }, output, input);
   });
-  assert.equal(minify('<p>foo <img> bar</p>', { collapseWhitespace: true }), '<p>foo <img> bar</p>');
-  assert.equal(minify('<p>foo<img>bar</p>', { collapseWhitespace: true }), '<p>foo<img>bar</p>');
-  assert.equal(minify('<p>foo <img>bar</p>', { collapseWhitespace: true }), '<p>foo <img>bar</p>');
-  assert.equal(minify('<p>foo<img> bar</p>', { collapseWhitespace: true }), '<p>foo<img> bar</p>');
-  assert.equal(minify('<p>foo <wbr> bar</p>', { collapseWhitespace: true }), '<p>foo<wbr> bar</p>');
-  assert.equal(minify('<p>foo<wbr>bar</p>', { collapseWhitespace: true }), '<p>foo<wbr>bar</p>');
-  assert.equal(minify('<p>foo <wbr>bar</p>', { collapseWhitespace: true }), '<p>foo <wbr>bar</p>');
-  assert.equal(minify('<p>foo<wbr> bar</p>', { collapseWhitespace: true }), '<p>foo<wbr> bar</p>');
-  assert.equal(minify('<p>foo <wbr baz moo=""> bar</p>', { collapseWhitespace: true }), '<p>foo<wbr baz moo=""> bar</p>');
-  assert.equal(minify('<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true }), '<p>foo<wbr baz moo="">bar</p>');
-  assert.equal(minify('<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true }), '<p>foo <wbr baz moo="">bar</p>');
-  assert.equal(minify('<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true }), '<p>foo<wbr baz moo=""> bar</p>');
-  assert.equal(minify('<p>  <a href="#">  <code>foo</code></a> bar</p>', { collapseWhitespace: true }), '<p><a href="#"><code>foo</code></a> bar</p>');
-  assert.equal(minify('<p><a href="#"><code>foo  </code></a> bar</p>', { collapseWhitespace: true }), '<p><a href="#"><code>foo</code></a> bar</p>');
-  assert.equal(minify('<p>  <a href="#">  <code>   foo</code></a> bar   </p>', { collapseWhitespace: true }), '<p><a href="#"><code>foo</code></a> bar</p>');
-  assert.equal(minify('<div> Empty <!-- or --> not </div>', { collapseWhitespace: true }), '<div>Empty<!-- or --> not</div>');
-  assert.equal(minify('<div> a <input><!-- b --> c </div>', {
+  test_minify(assert, '<p>foo <img> bar</p>', { collapseWhitespace: true }, '<p>foo <img> bar</p>');
+  test_minify(assert, '<p>foo<img>bar</p>', { collapseWhitespace: true }, '<p>foo<img>bar</p>');
+  test_minify(assert, '<p>foo <img>bar</p>', { collapseWhitespace: true }, '<p>foo <img>bar</p>');
+  test_minify(assert, '<p>foo<img> bar</p>', { collapseWhitespace: true }, '<p>foo<img> bar</p>');
+  test_minify(assert, '<p>foo <wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
+  test_minify(assert, '<p>foo<wbr>bar</p>', { collapseWhitespace: true }, '<p>foo<wbr>bar</p>');
+  test_minify(assert, '<p>foo <wbr>bar</p>', { collapseWhitespace: true }, '<p>foo <wbr>bar</p>');
+  test_minify(assert, '<p>foo<wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
+  test_minify(assert, '<p>foo <wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
+  test_minify(assert, '<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo="">bar</p>');
+  test_minify(assert, '<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo <wbr baz moo="">bar</p>');
+  test_minify(assert, '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
+  test_minify(assert, '<p>  <a href="#">  <code>foo</code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify(assert, '<p><a href="#"><code>foo  </code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify(assert, '<p>  <a href="#">  <code>   foo</code></a> bar   </p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify(assert, '<div> Empty <!-- or --> not </div>', { collapseWhitespace: true }, '<div>Empty<!-- or --> not</div>');
+  test_minify(assert, '<div> a <input><!-- b --> c </div>', {
     collapseWhitespace: true,
     removeComments: true
-  }), '<div>a <input> c</div>');
+  }, '<div>a <input> c</div>');
   [
     ' a <? b ?> c ',
     '<!-- d --> a <? b ?> c ',
@@ -296,64 +348,64 @@ QUnit.test('space normalization around text', function(assert) {
     ' a <? b ?> c<!-- d --> ',
     ' a <? b ?> c <!-- d -->'
   ].forEach(function(input) {
-    assert.equal(minify(input, {
+    test_minify(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }), input, input);
-    assert.equal(minify(input, {
+    }, input, input);
+    test_minify(assert, input, {
       collapseWhitespace: true,
       removeComments: true
-    }), 'a <? b ?> c', input);
-    assert.equal(minify(input, {
+    }, 'a <? b ?> c', input);
+    test_minify(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
-    }), ' a <? b ?> c ', input);
+    }, ' a <? b ?> c ', input);
     input = '<p>' + input + '</p>';
-    assert.equal(minify(input, {
+    test_minify(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }), input, input);
-    assert.equal(minify(input, {
+    }, input, input);
+    test_minify(assert, input, {
       collapseWhitespace: true,
       removeComments: true
-    }), '<p>a <? b ?> c</p>', input);
-    assert.equal(minify(input, {
+    }, '<p>a <? b ?> c</p>', input);
+    test_minify(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
-    }), '<p> a <? b ?> c </p>', input);
+    }, '<p> a <? b ?> c </p>', input);
   });
   input = '<li><i></i> <b></b> foo</li>';
   output = '<li><i></i> <b></b> foo</li>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<li><i> </i> <b></b> foo</li>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<li> <i></i> <b></b> foo</li>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<li><i></i> <b> </b> foo</li>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<li> <i> </i> <b> </b> foo</li>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<div> <a href="#"> <span> <b> foo </b> <i> bar </i> </span> </a> </div>';
   output = '<div><a href="#"><span><b>foo </b><i>bar</i></span></a></div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<head> <!-- a --> <!-- b --><link> </head>';
   output = '<head><!-- a --><!-- b --><link></head>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<head> <!-- a --> <!-- b --> <!-- c --><link> </head>';
   output = '<head><!-- a --><!-- b --><!-- c --><link></head>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<p> foo\u00A0bar\nbaz  \u00A0\nmoo\t</p>';
   output = '<p>foo\u00A0bar baz \u00A0 moo</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<label> foo </label>\n' +
           '<input>\n' +
           '<object> bar </object>\n' +
           '<select> baz </select>\n' +
           '<textarea> moo </textarea>\n';
   output = '<label>foo</label> <input> <object>bar</object> <select>baz</select> <textarea> moo </textarea>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   input = '<pre>\n' +
           'foo\n' +
           '<br>\n' +
@@ -361,130 +413,130 @@ QUnit.test('space normalization around text', function(assert) {
           '</pre>\n' +
           'baz\n';
   output = '<pre>\nfoo\n<br>\nbar\n</pre>baz';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('types of whitespace that should always be preserved', function(assert) {
   // Hair space:
   var input = '<div>\u200afo\u200ao\u200a</div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), input);
+  test_minify(assert, input, { collapseWhitespace: true }, input);
 
   // Hair space passed as HTML entity:
   var inputWithEntities = '<div>&#8202;fo&#8202;o&#8202;</div>';
-  assert.equal(minify(inputWithEntities, { collapseWhitespace: true }), inputWithEntities);
+  test_minify(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
 
   // Hair space passed as HTML entity, in decodeEntities:true mode:
-  assert.equal(minify(inputWithEntities, { collapseWhitespace: true, decodeEntities: true }), input);
+  test_minify(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
 
 
   // Non-breaking space:
   input = '<div>\xa0fo\xa0o\xa0</div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), input);
+  test_minify(assert, input, { collapseWhitespace: true }, input);
 
   // Non-breaking space passed as HTML entity:
   inputWithEntities = '<div>&nbsp;fo&nbsp;o&nbsp;</div>';
-  assert.equal(minify(inputWithEntities, { collapseWhitespace: true }), inputWithEntities);
+  test_minify(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
 
   // Non-breaking space passed as HTML entity, in decodeEntities:true mode:
-  assert.equal(minify(inputWithEntities, { collapseWhitespace: true, decodeEntities: true }), input);
+  test_minify(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
 
   // Do not remove hair space when preserving line breaks between tags:
   input = '<p></p>\u200a\n<p></p>\n';
-  assert.equal(minify(input, { collapseWhitespace: true, preserveLineBreaks: true }), input);
+  test_minify(assert, input, { collapseWhitespace: true, preserveLineBreaks: true }, input);
 
   // Preserve hair space in attributes:
   input = '<p class="foo\u200abar"></p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), input);
+  test_minify(assert, input, { collapseWhitespace: true }, input);
 
   // Preserve hair space in class names when deduplicating and reordering:
   input = '<a class="0 1\u200a3 2 3"></a>';
-  assert.equal(minify(input, { sortClassName: false }), input);
-  assert.equal(minify(input, { sortClassName: true }), input);
+  test_minify(assert, input, { sortClassName: false }, input);
+  test_minify(assert, input, { sortClassName: true }, input);
 });
 
 QUnit.test('doctype normalization', function(assert) {
   var input;
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"\n    "http://www.w3.org/TR/html4/strict.dtd">';
-  assert.equal(minify(input, { useShortDoctype: true }), '<!DOCTYPE html>');
+  test_minify(assert, input, { useShortDoctype: true }, '<!DOCTYPE html>');
 
   input = '<!DOCTYPE html>';
-  assert.equal(minify(input, { useShortDoctype: true }), input);
+  test_minify(assert, input, { useShortDoctype: true }, input);
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">';
-  assert.equal(minify(input, { useShortDoctype: false }), input);
+  test_minify(assert, input, { useShortDoctype: false }, input);
 });
 
 QUnit.test('removing comments', function(assert) {
   var input;
 
   input = '<!-- test -->';
-  assert.equal(minify(input, { removeComments: true }), '');
+  test_minify(assert, input, { removeComments: true }, '');
 
   input = '<!-- foo --><div>baz</div><!-- bar\n\n moo -->';
-  assert.equal(minify(input, { removeComments: true }), '<div>baz</div>');
-  assert.equal(minify(input, { removeComments: false }), input);
+  test_minify(assert, input, { removeComments: true }, '<div>baz</div>');
+  test_minify(assert, input, { removeComments: false }, input);
 
   input = '<p title="<!-- comment in attribute -->">foo</p>';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<script><!-- alert(1) --></script>';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<STYLE><!-- alert(1) --></STYLE>';
-  assert.equal(minify(input, { removeComments: true }), '<style><!-- alert(1) --></style>');
+  test_minify(assert, input, { removeComments: true }, '<style><!-- alert(1) --></style>');
 });
 
 QUnit.test('ignoring comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { removeComments: false }), input);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { removeComments: false }, input);
 
   input = '<!--! foo --><div>baz</div><!--! bar\n\n moo -->';
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { removeComments: false }), input);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { removeComments: false }, input);
 
   input = '<!--! foo --><div>baz</div><!-- bar\n\n moo -->';
-  assert.equal(minify(input, { removeComments: true }), '<!--! foo --><div>baz</div>');
-  assert.equal(minify(input, { removeComments: false }), input);
+  test_minify(assert, input, { removeComments: true }, '<!--! foo --><div>baz</div>');
+  test_minify(assert, input, { removeComments: false }, input);
 
   input = '<!-- ! test -->';
-  assert.equal(minify(input, { removeComments: true }), '');
-  assert.equal(minify(input, { removeComments: false }), input);
+  test_minify(assert, input, { removeComments: true }, '');
+  test_minify(assert, input, { removeComments: false }, input);
 
   input = '<div>\n\n   \t<div><div>\n\n<p>\n\n<!--!      \t\n\nbar\n\n moo         -->      \n\n</p>\n\n        </div>  </div></div>';
   output = '<div><div><div><p><!--!      \t\n\nbar\n\n moo         --></p></div></div></div>';
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { removeComments: true, collapseWhitespace: true }), output);
-  assert.equal(minify(input, { removeComments: false }), input);
-  assert.equal(minify(input, { removeComments: false, collapseWhitespace: true }), output);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, output);
+  test_minify(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, { removeComments: false, collapseWhitespace: true }, output);
 
   input = '<p rel="<!-- comment in attribute -->" title="<!--! ignored comment in attribute -->">foo</p>';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 });
 
 QUnit.test('conditional comments', function(assert) {
   var input, output;
 
   input = '<![if IE 5]>test<![endif]>';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 6]>test<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 7]>-->test<!--<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 8]><!-->test<!--<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<!--[if lt IE 5.5]>test<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<!--[if (gt IE 5)&(lt IE 7)]>test<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
 
   input = '<html>\n' +
           '  <head>\n' +
@@ -502,22 +554,22 @@ QUnit.test('conditional comments', function(assert) {
            '        alert("ie8!");\n' +
            '      </script>\n' +
            '    <![endif]-->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
     removeOptionalTags: true,
     removeScriptTypeAttributes: true
-  }), output);
+  }, output);
   output = '<head><!--[if lte IE 8]><script>alert("ie8!")</script><![endif]-->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
     removeOptionalTags: true,
     removeScriptTypeAttributes: true,
     processConditionalComments: true
-  }), output);
+  }, output);
 
   input = '<!DOCTYPE html>\n' +
           '<html lang="en">\n' +
@@ -545,15 +597,15 @@ QUnit.test('conditional comments', function(assert) {
            '<!--[if IE 8]><html class="no-js ie8"><![endif]-->' +
            '<!--[if gt IE 8]><!--><html class="no-js"><!--<![endif]-->' +
            '<title>Document</title></head><body></body></html>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true
-  }), output);
-  assert.equal(minify(input, {
+  }, output);
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('collapsing space in conditional comments', function(assert) {
@@ -562,215 +614,215 @@ QUnit.test('collapsing space in conditional comments', function(assert) {
   input = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
             '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css" />\n\t' +
           '<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { removeComments: true, collapseWhitespace: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, input);
   output = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">\n\t' +
            '<![endif]-->';
-  assert.equal(minify(input, { removeComments: true, processConditionalComments: true }), output);
+  test_minify(assert, input, { removeComments: true, processConditionalComments: true }, output);
   output = '<!--[if IE 7]>' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">' +
            '<![endif]-->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }), output);
+  }, output);
 
   input = '<!--[if lte IE 6]>\n    \n   \n\n\n\t' +
             '<p title=" sigificant     whitespace   ">blah blah</p>' +
           '<![endif]-->';
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { removeComments: true, collapseWhitespace: true }), input);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, input);
   output = '<!--[if lte IE 6]>' +
              '<p title=" sigificant     whitespace   ">blah blah</p>' +
            '<![endif]-->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('remove comments from scripts', function(assert) {
   var input, output;
 
   input = '<script><!--\nalert(1);\n--></script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--alert(2);--></script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--alert(3);\n--></script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--\nalert(4);--></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><!--alert(5);\nalert(6);\nalert(7);--></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><!--alert(8)</script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->"); -->\n\n   </script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->");\n -->\n\n   </script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script type="text/javascript">alert("--\\x3e")</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script> //   <!--   \n  alert(1)   //  --> </script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/html">\n<div>\n</div>\n<!-- aa -->\n</script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 });
 
 QUnit.test('remove comments from styles', function(assert) {
   var input, output;
 
   input = '<style><!--\np.a{background:red}\n--></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.a{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.b{background:red}--></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.b{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.c{background:red}\n--></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.c{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--\np.d{background:red}--></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.d{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.e{background:red}\np.f{background:red}\np.g{background:red}--></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.e{background:red}p.f{background:red}p.g{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style>p.h{background:red}<!--\np.i{background:red}\n-->p.j{background:red}</style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.h{background:red}p.i{background:red}p.j{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/css"><!-- p { color: red } --></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style type="text/css">p{color:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/css">p::before { content: "<!--" }</style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style type="text/css">p::before{content:"<!--"}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/html">\n<div>\n</div>\n<!-- aa -->\n</style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: true }, input);
 });
 
 QUnit.test('remove CDATA sections from scripts/styles', function(assert) {
   var input, output;
 
   input = '<script><![CDATA[\nalert(1)\n]]></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(2)]]></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(3)\n]]></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[\nalert(4)]]></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(5)\nalert(6)\nalert(7)]]></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script>/*<![CDATA[*/alert(8)/*]]>*/</script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script>alert(8)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script>//<![CDATA[\nalert(9)\n//]]></script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script>alert(9)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript"> /* \n\t  <![CDATA[  */ alert(10) /*  ]]>  */ \n </script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script type="text/javascript">alert(10)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script>\n\n//<![CDATA[\nalert(11)//]]></script>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<script>alert(11)</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<style><![CDATA[\np.a{background:red}\n]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.b{background:red}]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.c{background:red}\n]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[\np.d{background:red}]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.e{background:red}\np.f{background:red}\np.g{background:red}]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.f{background:red}p.g{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style>p.h{background:red}<![CDATA[\np.i{background:red}\n]]>p.j{background:red}</style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p.h{background:red}]]>p.j{background:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style>/* <![CDATA[ */p { color: red } // ]]></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p{color:red}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/html">\n<div>\n</div>\n<![CDATA[ aa ]]>\n</style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: true }, input);
 });
 
 QUnit.test('custom processors', function(assert) {
@@ -781,125 +833,125 @@ QUnit.test('custom processors', function(assert) {
   }
 
   input = '<style>\n.foo { font: 12pt "bar" } </style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: null }), input);
-  assert.equal(minify(input, { minifyCSS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: null }, input);
+  test_minify(assert, input, { minifyCSS: false }, input);
   output = '<style>Some CSS</style>';
-  assert.equal(minify(input, { minifyCSS: css }), output);
+  test_minify(assert, input, { minifyCSS: css }, output);
 
   input = '<p style="font: 12pt \'bar\'"></p>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: null }), input);
-  assert.equal(minify(input, { minifyCSS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: null }, input);
+  test_minify(assert, input, { minifyCSS: false }, input);
   output = '<p style="Some CSS"></p>';
-  assert.equal(minify(input, { minifyCSS: css }), output);
+  test_minify(assert, input, { minifyCSS: css }, output);
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: null }), input);
-  assert.equal(minify(input, { minifyCSS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: null }, input);
+  test_minify(assert, input, { minifyCSS: false }, input);
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="Some CSS">';
-  assert.equal(minify(input, { minifyCSS: css }), output);
+  test_minify(assert, input, { minifyCSS: css }, output);
 
   input = '<style media="(max-width: 737px)"></style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: null }), input);
-  assert.equal(minify(input, { minifyCSS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: null }, input);
+  test_minify(assert, input, { minifyCSS: false }, input);
   output = '<style media="Some CSS">Some CSS</style>';
-  assert.equal(minify(input, { minifyCSS: css }), output);
+  test_minify(assert, input, { minifyCSS: css }, output);
 
   function js(text, inline) {
     return inline ? 'Inline JS' : 'Normal JS';
   }
 
   input = '<script>\nalert(1); </script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: null }), input);
-  assert.equal(minify(input, { minifyJS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: null }, input);
+  test_minify(assert, input, { minifyJS: false }, input);
   output = '<script>Normal JS</script>';
-  assert.equal(minify(input, { minifyJS: js }), output);
+  test_minify(assert, input, { minifyJS: js }, output);
 
   input = '<p onload="alert(1);"></p>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyJS: null }), input);
-  assert.equal(minify(input, { minifyJS: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyJS: null }, input);
+  test_minify(assert, input, { minifyJS: false }, input);
   output = '<p onload="Inline JS"></p>';
-  assert.equal(minify(input, { minifyJS: js }), output);
+  test_minify(assert, input, { minifyJS: js }, output);
 
   function url() {
     return 'URL';
   }
 
   input = '<a href="http://site.com/foo">bar</a>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyURLs: null }), input);
-  assert.equal(minify(input, { minifyURLs: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyURLs: null }, input);
+  test_minify(assert, input, { minifyURLs: false }, input);
   output = '<a href="URL">bar</a>';
-  assert.equal(minify(input, { minifyURLs: url }), output);
+  test_minify(assert, input, { minifyURLs: url }, output);
 
   input = '<style>\n.foo { background: url("http://site.com/foo") } </style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyURLs: null }), input);
-  assert.equal(minify(input, { minifyURLs: false }), input);
-  assert.equal(minify(input, { minifyURLs: url }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyURLs: null }, input);
+  test_minify(assert, input, { minifyURLs: false }, input);
+  test_minify(assert, input, { minifyURLs: url }, input);
   output = '<style>.foo{background:url(URL)}</style>';
-  assert.equal(minify(input, { minifyCSS: true, minifyURLs: url }), output);
+  test_minify(assert, input, { minifyCSS: true, minifyURLs: url }, output);
 });
 
 QUnit.test('empty attributes', function(assert) {
   var input;
 
   input = '<p id="" class="" STYLE=" " title="\n" lang="" dir="">x</p>';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<p>x</p>');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
 
   input = '<p onclick=""   ondblclick=" " onmousedown="" ONMOUSEUP="" onmouseover=" " onmousemove="" onmouseout="" ' +
           'onkeypress=\n\n  "\n     " onkeydown=\n"" onkeyup\n="">x</p>';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<p>x</p>');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
 
   input = '<input onfocus="" onblur="" onchange=" " value=" boo ">';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<input value=" boo ">');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<input value=" boo ">');
 
   input = '<input value="" name="foo">';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<input name="foo">');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<input name="foo">');
 
   input = '<img src="" alt="">';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<img src="" alt="">');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<img src="" alt="">');
 
   // preserve unrecognized attribute
   // remove recognized attrs with unspecified values
   input = '<div data-foo class id style title lang dir onfocus onblur onchange onclick ondblclick onmousedown onmouseup onmouseover onmousemove onmouseout onkeypress onkeydown onkeyup></div>';
-  assert.equal(minify(input, { removeEmptyAttributes: true }), '<div data-foo></div>');
+  test_minify(assert, input, { removeEmptyAttributes: true }, '<div data-foo></div>');
 
   // additional remove attributes
   input = '<img src="" alt="">';
-  assert.equal(minify(input, { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } }), '<img alt="">');
+  test_minify(assert, input, { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } }, '<img alt="">');
 });
 
 QUnit.test('cleaning class/style attributes', function(assert) {
   var input, output;
 
   input = '<p class=" foo bar  ">foo bar baz</p>';
-  assert.equal(minify(input), '<p class="foo bar">foo bar baz</p>');
+  test_minify(assert, input, '<p class="foo bar">foo bar baz</p>');
 
   input = '<p class=" foo      ">foo bar baz</p>';
-  assert.equal(minify(input), '<p class="foo">foo bar baz</p>');
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<p class=foo>foo bar baz</p>');
+  test_minify(assert, input, '<p class="foo">foo bar baz</p>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<p class=foo>foo bar baz</p>');
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n   ">foo bar baz</p>';
   output = '<p class="foo">foo bar baz</p>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n  class1 class-23 ">foo bar baz</p>';
   output = '<p class="foo class1 class-23">foo bar baz</p>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<p style="    color: red; background-color: rgb(100, 75, 200);  "></p>';
   output = '<p style="color: red; background-color: rgb(100, 75, 200);"></p>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<p style="font-weight: bold  ; "></p>';
   output = '<p style="font-weight: bold;"></p>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('cleaning URI-based attributes', function(assert) {
@@ -907,41 +959,41 @@ QUnit.test('cleaning URI-based attributes', function(assert) {
 
   input = '<a href="   http://example.com  ">x</a>';
   output = '<a href="http://example.com">x</a>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<a href="  \t\t  \n \t  ">x</a>';
   output = '<a href="">x</a>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<img src="   http://example.com  " title="bleh   " longdesc="  http://example.com/longdesc \n\n   \t ">';
   output = '<img src="http://example.com" title="bleh   " longdesc="http://example.com/longdesc">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<img src="" usemap="   http://example.com  ">';
   output = '<img src="" usemap="http://example.com">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<form action="  somePath/someSubPath/someAction?foo=bar&baz=qux     "></form>';
   output = '<form action="somePath/someSubPath/someAction?foo=bar&baz=qux"></form>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<BLOCKQUOTE cite=" \n\n\n http://www.mycom.com/tolkien/twotowers.html     "><P>foobar</P></BLOCKQUOTE>';
   output = '<blockquote cite="http://www.mycom.com/tolkien/twotowers.html"><p>foobar</p></blockquote>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<head profile="       http://gmpg.org/xfn/11    "></head>';
   output = '<head profile="http://gmpg.org/xfn/11"></head>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<object codebase="   http://example.com  "></object>';
   output = '<object codebase="http://example.com"></object>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<span profile="   1, 2, 3  ">foo</span>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   input = '<div action="  foo-bar-baz ">blah</div>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('cleaning Number-based attributes', function(assert) {
@@ -949,27 +1001,27 @@ QUnit.test('cleaning Number-based attributes', function(assert) {
 
   input = '<a href="#" tabindex="   1  ">x</a><button tabindex="   2  ">y</button>';
   output = '<a href="#" tabindex="1">x</a><button tabindex="2">y</button>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<input value="" maxlength="     5 ">';
   output = '<input value="" maxlength="5">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<select size="  10   \t\t "><option>x</option></select>';
   output = '<select size="10"><option>x</option></select>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<textarea rows="   20  " cols="  30      "></textarea>';
   output = '<textarea rows="20" cols="30"></textarea>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<COLGROUP span="   40  "><COL span="  39 "></COLGROUP>';
   output = '<colgroup span="40"><col span="39"></colgroup>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<tr><td colspan="    2   ">x</td><td rowspan="   3 "></td></tr>';
   output = '<tr><td colspan="2">x</td><td rowspan="3"></td></tr>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('cleaning other attributes', function(assert) {
@@ -977,50 +1029,50 @@ QUnit.test('cleaning other attributes', function(assert) {
 
   input = '<a href="#" onclick="  window.prompt(\'boo\'); " onmouseover=" \n\n alert(123)  \t \n\t  ">blah</a>';
   output = '<a href="#" onclick="window.prompt(\'boo\');" onmouseover="alert(123)">blah</a>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</p></body>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;form method="get" ...>)', function(assert) {
   var input;
 
   input = '<form method="get">hello world</form>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<form>hello world</form>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<form>hello world</form>');
 
   input = '<form method="post">hello world</form>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<form method="post">hello world</form>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<form method="post">hello world</form>');
 });
 
 QUnit.test('removing redundant attributes (&lt;input type="text" ...>)', function(assert) {
   var input;
 
   input = '<input type="text">';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<input>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<input>');
 
   input = '<input type="  TEXT  " value="foo">';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<input value="foo">');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<input value="foo">');
 
   input = '<input type="checkbox">';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<input type="checkbox">');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<input type="checkbox">');
 });
 
 QUnit.test('removing redundant attributes (&lt;a name="..." id="..." ...>)', function(assert) {
   var input;
 
   input = '<a id="foo" name="foo">blah</a>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<a id="foo">blah</a>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<a id="foo">blah</a>');
 
   input = '<input id="foo" name="foo">';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), input);
+  test_minify(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<a name="foo">blah</a>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), input);
+  test_minify(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<a href="..." name="  bar  " id="bar" >blah</a>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<a href="..." id="bar">blah</a>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<a href="..." id="bar">blah</a>');
 });
 
 QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)', function(assert) {
@@ -1028,125 +1080,125 @@ QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)'
 
   input = '<script type="text/javascript" charset="UTF-8">alert(222);</script>';
   output = '<script type="text/javascript">alert(222);</script>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), output);
+  test_minify(assert, input, { removeRedundantAttributes: true }, output);
 
   input = '<script type="text/javascript" src="http://example.com" charset="UTF-8">alert(222);</script>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), input);
+  test_minify(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<script CHARSET=" ... ">alert(222);</script>';
   output = '<script>alert(222);</script>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), output);
+  test_minify(assert, input, { removeRedundantAttributes: true }, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;... language="javascript" ...>)', function(assert) {
   var input;
 
   input = '<script language="Javascript">x=2,y=4</script>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<script>x=2,y=4</script>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
 
   input = '<script LANGUAGE = "  javaScript  ">x=2,y=4</script>';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), '<script>x=2,y=4</script>');
+  test_minify(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
 });
 
 QUnit.test('removing redundant attributes (&lt;area shape="rect" ...>)', function(assert) {
   var input = '<area shape="rect" coords="696,25,958,47" href="#" title="foo">';
   var output = '<area coords="696,25,958,47" href="#" title="foo">';
-  assert.equal(minify(input, { removeRedundantAttributes: true }), output);
+  test_minify(assert, input, { removeRedundantAttributes: true }, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;... = "javascript: ..." ...>)', function(assert) {
   var input;
 
   input = '<p onclick="javascript:alert(1)">x</p>';
-  assert.equal(minify(input), '<p onclick="alert(1)">x</p>');
+  test_minify(assert, input, '<p onclick="alert(1)">x</p>');
 
   input = '<p onclick="javascript:x">x</p>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<p onclick=x>x</p>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<p onclick=x>x</p>');
 
   input = '<p onclick=" JavaScript: x">x</p>';
-  assert.equal(minify(input), '<p onclick="x">x</p>');
+  test_minify(assert, input, '<p onclick="x">x</p>');
 
   input = '<p title="javascript:(function() { /* some stuff here */ })()">x</p>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('removing javascript type attributes', function(assert) {
   var input, output;
 
   input = '<script type="">alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: false }), input);
+  test_minify(assert, input, { removeScriptTypeAttributes: false }, input);
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: true }), output);
+  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="text/javascript">alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: false }), input);
+  test_minify(assert, input, { removeScriptTypeAttributes: false }, input);
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: true }), output);
+  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<SCRIPT TYPE="  text/javascript ">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: true }), output);
+  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="application/javascript;version=1.8">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: true }), output);
+  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="text/vbscript">MsgBox("foo bar")</script>';
   output = '<script type="text/vbscript">MsgBox("foo bar")</script>';
-  assert.equal(minify(input, { removeScriptTypeAttributes: true }), output);
+  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
 });
 
 QUnit.test('removing type="text/css" attributes', function(assert) {
   var input, output;
 
   input = '<style type="">.foo { color: red }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: false }), input);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: false }, input);
   output = '<style>.foo { color: red }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), output);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<style type="text/css">.foo { color: red }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: false }), input);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: false }, input);
   output = '<style>.foo { color: red }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), output);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<STYLE TYPE = "  text/CSS ">body { font-size: 1.75em }</style>';
   output = '<style>body { font-size: 1.75em }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), output);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<style type="text/plain">.foo { background: green }</style>';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), input);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, input);
 
   input = '<link rel="stylesheet" type="text/css" href="http://example.com">';
   output = '<link rel="stylesheet" href="http://example.com">';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), output);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<link rel="alternate" type="application/atom+xml" href="data.xml">';
-  assert.equal(minify(input, { removeStyleLinkTypeAttributes: true }), input);
+  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, input);
 });
 
 QUnit.test('removing attribute quotes', function(assert) {
   var input;
 
   input = '<p title="blah" class="a23B-foo.bar_baz:qux" id="moo">foo</p>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
 
   input = '<input value="hello world">';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<input value="hello world">');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<input value="hello world">');
 
   input = '<a href="#" title="foo#bar">x</a>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<a href=# title=foo#bar>x</a>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<a href=# title=foo#bar>x</a>');
 
   input = '<a href="http://example.com/" title="blah">\nfoo\n\n</a>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<a href=http://example.com/ title=blah>\nfoo\n\n</a>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<a href=http://example.com/ title=blah>\nfoo\n\n</a>');
 
   input = '<a title="blah" href="http://example.com/">\nfoo\n\n</a>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<a title=blah href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<a title=blah href=http://example.com/ >\nfoo\n\n</a>');
 
   input = '<a href="http://example.com/" title="">\nfoo\n\n</a>';
-  assert.equal(minify(input, { removeAttributeQuotes: true, removeEmptyAttributes: true }), '<a href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify(assert, input, { removeAttributeQuotes: true, removeEmptyAttributes: true }, '<a href=http://example.com/ >\nfoo\n\n</a>');
 
   input = '<p class=foo|bar:baz></p>';
-  assert.equal(minify(input, { removeAttributeQuotes: true }), '<p class=foo|bar:baz></p>');
+  test_minify(assert, input, { removeAttributeQuotes: true }, '<p class=foo|bar:baz></p>');
 });
 
 QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
@@ -1158,10 +1210,10 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   input = '<input checked="checked">';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   // With multiple rules
   customAttrOptions = {
@@ -1172,16 +1224,16 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   input = '<input {{#unless value}}checked="checked"{{/unless}}>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   input = '<input {{#if value1}}data-attr="example" {{/if}}{{#unless value2}}checked="checked"{{/unless}}>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   input = '<input checked="checked">';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 
   // With multiple rules and richer options
   customAttrOptions = {
@@ -1194,13 +1246,13 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  assert.equal(minify(input, customAttrOptions), '<input {{#if value}}checked{{/if}}>');
+  test_minify(assert, input, customAttrOptions, '<input {{#if value}}checked{{/if}}>');
 
   input = '<input {{#if value1}}checked="checked"{{/if}} {{#if value2}}data-attr="foo"{{/if}}/>';
-  assert.equal(minify(input, customAttrOptions), '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>');
+  test_minify(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>');
 
   customAttrOptions.keepClosingSlash = true;
-  assert.equal(minify(input, customAttrOptions), '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>');
+  test_minify(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>');
 });
 
 QUnit.test('preserving custom attribute-joining markup', function(assert) {
@@ -1210,9 +1262,9 @@ QUnit.test('preserving custom attribute-joining markup', function(assert) {
     customAttrAssign: [polymerConditionalAttributeJoin]
   };
   input = '<div flex?="{{mode != cover}}"></div>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
   input = '<div flex?="{{mode != cover}}" class="foo"></div>';
-  assert.equal(minify(input, customAttrOptions), input);
+  test_minify(assert, input, customAttrOptions, input);
 });
 
 QUnit.test('collapsing whitespace', function(assert) {
@@ -1220,37 +1272,37 @@ QUnit.test('collapsing whitespace', function(assert) {
 
   input = '<script type="text/javascript">  \n\t   alert(1) \n\n\n  \t </script>';
   output = '<script type="text/javascript">alert(1)</script>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo</p>    <p> bar</p>\n\n   \n\t\t  <div title="quz">baz  </div>';
   output = '<p>foo</p><p>bar</p><div title="quz">baz</div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p> foo    bar</p>';
   output = '<p>foo bar</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo\nbar</p>';
   output = '<p>foo bar</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p> foo    <span>  blah     <i>   22</i>    </span> bar <img src=""></p>';
   output = '<p>foo <span>blah <i>22</i> </span>bar <img src=""></p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
   output = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<div><textarea></textarea>    </div>';
   output = '<div><textarea></textarea></div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<div><pRe> $foo = "baz"; </pRe>    </div>';
   output = '<div><pre> $foo = "baz"; </pre></div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
   output = '<div><pRe>$foo = "baz";</pRe></div>';
-  assert.equal(minify(input, { collapseWhitespace: true, caseSensitive: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, caseSensitive: true }, output);
 
   input = '<script type="text/javascript">var = "hello";</script>\r\n\r\n\r\n' +
           '<style type="text/css">#foo { color: red;        }          </style>\r\n\r\n\r\n' +
@@ -1268,153 +1320,153 @@ QUnit.test('collapsing whitespace', function(assert) {
            '</div></div></div></div></div></div>' +
            '<pre>       \r\nxxxx</pre><span>x</span> <span>Hello</span> <b>billy</b> ' +
            '<input type="text"> <textarea></textarea><pre></pre>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<pre title="some title...">   hello     world </pre>';
   output = '<pre title="some title...">   hello     world </pre>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<pre title="some title..."><code>   hello     world </code></pre>';
   output = '<pre title="some title..."><code>   hello     world </code></pre>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<script>alert("foo     bar")    </script>';
   output = '<script>alert("foo     bar")</script>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<style>alert("foo     bar")    </style>';
   output = '<style>alert("foo     bar")</style>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('removing empty elements', function(assert) {
   var input, output;
 
-  assert.equal(minify('<p>x</p>', { removeEmptyElements: true }), '<p>x</p>');
-  assert.equal(minify('<p></p>', { removeEmptyElements: true }), '');
+  test_minify(assert, '<p>x</p>', { removeEmptyElements: true }, '<p>x</p>');
+  test_minify(assert, '<p></p>', { removeEmptyElements: true }, '');
 
   input = '<p>foo<span>bar</span><span></span></p>';
   output = '<p>foo<span>bar</span></p>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<a href="http://example/com" title="hello world"></a>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<iframe></iframe>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<iframe src="page.html"></iframe>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<iframe srcdoc="<h1>Foo</h1>"></iframe>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<video></video>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<video src="preview.ogg"></video>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<audio autoplay></audio>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<audio src="startup.mp3" autoplay></audio>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<object type="application/x-shockwave-flash"></object>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<object data="game.swf" type="application/x-shockwave-flash"></object>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<applet archive="game.zip" width="250" height="150"></applet>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<applet code="game.class" archive="game.zip" width="250" height="150"></applet>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<textarea cols="10" rows="10"></textarea>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<div>hello<span>world</span></div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<p>x<span title="<" class="blah-moo"></span></p>';
   output = '<p>x</p>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<div>x<div>y <div>blah</div><div></div>foo</div>z</div>';
   output = '<div>x<div>y <div>blah</div>foo</div>z</div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<img src="">';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
 
   input = '<p><!-- x --></p>';
   output = '';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
 
   input = '<script src="foo.js"></script>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
   input = '<script></script>';
-  assert.equal(minify(input, { removeEmptyElements: true }), '');
+  test_minify(assert, input, { removeEmptyElements: true }, '');
 
   input = '<div>after<span></span> </div>';
   output = '<div>after </div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
   output = '<div>after</div>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>before <span></span></div>';
   output = '<div>before </div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
   output = '<div>before</div>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>both <span></span> </div>';
   output = '<div>both  </div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
   output = '<div>both</div>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>unary <span></span><link></div>';
   output = '<div>unary <link></div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeEmptyElements: true }, output);
   output = '<div>unary<link></div>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>Empty <!-- NOT --> </div>';
-  assert.equal(minify(input, { removeEmptyElements: true }), input);
+  test_minify(assert, input, { removeEmptyElements: true }, input);
   output = '<div>Empty<!-- NOT --></div>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 });
 
 QUnit.test('collapsing boolean attributes', function(assert) {
   var input, output;
 
   input = '<input disabled="disabled">';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<input disabled>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input disabled>');
 
   input = '<input CHECKED = "checked" readonly="readonly">';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<input checked readonly>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input checked readonly>');
 
   input = '<option name="blah" selected="selected">moo</option>';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<option name="blah" selected>moo</option>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<option name="blah" selected>moo</option>');
 
   input = '<input autofocus="autofocus">';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<input autofocus>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input autofocus>');
 
   input = '<input required="required">';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<input required>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input required>');
 
   input = '<input multiple="multiple">';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), '<input multiple>');
+  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input multiple>');
 
   input = '<div Allowfullscreen=foo Async=foo Autofocus=foo Autoplay=foo Checked=foo Compact=foo Controls=foo ' +
     'Declare=foo Default=foo Defaultchecked=foo Defaultmuted=foo Defaultselected=foo Defer=foo Disabled=foo ' +
@@ -1426,129 +1478,129 @@ QUnit.test('collapsing boolean attributes', function(assert) {
     'defaultmuted defaultselected defer disabled enabled formnovalidate hidden indeterminate inert ' +
     'ismap itemscope loop multiple muted nohref noresize noshade novalidate nowrap open pauseonexit readonly ' +
     'required reversed scoped seamless selected sortable truespeed typemustmatch visible></div>';
-  assert.equal(minify(input, { collapseBooleanAttributes: true }), output);
+  test_minify(assert, input, { collapseBooleanAttributes: true }, output);
   output = '<div Allowfullscreen Async Autofocus Autoplay Checked Compact Controls Declare Default Defaultchecked ' +
     'Defaultmuted Defaultselected Defer Disabled Enabled Formnovalidate Hidden Indeterminate Inert ' +
     'Ismap Itemscope Loop Multiple Muted Nohref Noresize Noshade Novalidate Nowrap Open Pauseonexit Readonly ' +
     'Required Reversed Scoped Seamless Selected Sortable Truespeed Typemustmatch Visible></div>';
-  assert.equal(minify(input, { collapseBooleanAttributes: true, caseSensitive: true }), output);
+  test_minify(assert, input, { collapseBooleanAttributes: true, caseSensitive: true }, output);
 });
 
 QUnit.test('collapsing enumerated attributes', function(assert) {
-  assert.equal(minify('<div draggable="auto"></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div draggable="true"></div>', { collapseBooleanAttributes: true }), '<div draggable="true"></div>');
-  assert.equal(minify('<div draggable="false"></div>', { collapseBooleanAttributes: true }), '<div draggable="false"></div>');
-  assert.equal(minify('<div draggable="foo"></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div draggable></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div Draggable="auto"></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div Draggable="true"></div>', { collapseBooleanAttributes: true }), '<div draggable="true"></div>');
-  assert.equal(minify('<div Draggable="false"></div>', { collapseBooleanAttributes: true }), '<div draggable="false"></div>');
-  assert.equal(minify('<div Draggable="foo"></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div Draggable></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
-  assert.equal(minify('<div draggable="Auto"></div>', { collapseBooleanAttributes: true }), '<div draggable></div>');
+  test_minify(assert, '<div draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
+  test_minify(assert, '<div draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
+  test_minify(assert, '<div draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div Draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div Draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
+  test_minify(assert, '<div Draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
+  test_minify(assert, '<div Draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div Draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div draggable="Auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
 });
 
 QUnit.test('keeping trailing slashes in tags', function(assert) {
-  assert.equal(minify('<img src="test"/>', { keepClosingSlash: true }), '<img src="test"/>');
+  test_minify(assert, '<img src="test"/>', { keepClosingSlash: true }, '<img src="test"/>');
   // https://github.com/kangax/html-minifier/issues/233
-  assert.equal(minify('<img src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }), '<img src=test />');
-  assert.equal(minify('<img src="test" id=""/>', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true }), '<img src=test />');
-  assert.equal(minify('<img title="foo" src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }), '<img title=foo src=test />');
+  test_minify(assert, '<img src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img src=test />');
+  test_minify(assert, '<img src="test" id=""/>', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true }, '<img src=test />');
+  test_minify(assert, '<img title="foo" src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img title=foo src=test />');
 });
 
 QUnit.test('removing optional tags', function(assert) {
   var input, output;
 
   input = '<p>foo';
-  assert.equal(minify(input, { removeOptionalTags: true }), input);
+  test_minify(assert, input, { removeOptionalTags: true }, input);
 
   input = '</p>';
   output = '<p>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<body></body>';
   output = '';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
-  assert.equal(minify(input, { removeOptionalTags: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
 
   input = '<html><head></head><body></body></html>';
   output = '';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
-  assert.equal(minify(input, { removeOptionalTags: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
 
   input = ' <html></html>';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html> </html>';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html></html> ';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = ' <html><body></body></html>';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html> <body></body></html>';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body> </body></html>';
   output = '<body> ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body></body> </html>';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body></body></html> ';
   output = ' ';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><head><title>hello</title></head><body><p>foo<span>bar</span></p></body></html>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<title>hello</title><p>foo<span>bar</span>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<html lang=""><head><title>hello</title></head><body style=""><p>foo<span>bar</span></p></body></html>';
   output = '<html lang=""><title>hello</title><body style=""><p>foo<span>bar</span>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
   output = '<title>hello</title><p>foo<span>bar</span>';
-  assert.equal(minify(input, { removeOptionalTags: true, removeEmptyAttributes: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true, removeEmptyAttributes: true }, output);
 
   input = '<html><head><title>a</title><link href="b.css" rel="stylesheet"/></head><body><a href="c.html"></a><div class="d"><input value="e"/></div></body></html>';
   output = '<title>a</title><link href="b.css" rel="stylesheet"><a href="c.html"></a><div class="d"><input value="e"></div>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><div><p>This is some text in a div</p><details>Followed by some details</details></div><div><p>This is some more text in a div</p></div></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><div><p>This is some text in a div<details>Followed by some details</details></div><div><p>This is some more text in a div</div>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><noscript><p>This is some text in a noscript</p><details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><body><noscript><p>This is some text in a noscript<details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<md-list-item ui-sref=".app-config"><md-icon md-font-icon="mdi-settings"></md-icon><p translate>Configure</p></md-list-item>';
-  assert.equal(minify(input, { removeOptionalTags: true }), input);
+  test_minify(assert, input, { removeOptionalTags: true }, input);
 });
 
 QUnit.test('removing optional tags in tables', function(assert) {
@@ -1559,21 +1611,21 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<tbody><tr><td>boo</td><td>moo</td><td>loo</td></tr> </tbody>' +
             '<tfoot><tr><th>baz</th> <th>qux</th><td>boo</td></tr></tfoot>' +
           '</table>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar</th> <th>baz</thead> ' +
              '<tr><td>boo<td>moo<td>loo</tr> ' +
              '<tfoot><tr><th>baz</th> <th>qux<td>boo' +
            '</table>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar<th>baz' +
              '<tbody><tr><td>boo<td>moo<td>loo' +
              '<tfoot><tr><th>baz<th>qux<td>boo' +
            '</table>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<table>' +
             '<caption>foo</caption>' +
@@ -1582,7 +1634,7 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<!-- blah -->' +
             '<tbody><tr><th>bar</th><td>baz</td><th>qux</th></tr></tbody>' +
           '</table>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   output = '<table>' +
              '<caption>foo</caption>' +
@@ -1591,22 +1643,22 @@ QUnit.test('removing optional tags in tables', function(assert) {
              '<!-- blah -->' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   output = '<table>' +
              '<caption>foo' +
              '<col span="2"><col>' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  assert.equal(minify(input, { removeComments: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeComments: true, removeOptionalTags: true }, output);
 
   input = '<table>' +
             '<tbody></tbody>' +
           '</table>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
   output = '<table><tbody></table>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 });
 
 QUnit.test('removing optional tags in options', function(assert) {
@@ -1614,17 +1666,17 @@ QUnit.test('removing optional tags in options', function(assert) {
 
   input = '<select><option>foo</option><option>bar</option></select>';
   output = '<select><option>foo<option>bar</select>';
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 
   input = '<select>\n' +
           '  <option>foo</option>\n' +
           '  <option>bar</option>\n' +
           '</select>';
-  assert.equal(minify(input, { removeOptionalTags: true }), input);
+  test_minify(assert, input, { removeOptionalTags: true }, input);
   output = '<select><option>foo<option>bar</select>';
-  assert.equal(minify(input, { removeOptionalTags: true, collapseWhitespace: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true, collapseWhitespace: true }, output);
   output = '<select> <option>foo</option> <option>bar</option> </select>';
-  assert.equal(minify(input, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true }, output);
 
   // example from htmldog.com
   input = '<select name="catsndogs">' +
@@ -1643,40 +1695,40 @@ QUnit.test('removing optional tags in options', function(assert) {
                '<option>Grey Wolf<option>Red Fox<option>Fennec' +
            '</select>';
 
-  assert.equal(minify(input, { removeOptionalTags: true }), output);
+  test_minify(assert, input, { removeOptionalTags: true }, output);
 });
 
 QUnit.test('custom components', function(assert) {
   var input = '<custom-component>Oh, my.</custom-component>';
   var output = '<custom-component>Oh, my.</custom-component>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('HTML4: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  assert.equal(minify(input, { html5: false }), input);
+  test_minify(assert, input, { html5: false }, input);
 });
 
 QUnit.test('HTML5: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  assert.equal(minify(input, { html5: true }), input);
+  test_minify(assert, input, { html5: true }, input);
 });
 
 QUnit.test('HTML4: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"></a><div>Well, look at me! I\'m a div!</div>';
-  assert.equal(minify(input, { html5: false }), output);
+  test_minify(assert, input, { html5: false }, output);
 });
 
 QUnit.test('HTML5: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  assert.equal(minify(input, { html5: true }), output);
+  test_minify(assert, input, { html5: true }, output);
 });
 
 QUnit.test('HTML5: enabled by default', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  assert.equal(minify(input, { html5: true }), minify(input));
+  test_minify(assert, input, { html5: true }, minify(input));
 });
 
 QUnit.test('phrasing content', function(assert) {
@@ -1684,12 +1736,12 @@ QUnit.test('phrasing content', function(assert) {
 
   input = '<p>a<div>b</div>';
   output = '<p>a</p><div>b</div>';
-  assert.equal(minify(input, { html5: true }), output);
+  test_minify(assert, input, { html5: true }, output);
   output = '<p>a<div>b</div></p>';
-  assert.equal(minify(input, { html5: false }), output);
+  test_minify(assert, input, { html5: false }, output);
 
   input = '<label>a<div>b</div>c</label>';
-  assert.equal(minify(input, { html5: true }), input);
+  test_minify(assert, input, { html5: true }, input);
 });
 
 // https://github.com/kangax/html-minifier/issues/888
@@ -1698,29 +1750,29 @@ QUnit.test('ul/ol should be phrasing content', function(assert) {
 
   input = '<p>a<ul><li>item</li></ul>';
   output = '<p>a</p><ul><li>item</li></ul>';
-  assert.equal(minify(input, { html5: true }), output);
+  test_minify(assert, input, { html5: true }, output);
 
   output = '<p>a<ul><li>item</ul>';
-  assert.equal(minify(input, { html5: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { html5: true, removeOptionalTags: true }, output);
 
   output = '<p>a<ul><li>item</li></ul></p>';
-  assert.equal(minify(input, { html5: false }), output);
+  test_minify(assert, input, { html5: false }, output);
 
   input = '<p>a<ol><li>item</li></ol></p>';
   output = '<p>a</p><ol><li>item</li></ol><p></p>';
-  assert.equal(minify(input, { html5: true }), output);
+  test_minify(assert, input, { html5: true }, output);
 
   output = '<p>a<ol><li>item</ol><p>';
-  assert.equal(minify(input, { html5: true, removeOptionalTags: true }), output);
+  test_minify(assert, input, { html5: true, removeOptionalTags: true }, output);
 
   output = '<p>a</p><ol><li>item</li></ol>';
-  assert.equal(minify(input, { html5: true, removeEmptyElements: true }), output);
+  test_minify(assert, input, { html5: true, removeEmptyElements: true }, output);
 });
 
 QUnit.test('phrasing content with Web Components', function(assert) {
   var input = '<span><phrasing-element></phrasing-element></span>';
   var output = '<span><phrasing-element></phrasing-element></span>';
-  assert.equal(minify(input, { html5: true }), output);
+  test_minify(assert, input, { html5: true }, output);
 });
 
 // https://github.com/kangax/html-minifier/issues/10
@@ -1730,52 +1782,52 @@ QUnit.test('Ignore custom fragments', function(assert) {
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n{{ ... }}\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %> <%= ... %> <? ... ?> No comment, but middle. {{ ... }} <?php ... ?> <?xml ... ?> Hello, this is the end!';
-  assert.equal(minify(input, {}), input);
-  assert.equal(minify(input, { removeComments: true, collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, {}, input);
+  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     ignoreCustomFragments: reFragments
-  }), output);
+  }, output);
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle. {{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n{{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true,
     ignoreCustomFragments: reFragments
-  }), output);
+  }, output);
 
   input = '{{ if foo? }}\r\n  <div class="bar">\r\n    ...\r\n  </div>\r\n{{ end \n}}';
   output = '{{ if foo? }}<div class="bar">...</div>{{ end }}';
-  assert.equal(minify(input, {}), input);
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, { collapseWhitespace: true, ignoreCustomFragments: [] }), output);
+  test_minify(assert, input, {}, input);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, { collapseWhitespace: true, ignoreCustomFragments: [] }, output);
 
   output = '{{ if foo? }} <div class="bar">...</div> {{ end \n}}';
-  assert.equal(minify(input, { collapseWhitespace: true, ignoreCustomFragments: reFragments }), output);
+  test_minify(assert, input, { collapseWhitespace: true, ignoreCustomFragments: reFragments }, output);
 
   output = '{{ if foo? }}\n<div class="bar">\n...\n</div>\n{{ end \n}}';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true,
     ignoreCustomFragments: reFragments
-  }), output);
+  }, output);
 
   input = '<a class="<% if foo? %>bar<% end %> {{ ... }}"></a>';
-  assert.equal(minify(input, {}), input);
-  assert.equal(minify(input, { ignoreCustomFragments: reFragments }), input);
+  test_minify(assert, input, {}, input);
+  test_minify(assert, input, { ignoreCustomFragments: reFragments }, input);
 
   input = '<img src="{% static "images/logo.png" %}">';
   output = '<img src="{% static "images/logo.png" %}">';
-  assert.equal(minify(input, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] }), output);
+  test_minify(assert, input, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] }, output);
 
   input = '<p{% if form.name.errors %}class=\'error\'{% endif %}>' +
             '{{ form.name.label_tag }}' +
@@ -1787,13 +1839,13 @@ QUnit.test('Ignore custom fragments', function(assert) {
             '{% endfor %}' +
             '{% endif %}' +
           '</p>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
     ],
     quoteCharacter: '\''
-  }), input);
+  }, input);
   output = '<p {% if form.name.errors %} class=\'error\' {% endif %}>' +
              '{{ form.name.label_tag }}' +
              '{{ form.name }}' +
@@ -1804,151 +1856,151 @@ QUnit.test('Ignore custom fragments', function(assert) {
              '{% endfor %}' +
              '{% endif %}' +
            '</p>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
     ],
     quoteCharacter: '\'',
     collapseWhitespace: true
-  }), output);
+  }, output);
 
   input = '<a href="/legal.htm"<?php echo e(Request::path() == \'/\' ? \' rel="nofollow"\':\'\'); ?>>Legal Notices</a>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /<\?php[\s\S]*?\?>/g
     ]
-  }), input);
+  }, input);
 
   input = '<input type="checkbox"<%= (model.isChecked ? \'checked="checked"\' : \'\') %>>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /<%=[\s\S]*?%>/g
     ]
-  }), input);
+  }, input);
 
   input = '<div' +
             '{{IF text}}' +
             'data-yashareDescription="{{shorted(text, 300)}}"' +
             '{{END IF}}></div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{\{[\s\S]*?\}\}/g
     ],
     caseSensitive: true
-  }), input);
+  }, input);
 
   input = '<img class="{% foo %} {% bar %}">';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ]
-  }), input);
+  }, input);
   // trimCustomFragments withOUT collapseWhitespace, does
   // not break the "{% foo %} {% bar %}" test
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
     trimCustomFragments: true
-  }), input);
+  }, input);
   // trimCustomFragments WITH collapseWhitespace, changes output
   output = '<img class="{% foo %}{% bar %}">';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
     collapseWhitespace: true,
     trimCustomFragments: true
-  }), output);
+  }, output);
 
   input = '<img class="titi.<%=tsItem_[0]%>">';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
 
   input = '<table id="<?php echo $this->escapeHtmlAttr($this->table_id); ?>"></table>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
 
   input = '<!--{{comment}}-->{{if a}}<div>b</div>{{/if}}';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '{{if a}}<div>b</div>{{/if}}';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     ignoreCustomFragments: [
       /\{\{.*?\}\}/g
     ]
-  }), output);
+  }, output);
 
   // https://github.com/kangax/html-minifier/issues/722
   input = '<? echo "foo"; ?> <span>bar</span>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
   output = '<? echo "foo"; ?><span>bar</span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }), output);
+  }, output);
 
   input = ' <? echo "foo"; ?> bar';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<? echo "foo"; ?> bar';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), output);
+  }, output);
   output = '<? echo "foo"; ?>bar';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }), output);
+  }, output);
 
   input = '<span>foo</span> <? echo "bar"; ?> baz';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
   output = '<span>foo</span><? echo "bar"; ?>baz';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }), output);
+  }, output);
 
   input = '<span>foo</span> <? echo "bar"; ?> <? echo "baz"; ?> <span>foo</span>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
   output = '<span>foo</span><? echo "bar"; ?><? echo "baz"; ?><span>foo</span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }), output);
+  }, output);
 
   input = 'foo <WC@bar> baz moo </WC@bar> loo';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [
       /<(WC@[\s\S]*?)>(.*?)<\/\1>/
     ]
-  }), input);
+  }, input);
   output = 'foo<wc @bar>baz moo</wc>loo';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), output);
+  }, output);
 
   input = '<link href="<?php echo \'http://foo/\' ?>">';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { removeAttributeQuotes: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { removeAttributeQuotes: true }, input);
 
   input = '<pre>\nfoo\n<? bar ?>\nbaz\n</pre>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { collapseWhitespace: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { collapseWhitespace: true }, input);
 });
 
 QUnit.test('bootstrap\'s span > button > span', function(assert) {
@@ -1958,15 +2010,15 @@ QUnit.test('bootstrap\'s span > button > span', function(assert) {
                 '\n  </button>' +
               '</span>';
   var output = '<span class=input-group-btn><button class="btn btn-default" type=button><span class="glyphicon glyphicon-search"></span></button></span>';
-  assert.equal(minify(input, { collapseWhitespace: true, removeAttributeQuotes: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, removeAttributeQuotes: true }, output);
 });
 
 QUnit.test('caseSensitive', function(assert) {
   var input = '<div mixedCaseAttribute="value"></div>';
   var caseSensitiveOutput = '<div mixedCaseAttribute="value"></div>';
   var caseInSensitiveOutput = '<div mixedcaseattribute="value"></div>';
-  assert.equal(minify(input), caseInSensitiveOutput);
-  assert.equal(minify(input, { caseSensitive: true }), caseSensitiveOutput);
+  test_minify(assert, input, caseInSensitiveOutput);
+  test_minify(assert, input, { caseSensitive: true }, caseSensitiveOutput);
 });
 
 QUnit.test('source & track', function(assert) {
@@ -1976,8 +2028,8 @@ QUnit.test('source & track', function(assert) {
                 '<source src="foobar.wav">' +
                 '<track kind="captions" src="sampleCaptions.vtt" srclang="en">' +
               '</audio>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { removeOptionalTags: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { removeOptionalTags: true }, input);
 });
 
 QUnit.test('mixed html and svg', function(assert) {
@@ -2002,18 +2054,18 @@ QUnit.test('mixed html and svg', function(assert) {
     '</svg>' +
     '</body></html>';
   // Should preserve case-sensitivity and closing slashes within svg tags
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('nested quotes', function(assert) {
   var input, output;
 
   input = '<div data=\'{"test":"\\"test\\""}\'></div>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { quoteCharacter: '\'' }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { quoteCharacter: '\'' }, input);
 
   output = '<div data="{&#34;test&#34;:&#34;\\&#34;test\\&#34;&#34;}"></div>';
-  assert.equal(minify(input, { quoteCharacter: '"' }), output);
+  test_minify(assert, input, { quoteCharacter: '"' }, output);
 });
 
 QUnit.test('script minification', function(assert) {
@@ -2021,32 +2073,32 @@ QUnit.test('script minification', function(assert) {
 
   input = '<script></script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()';
 
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script>alert("1 2")</script>';
 
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/JavaScript">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="text/JavaScript">alert("1 2")</script>';
 
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="application/javascript;version=1.8">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;version=1.8">alert("1 2")</script>';
 
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type=" application/javascript  ; charset=utf-8 ">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;charset=utf-8">alert("1 2")</script>';
 
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
-  input = '<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({\'gtm.start\':new Date().getTime(),event:\'gtm.js\'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!=\'dataLayer\'?\'&l=\'+l:\'\';j.async=true;j.src=\'//www.googletagmanager.com/gtm.js?id=\'+i+dl;f.parentNode.insertBefore(j,f);})(window,document,\'script\',\'dataLayer\',\'GTM-67NT\');</script>';
-  output = '<script>!function(w,d,s,l,i){w[l]=w[l]||[],w[l].push({"gtm.start":(new Date).getTime(),event:"gtm.js"});var f=d.getElementsByTagName(s)[0],j=d.createElement(s);j.async=!0,j.src="//www.googletagmanager.com/gtm.js?id=GTM-67NT",f.parentNode.insertBefore(j,f)}(window,document,"script","dataLayer")</script>';
+  input = '<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({\'gtm.start\':new Date().getTime(,event:\'gtm.js\'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s,dl=l!=\'dataLayer\'?\'&l=\'+l:\'\';j.async=true;j.src=\'//www.googletagmanager.com/gtm.js?id=\'+i+dl;f.parentNode.insertBefore(j,f);})(window,document,\'script\',\'dataLayer\',\'GTM-67NT\');</script>';
+  output = '<script>!function(w,d,s,l,i){w[l]=w[l]||[],w[l].push({"gtm.start":(new Date).getTime(,event:"gtm.js"});var f=d.getElementsByTagName(s)[0],j=d.createElement(s);j.async=!0,j.src="//www.googletagmanager.com/gtm.js?id=GTM-67NT",f.parentNode.insertBefore(j,f)}(window,document,"script","dataLayer")</script>';
 
-  assert.equal(minify(input, { minifyJS: { mangle: false } }), output);
+  test_minify(assert, input, { minifyJS: { mangle: false } }, output);
 
   input = '<script>\n' +
           '  <!--\n' +
@@ -2059,7 +2111,7 @@ QUnit.test('script minification', function(assert) {
           '</script>';
   output = '<script>Platform.Mobile.Bootstrap.init(function(){Platform.Mobile.Core.Navigation.go("Login",{error:""})})</script>';
 
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('minification of scripts with different mimetypes', function(assert) {
@@ -2067,268 +2119,268 @@ QUnit.test('minification of scripts with different mimetypes', function(assert)
 
   input = '<script type="">function f(){  return 1  }</script>';
   output = '<script type="">function f(){return 1}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript">function f(){  return 1  }</script>';
   output = '<script type="text/javascript">function f(){return 1}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script foo="bar">function f(){  return 1  }</script>';
   output = '<script foo="bar">function f(){return 1}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/ecmascript">function f(){  return 1  }</script>';
   output = '<script type="text/ecmascript">function f(){return 1}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="application/javascript">function f(){  return 1  }</script>';
   output = '<script type="application/javascript">function f(){return 1}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<script type="boo">function f(){  return 1  }</script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<script type="text/html"><!-- ko if: true -->\n\n\n<div></div>\n\n\n<!-- /ko --></script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
 });
 
 QUnit.test('minification of scripts with custom fragments', function(assert) {
   var input, output;
 
   input = '<script><?php ?></script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, input);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), input);
+  }, input);
 
   input = '<script>\n<?php ?></script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
   output = '<script> <?php ?></script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), input);
+  }, input);
 
   input = '<script><?php ?>\n</script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
   output = '<script><?php ?> </script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), input);
+  }, input);
 
   input = '<script>\n<?php ?>\n</script>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
   output = '<script> <?php ?> </script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), input);
+  }, input);
 
   input = '<script>// <% ... %></script>';
   output = '<script></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<script>// \n<% ... %></script>';
   output = '<script> \n<% ... %></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
   output = '<script> <% ... %></script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
   output = '<script>\n<% ... %></script>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<script>// <% ... %>\n</script>';
   output = '<script></script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<script>// \n<% ... %>\n</script>';
   output = '<script> \n<% ... %>\n</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
   output = '<script> <% ... %> </script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
   output = '<script>\n<% ... %>\n</script>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<script>function f(){  return <?php ?>  }</script>';
   output = '<script>function f(){return <?php ?>  }</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
   output = '<script>function f(){return <?php ?> }</script>';
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
 
   input = '<script>function f(){  return "<?php ?>"  }</script>';
   output = '<script>function f(){return"<?php ?>"}</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
-  assert.equal(minify(input, { collapseWhitespace: true, minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
 });
 
 QUnit.test('event minification', function(assert) {
   var input, output;
 
   input = '<div only="alert(a + b)" one=";return false;"></div>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<div onclick="alert(a + b)"></div>';
   output = '<div onclick="alert(a+b)"></div>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<a href="/" onclick="this.href = getUpdatedURL (this.href);return true;">test</a>';
-  output = '<a href="/" onclick="return this.href=getUpdatedURL(this.href),!0">test</a>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  output = '<a href="/" onclick="return this.href=getUpdatedURL(this.href,!0">test</a>';
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick=\'try{dcsMultiTrack("DCS.dcsuri","USPS","WT.ti")}catch(e){}\'> foobar</a>';
-  assert.equal(minify(input, { minifyJS: { mangle: false } }), output);
-  assert.equal(minify(input, { minifyJS: { mangle: false }, quoteCharacter: '\'' }), output);
+  test_minify(assert, input, { minifyJS: { mangle: false } }, output);
+  test_minify(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '\'' }, output);
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick="try{dcsMultiTrack(&#34;DCS.dcsuri&#34;,&#34;USPS&#34;,&#34;WT.ti&#34;)}catch(e){}"> foobar</a>';
-  assert.equal(minify(input, { minifyJS: { mangle: false }, quoteCharacter: '"' }), output);
+  test_minify(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '"' }, output);
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick=\'_gaq.push(["_trackEvent","FGF","banner_click"])\'></a>';
-  assert.equal(minify(input, { minifyJS: true }), output);
-  assert.equal(minify(input, { minifyJS: true, quoteCharacter: '\'' }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, { minifyJS: true, quoteCharacter: '\'' }, output);
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick="_gaq.push([&#34;_trackEvent&#34;,&#34;FGF&#34;,&#34;banner_click&#34;])"></a>';
-  assert.equal(minify(input, { minifyJS: true, quoteCharacter: '"' }), output);
+  test_minify(assert, input, { minifyJS: true, quoteCharacter: '"' }, output);
 
   input = '<button type="button" onclick=";return false;" id="appbar-guide-button"></button>';
   output = '<button type="button" onclick="return!1" id="appbar-guide-button"></button>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<button type="button" onclick=";return false;" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
   output = '<button type="button" onclick="return!1" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
-  assert.equal(minify(input, { minifyJS: true }), output);
-  assert.equal(minify(input, { minifyJS: true, customEventAttributes: [] }), input);
+  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, { minifyJS: true, customEventAttributes: [] }, input);
   output = '<button type="button" onclick=";return false;" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  assert.equal(minify(input, { minifyJS: true, customEventAttributes: [/^ng-/] }), output);
+  test_minify(assert, input, { minifyJS: true, customEventAttributes: [/^ng-/] }, output);
   output = '<button type="button" onclick="return!1" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  assert.equal(minify(input, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] }), output);
+  test_minify(assert, input, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] }, output);
 
   input = '<div onclick="<?= b ?>"></div>';
-  assert.equal(minify(input, { minifyJS: true }), input);
+  test_minify(assert, input, { minifyJS: true }, input);
 
   input = '<div onclick="alert(a + <?= b ?>)"></div>';
   output = '<div onclick="alert(a+ <?= b ?>)"></div>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 
   input = '<div onclick="alert(a + \'<?= b ?>\')"></div>';
   output = '<div onclick=\'alert(a+"<?= b ?>")\'></div>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('escaping closing script tag', function(assert) {
   var input = '<script>window.jQuery || document.write(\'<script src="jquery.js"><\\/script>\')</script>';
   var output = '<script>window.jQuery||document.write(\'<script src="jquery.js"><\\/script>\')</script>';
-  assert.equal(minify(input, { minifyJS: true }), output);
+  test_minify(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('style minification', function(assert) {
   var input, output;
 
   input = '<style></style>div#foo { background-color: red; color: white }';
-  assert.equal(minify(input, { minifyCSS: true }), input);
+  test_minify(assert, input, { minifyCSS: true }, input);
 
   input = '<style>div#foo { background-color: red; color: white }</style>';
   output = '<style>div#foo{background-color:red;color:#fff}</style>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<style>div > p.foo + span { border: 10px solid black }</style>';
   output = '<style>div>p.foo+span{border:10px solid #000}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 
   input = '<div style="background: url(images/<% image %>);"></div>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
-  }), output);
+  }, output);
 
   input = '<div style="background: url(\'images/<% image %>\')"></div>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
-  }), output);
+  }, output);
 
   input = '<style>\np {\n  background: url(images/<% image %>);\n}\n</style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
-  }), output);
+  }, output);
 
   input = '<style>p { background: url("images/<% image %>") }</style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
-  }), output);
+  }, output);
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width:737px)">';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
   output = '<link rel=stylesheet href=css/style-mobile.css media=(max-width:737px)>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     removeAttributeQuotes: true
-  }), output);
+  }, output);
 
   input = '<style media="(max-width: 737px)"></style>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
   output = '<style media="(max-width:737px)"></style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
   output = '<style media=(max-width:737px)></style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     removeAttributeQuotes: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('style attribute minification', function(assert) {
   var input = '<div style="color: red; background-color: yellow; font-family: Verdana, Arial, sans-serif;"></div>';
   var output = '<div style="color:red;background-color:#ff0;font-family:Verdana,Arial,sans-serif"></div>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
 });
 
 QUnit.test('url attribute minification', function(assert) {
@@ -2336,61 +2388,61 @@ QUnit.test('url attribute minification', function(assert) {
 
   input = '<link rel="stylesheet" href="http://website.com/style.css"><form action="http://website.com/folder/folder2/index.html"><a href="http://website.com/folder/file.html">link</a></form>';
   output = '<link rel="stylesheet" href="/style.css"><form action="folder2/"><a href="file.html">link</a></form>';
-  assert.equal(minify(input, { minifyURLs: 'http://website.com/folder/' }), output);
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/folder/' } }), output);
+  test_minify(assert, input, { minifyURLs: 'http://website.com/folder/' }, output);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/folder/' } }, output);
 
   input = '<link rel="canonical" href="http://website.com/">';
-  assert.equal(minify(input, { minifyURLs: 'http://website.com/' }), input);
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/' } }), input);
+  test_minify(assert, input, { minifyURLs: 'http://website.com/' }, input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
 
   input = '<style>body { background: url(\'http://website.com/bg.png\') }</style>';
-  assert.equal(minify(input, { minifyURLs: 'http://website.com/' }), input);
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/' } }), input);
+  test_minify(assert, input, { minifyURLs: 'http://website.com/' }, input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
   output = '<style>body{background:url(http://website.com/bg.png)}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: 'http://website.com/'
-  }), output);
-  assert.equal(minify(input, {
+  }, output);
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
-  }), output);
+  }, output);
 
   input = '<style>body { background: url("http://website.com/foo bar/bg.png") }</style>';
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/foo bar/' } }), input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo bar/' } }, input);
   output = '<style>body{background:url("http://website.com/foo bar/bg.png")}</style>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo bar/' }
-  }), output);
+  }, output);
 
   input = '<style>body { background: url("http://website.com/foo bar/(baz)/bg.png") }</style>';
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/' } }), input);
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } }), input);
-  assert.equal(minify(input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } }), input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } }, input);
+  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } }, input);
   output = '<style>body{background:url("foo%20bar/(baz)/bg.png")}</style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
-  }), output);
+  }, output);
   output = '<style>body{background:url("(baz)/bg.png")}</style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/' }
-  }), output);
+  }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' }
-  }), output);
+  }, output);
 
   input = '<img src="http://cdn.site.com/foo.png">';
   output = '<img src="//cdn.site.com/foo.png">';
-  assert.equal(minify(input, { minifyURLs: { site: 'http://site.com/' } }), output);
+  test_minify(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
 });
 
 QUnit.test('srcset attribute minification', function(assert) {
@@ -2398,20 +2450,20 @@ QUnit.test('srcset attribute minification', function(assert) {
   input = '<source srcset="http://site.com/foo.gif ,http://site.com/bar.jpg 1x, baz moo 42w,' +
           '\n\n\n\n\n\t    http://site.com/zo om.png 1.00x">';
   output = '<source srcset="http://site.com/foo.gif, http://site.com/bar.jpg, baz moo 42w, http://site.com/zo om.png">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
   output = '<source srcset="foo.gif, bar.jpg, baz%20moo 42w, zo%20om.png">';
-  assert.equal(minify(input, { minifyURLs: { site: 'http://site.com/' } }), output);
+  test_minify(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
 });
 
 QUnit.test('valueless attributes', function(assert) {
   var input = '<br foo>';
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('newlines becoming whitespaces', function(assert) {
   var input = 'test\n\n<input>\n\ntest';
   var output = 'test <input> test';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('conservative collapse', function(assert) {
@@ -2419,115 +2471,115 @@ QUnit.test('conservative collapse', function(assert) {
 
   input = '<b>   foo \n\n</b>';
   output = '<b> foo </b>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<html>\n\n<!--test-->\n\n</html>';
   output = '<html> </html>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, input);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), input);
+  }, input);
 
   input = '<p> \u00A0</p>';
   output = '<p>\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>\u00A0 </p>';
   output = '<p>\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p> \u00A0 </p>';
   output = '<p>\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>\u00A0\u00A0 \u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>foo \u00A0\u00A0 \u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>\u00A0\u00A0 \u00A0 bar</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>foo \u00A0\u00A0 \u00A0 bar</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p> \u00A0foo\u00A0\t</p>';
   output = '<p>\u00A0foo\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
 
   input = '<p> \u00A0\nfoo\u00A0\t</p>';
   output = '<p>\u00A0 foo\u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
 
   input = '<p> \u00A0foo \u00A0\t</p>';
   output = '<p>\u00A0foo \u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 
   input = '<p> \u00A0\nfoo \u00A0\t</p>';
   output = '<p>\u00A0 foo \u00A0</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('collapse preseving a line break', function(assert) {
@@ -2557,15 +2609,15 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
-  assert.equal(minify(input, {
+  }, output);
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
   output = '\n<!DOCTYPE html>\n<html lang="en" class="no-js">\n' +
            '<head>\n<meta charset="utf-8">\n<meta http-equiv="X-UA-Compatible" content="IE=edge">\n' +
            '<title>Carbon</title>\n<meta name="title" content="Carbon">\n' +
@@ -2577,140 +2629,140 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true,
     removeComments: true
-  }), output);
+  }, output);
 
   input = '<div> text <span>\n text</span> \n</div>';
   output = '<div>text <span>\ntext</span>\n</div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<div>  text \n </div>';
   output = '<div>text\n</div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
   output = '<div> text\n</div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = '<div>\ntext  </div>';
   output = '<div>\ntext</div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
   output = '<div>\ntext </div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n<?= ... ?>\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n<?= ... ?>\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('collapse inline tag whitespace', function(assert) {
   var input, output;
 
   input = '<button>a</button> <button>b</button>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), input);
+  }, input);
 
   output = '<button>a</button><button>b</button>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
-  }), output);
+  }, output);
 
   input = '<p>where <math> <mi>R</mi> </math> is the Rici tensor.</p>';
   output = '<p>where <math><mi>R</mi></math> is the Rici tensor.</p>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true
-  }), output);
+  }, output);
 
   output = '<p>where<math><mi>R</mi></math>is the Rici tensor.</p>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('ignore custom comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { removeComments: true }), input);
-  assert.equal(minify(input, { ignoreCustomComments: false }), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, { ignoreCustomComments: false }, input);
+  test_minify(assert, input, {
     removeComments: true,
     ignoreCustomComments: []
-  }), '');
-  assert.equal(minify(input, {
+  }, '');
+  test_minify(assert, input, {
     removeComments: true,
     ignoreCustomComments: false
-  }), '');
+  }, '');
 
   input = '<!-- htmlmin:ignore -->test<!-- htmlmin:ignore -->';
   output = 'test';
-  assert.equal(minify(input), output);
-  assert.equal(minify(input, { removeComments: true }), output);
-  assert.equal(minify(input, { ignoreCustomComments: false }), output);
-  assert.equal(minify(input, {
+  test_minify(assert, input, output);
+  test_minify(assert, input, { removeComments: true }, output);
+  test_minify(assert, input, { ignoreCustomComments: false }, output);
+  test_minify(assert, input, {
     removeComments: true,
     ignoreCustomComments: []
-  }), output);
-  assert.equal(minify(input, {
+  }, output);
+  test_minify(assert, input, {
     removeComments: true,
     ignoreCustomComments: false
-  }), output);
+  }, output);
 
   input = '<!-- ko if: someExpressionGoesHere --><li>test</li><!-- /ko -->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     // ignore knockout comments
     ignoreCustomComments: [
       /^\s+ko/,
       /\/ko\s+$/
     ]
-  }), input);
+  }, input);
 
   input = '<!--#include virtual="/cgi-bin/counter.pl" -->';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeComments: true,
     // ignore Apache SSI includes
     ignoreCustomComments: [
       /^\s*#/
     ]
-  }), input);
+  }, input);
 });
 
 QUnit.test('processScripts', function(assert) {
   var input = '<script type="text/ng-template"><!--test--><div>   <span> foobar </span> \n\n</div></script>';
   var output = '<script type="text/ng-template"><div><span>foobar</span></div></script>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     removeComments: true,
     processScripts: ['text/ng-template']
-  }), output);
+  }, output);
 });
 
 QUnit.test('ignore', function(assert) {
@@ -2720,10 +2772,10 @@ QUnit.test('ignore', function(assert) {
           '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>';
   output = '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>' +
            '<div class="blah" style="color: red">test <span><input disabled="disabled"> foo</span></div>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<!-- htmlmin:ignore --><!-- htmlmin:ignore -->';
-  assert.equal(minify(input), '');
+  test_minify(assert, input, '');
 
   input = '<p>.....</p><!-- htmlmin:ignore -->' +
           '@for( $i = 0 ; $i < $criterions->count() ; $i++ )' +
@@ -2735,23 +2787,23 @@ QUnit.test('ignore', function(assert) {
                '<h1>{{ $criterions[$i]->value }}</h1>' +
            '@endfor' +
            '<p>....</p>';
-  assert.equal(minify(input, { removeComments: true }), output);
+  test_minify(assert, input, { removeComments: true }, output);
 
   input = '<!-- htmlmin:ignore --> <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> <!-- htmlmin:ignore -->';
   output = ' <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> ';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<!-- htmlmin:ignore --><body <?php body_class(); ?>><!-- htmlmin:ignore -->';
   output = '<body <?php body_class(); ?>>';
-  assert.equal(minify(input, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] }), output);
+  test_minify(assert, input, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] }, output);
 
   input = 'a\n<!-- htmlmin:ignore -->b<!-- htmlmin:ignore -->';
   output = 'a b';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo <!-- htmlmin:ignore --><span>\n\tbar\n</span><!-- htmlmin:ignore -->.</p>';
   output = '<p>foo <span>\n\tbar\n</span>.</p>';
-  assert.equal(minify(input, { collapseWhitespace: true }), output);
+  test_minify(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('meta viewport', function(assert) {
@@ -2759,36 +2811,36 @@ QUnit.test('meta viewport', function(assert) {
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="initial-scale=1, maximum-scale=1.0">';
   output = '<meta name="viewport" content="initial-scale=1,maximum-scale=1">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="width= 500 ,  initial-scale=1">';
   output = '<meta name="viewport" content="width=500,initial-scale=1">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0001, maximum-scale=3.140000">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1.0001,maximum-scale=3.14">';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('downlevel-revealed conditional comments', function(assert) {
   var input = '<![if !IE]><link href="non-ie.css" rel="stylesheet"><![endif]>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { removeComments: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { removeComments: true }, input);
 });
 
 QUnit.test('noscript', function(assert) {
   var input;
 
   input = '<SCRIPT SRC="x"></SCRIPT><NOSCRIPT>x</NOSCRIPT>';
-  assert.equal(minify(input), '<script src="x"></script><noscript>x</noscript>');
+  test_minify(assert, input, '<script src="x"></script><noscript>x</noscript>');
 
   input = '<noscript>\n<!-- anchor linking to external file -->\n' +
           '<a href="#" onclick="javascript:">External Link</a>\n</noscript>';
-  assert.equal(minify(input, { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true }),
+  test_minify(assert, input, { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true },
     '<noscript><a href="#">External Link</a></noscript>');
 });
 
@@ -2797,49 +2849,49 @@ QUnit.test('max line length', function(assert) {
   var options = { maxLineLength: 25 };
 
   input = '<div data-attr="foo"></div>';
-  assert.equal(minify(input, options), '<div data-attr="foo">\n</div>');
+  test_minify(assert, input, options, '<div data-attr="foo">\n</div>');
 
   input = '<code>    hello   world  \n    world   hello  </code>';
-  assert.equal(minify(input, options), '<code>\n    hello   world  \n    world   hello  \n</code>');
+  test_minify(assert, input, options, '<code>\n    hello   world  \n    world   hello  \n</code>');
 
-  assert.equal(minify('<p title="</p>">x</p>'), '<p title="</p>">x</p>');
-  assert.equal(minify('<p title=" <!-- hello world --> ">x</p>'), '<p title=" <!-- hello world --> ">x</p>');
-  assert.equal(minify('<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>'), '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  assert.equal(minify('<p foo-bar=baz>xxx</p>'), '<p foo-bar="baz">xxx</p>');
-  assert.equal(minify('<p foo:bar=baz>xxx</p>'), '<p foo:bar="baz">xxx</p>');
+  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
 
-  assert.equal(minify(input), input);
+  test_minify(assert, input, input);
 
-  assert.equal(minify('<script>alert(\'<!--\')</script>', options), '<script>alert(\'<!--\')\n</script>');
-  assert.equal(minify('<script>alert(\'<!-- foo -->\')</script>', options), '<script>\nalert(\'<!-- foo -->\')\n</script>');
-  assert.equal(minify('<script>alert(\'-->\')</script>', options), '<script>alert(\'-->\')\n</script>');
+  test_minify(assert, '<script>alert(\'<!--\')</script>', options, '<script>alert(\'<!--\')\n</script>');
+  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', options, '<script>\nalert(\'<!-- foo -->\')\n</script>');
+  test_minify(assert, '<script>alert(\'-->\')</script>', options, '<script>alert(\'-->\')\n</script>');
 
-  assert.equal(minify('<a title="x"href=" ">foo</a>', options), '<a title="x" href="">foo\n</a>');
-  assert.equal(minify('<p id=""class=""title="">x', options), '<p id="" class="" \ntitle="">x</p>');
-  assert.equal(minify('<p x="x\'"">x</p>', options), '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  assert.equal(minify('<a href="#"><p>Click me</p></a>', options), '<a href="#"><p>Click me\n</p></a>');
-  assert.equal(minify('<span><button>Hit me</button></span>', options), '<span><button>Hit me\n</button></span>');
-  assert.equal(minify('<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', options),
+  test_minify(assert, '<a title="x"href=" ">foo</a>', options, '<a title="x" href="">foo\n</a>');
+  test_minify(assert, '<p id=""class=""title="">x', options, '<p id="" class="" \ntitle="">x</p>');
+  test_minify(assert, '<p x="x\'"">x</p>', options, '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify(assert, '<a href="#"><p>Click me</p></a>', options, '<a href="#"><p>Click me\n</p></a>');
+  test_minify(assert, '<span><button>Hit me</button></span>', options, '<span><button>Hit me\n</button></span>');
+  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', options,
     '<object \ntype="image/svg+xml" \ndata="image.svg"><div>\n[fallback image]</div>\n</object>'
   );
 
-  assert.equal(minify('<ng-include src="x"></ng-include>', options), '<ng-include src="x">\n</ng-include>');
-  assert.equal(minify('<ng:include src="x"></ng:include>', options), '<ng:include src="x">\n</ng:include>');
-  assert.equal(minify('<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', options),
+  test_minify(assert, '<ng-include src="x"></ng-include>', options, '<ng-include src="x">\n</ng-include>');
+  test_minify(assert, '<ng:include src="x"></ng:include>', options, '<ng:include src="x">\n</ng:include>');
+  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', options,
     '<ng-include \nsrc="\'views/partial-notification.html\'">\n</ng-include><div \nng-view=""></div>'
   );
-  assert.equal(minify('<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', options),
+  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', options,
     '<some-tag-1>\n</some-tag-1>\n<some-tag-2>\n</some-tag-2>'
   );
-  assert.equal(minify('[\']["]', options), '[\']["]');
-  assert.equal(minify('<a href="test.html"><div>hey</div></a>', options), '<a href="test.html">\n<div>hey</div></a>');
-  assert.equal(minify(':) <a href="http://example.com">link</a>', options), ':) <a \nhref="http://example.com">\nlink</a>');
+  test_minify(assert, '[\']["]', options, '[\']["]');
+  test_minify(assert, '<a href="test.html"><div>hey</div></a>', options, '<a href="test.html">\n<div>hey</div></a>');
+  test_minify(assert, ':) <a href="http://example.com">link</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
 
-  assert.equal(minify('<a href>ok</a>', options), '<a href>ok</a>');
+  test_minify(assert, '<a href>ok</a>', options, '<a href>ok</a>');
 });
 
 QUnit.test('custom attribute collapse', function(assert) {
@@ -2847,24 +2899,24 @@ QUnit.test('custom attribute collapse', function(assert) {
 
   input = '<div data-bind="\n' +
             'css: {\n' +
-              'fadeIn: selected(),\n' +
+              'fadeIn: selected(,\n' +
               'fadeOut: !selected()\n' +
             '},\n' +
             'visible: function () {\n' +
               'return pageWeAreOn() == \'home\';\n' +
             '}\n' +
           '">foo</div>';
-  output = '<div data-bind="css: {fadeIn: selected(),fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
+  output = '<div data-bind="css: {fadeIn: selected(,fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
 
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { customAttrCollapse: /data-bind/ }), output);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { customAttrCollapse: /data-bind/ }, output);
 
   input = '<div style="' +
             'color: red;' +
             'font-size: 100em;' +
           '">bar</div>';
   output = '<div style="color: red;font-size: 100em;">bar</div>';
-  assert.equal(minify(input, { customAttrCollapse: /style/ }), output);
+  test_minify(assert, input, { customAttrCollapse: /style/ }, output);
 
   input = '<div ' +
     'class="fragment square" ' +
@@ -2876,13 +2928,13 @@ QUnit.test('custom attribute collapse', function(assert) {
   '> ' +
   '</div>';
   output = '<div class="fragment square" ng-hide="square1.hide" ng-class="{\'bounceInDown\': !square1.hide, \'bounceOutDown\': square1.hide }"> </div>';
-  assert.equal(minify(input, { customAttrCollapse: /ng-class/ }), output);
+  test_minify(assert, input, { customAttrCollapse: /ng-class/ }, output);
 });
 
 QUnit.test('custom attribute collapse with empty attribute value', function(assert) {
   var input = '<div ng-some\n\n></div>';
   var output = '<div ng-some></div>';
-  assert.equal(minify(input, { customAttrCollapse: /.+/ }), output);
+  test_minify(assert, input, { customAttrCollapse: /.+/ }, output);
 });
 
 QUnit.test('custom attribute collapse with newlines, whitespace, and carriage returns', function(assert) {
@@ -2891,7 +2943,7 @@ QUnit.test('custom attribute collapse with newlines, whitespace, and carriage re
           '               value2:false \n\r' +
           '               }"></div>';
   var output = '<div ng-class="{value:true,value2:false}"></div>';
-  assert.equal(minify(input, { customAttrCollapse: /ng-class/ }), output);
+  test_minify(assert, input, { customAttrCollapse: /ng-class/ }, output);
 });
 
 QUnit.test('do not escape attribute value', function(assert) {
@@ -2900,23 +2952,23 @@ QUnit.test('do not escape attribute value', function(assert) {
   input = '<div data=\'{\n' +
           '\t"element": "<div class=\\"test\\"></div>\n"' +
           '}\'></div>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { preventAttributesEscaping: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { preventAttributesEscaping: true }, input);
 
   input = '<div foo bar=\'\' baz="" moo=1 loo=\'2\' haa="3"></div>';
-  assert.equal(minify(input, { preventAttributesEscaping: true }), input);
+  test_minify(assert, input, { preventAttributesEscaping: true }, input);
   output = '<div foo bar="" baz="" moo="1" loo="2" haa="3"></div>';
-  assert.equal(minify(input), output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('quoteCharacter is single quote', function(assert) {
-  assert.equal(minify('<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' }), '<div class=\'bar\'>foo</div>');
-  assert.equal(minify('<div class="bar">foo</div>', { quoteCharacter: '\'' }), '<div class=\'bar\'>foo</div>');
+  test_minify(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
+  test_minify(assert, '<div class="bar">foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
 });
 
 QUnit.test('quoteCharacter is not single quote or double quote', function(assert) {
-  assert.equal(minify('<div class=\'bar\'>foo</div>', { quoteCharacter: 'm' }), '<div class="bar">foo</div>');
-  assert.equal(minify('<div class="bar">foo</div>', { quoteCharacter: 'm' }), '<div class="bar">foo</div>');
+  test_minify(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
+  test_minify(assert, '<div class="bar">foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
 });
 
 QUnit.test('remove space between attributes', function(assert) {
@@ -2930,27 +2982,27 @@ QUnit.test('remove space between attributes', function(assert) {
 
   input = '<input data-attr="example" value="hello world!" checked="checked">';
   output = '<input data-attr=example value="hello world!"checked>';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 
   input = '<input checked="checked" value="hello world!" data-attr="example">';
   output = '<input checked value="hello world!"data-attr=example>';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 
   input = '<input checked="checked" data-attr="example" value="hello world!">';
   output = '<input checked data-attr=example value="hello world!">';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 
   input = '<input data-attr="example" value="hello world!" checked="checked"/>';
   output = '<input data-attr=example value="hello world!"checked/>';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 
   input = '<input checked="checked" value="hello world!" data-attr="example"/>';
   output = '<input checked value="hello world!"data-attr=example />';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 
   input = '<input checked="checked" data-attr="example" value="hello world!"/>';
   output = '<input checked data-attr=example value="hello world!"/>';
-  assert.equal(minify(input, options), output);
+  test_minify(assert, input, options, output);
 });
 
 QUnit.test('markups from Angular 2', function(assert) {
@@ -2976,7 +3028,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '  </div>\n' +
            '  <button type="submit" [disabled]="!theForm.form.valid">Submit</button>\n' +
            '</form>';
-  assert.equal(minify(input, { caseSensitive: true }), output);
+  test_minify(assert, input, { caseSensitive: true }, output);
   output = '<template ngFor #hero [ngForOf]=heroes>' +
            '<hero-detail *ngIf=hero [hero]=hero></hero-detail>' +
            '</template>' +
@@ -2987,7 +3039,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '</div>' +
            '<button type=submit [disabled]=!theForm.form.valid>Submit</button>' +
            '</form>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseWhitespace: true,
@@ -3000,58 +3052,58 @@ QUnit.test('markups from Angular 2', function(assert) {
     removeStyleLinkTypeAttributes: true,
     removeTagWhitespace: true,
     useShortDoctype: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('auto-generated tags', function(assert) {
   var input, output;
 
   input = '</p>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), input);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
 
   input = '<p id=""class=""title="">x';
   output = '<p id="" class="" title="">x';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), output);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, output);
   output = '<p id="" class="" title="">x</p>';
-  assert.equal(minify(input), output);
-  assert.equal(minify(input, { includeAutoGeneratedTags: true }), output);
+  test_minify(assert, input, output);
+  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</body>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), output);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, output);
 
   input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   output = '<a href="#"><div>Well, look at me! I\'m a div!</div>';
-  assert.equal(minify(input, { html5: false, includeAutoGeneratedTags: false }), output);
-  assert.equal(minify('<p id=""class=""title="">x', {
+  test_minify(assert, input, { html5: false, includeAutoGeneratedTags: false }, output);
+  test_minify(assert, '<p id=""class=""title="">x', {
     maxLineLength: 25,
     includeAutoGeneratedTags: false
-  }), '<p id="" class="" \ntitle="">x');
+  }, '<p id="" class="" \ntitle="">x');
 
   input = '<p>foo';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), input);
-  assert.equal(minify(input, {
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify(assert, input, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
-  }), input);
+  }, input);
 
   input = '</p>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), input);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
-  }), output);
+  }, output);
 
   input = '<select><option>foo<option>bar</select>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), input);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '<select><option>foo</option><option>bar</option></select>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: true }), output);
+  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
 
   input = '<datalist><option label="A" value="1"><option label="B" value="2"></datalist>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: false }), input);
+  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '<datalist><option label="A" value="1"></option><option label="B" value="2"></option></datalist>';
-  assert.equal(minify(input, { includeAutoGeneratedTags: true }), output);
+  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
 });
 
 QUnit.test('sort attributes', function(assert) {
@@ -3060,31 +3112,31 @@ QUnit.test('sort attributes', function(assert) {
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<link type="text/css" href="app.css" rel="stylesheet" async>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { sortAttributes: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { sortAttributes: false }, input);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<link href="app.css" rel="stylesheet" async type="text/css">';
-  assert.equal(minify(input, { sortAttributes: true }), output);
+  test_minify(assert, input, { sortAttributes: true }, output);
 
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { sortAttributes: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { sortAttributes: false }, input);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  assert.equal(minify(input, { sortAttributes: true }), output);
+  test_minify(assert, input, { sortAttributes: true }, output);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link href="app.css" rel="stylesheet" async type="text/css"></script>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     processScripts: [
       'text/html'
     ],
     sortAttributes: true
-  }), output);
+  }, output);
 
   input = '<link type="text/css" href="foo.css">' +
           '<link rel="stylesheet" type="text/abc" href="bar.css">' +
@@ -3092,45 +3144,45 @@ QUnit.test('sort attributes', function(assert) {
   output = '<link href="foo.css" type="text/css">' +
            '<link href="bar.css" type="text/abc" rel="stylesheet">' +
            '<link href="baz.css">';
-  assert.equal(minify(input, { sortAttributes: true }), output);
+  test_minify(assert, input, { sortAttributes: true }, output);
   output = '<link href="foo.css">' +
            '<link href="bar.css" rel="stylesheet" type="text/abc">' +
            '<link href="baz.css">';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     removeStyleLinkTypeAttributes: true,
     sortAttributes: true
-  }), output);
+  }, output);
 
   input = '<a foo moo></a>' +
           '<a bar foo></a>' +
           '<a baz bar foo></a>' +
           '<a baz foo moo></a>' +
           '<a moo baz></a>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { sortAttributes: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { sortAttributes: false }, input);
   output = '<a foo moo></a>' +
            '<a foo bar></a>' +
            '<a foo bar baz></a>' +
            '<a foo baz moo></a>' +
            '<a baz moo></a>';
-  assert.equal(minify(input, { sortAttributes: true }), output);
+  test_minify(assert, input, { sortAttributes: true }, output);
 
   input = '<span nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
-  }), input);
-  assert.equal(minify(input, {
+  }, input);
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: false
-  }), input);
+  }, input);
   output = '<span foo_bar nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> ></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: true
-  }), output);
+  }, output);
 
   input = '<a 0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z></a>';
-  assert.equal(minify(input, { sortAttributes: true }), input);
+  test_minify(assert, input, { sortAttributes: true }, input);
 });
 
 QUnit.test('sort style classes', function(assert) {
@@ -3141,125 +3193,125 @@ QUnit.test('sort style classes', function(assert) {
           '<i class="baz bar foo"></i>' +
           '<s class="baz foo moo"></s>' +
           '<u class="moo baz"></u>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { sortClassName: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { sortClassName: false }, input);
   output = '<a class="foo moo"></a>' +
            '<b class="foo bar"></b>' +
            '<i class="foo bar baz"></i>' +
            '<s class="foo baz moo"></s>' +
            '<u class="baz moo"></u>';
-  assert.equal(minify(input, { sortClassName: true }), output);
+  test_minify(assert, input, { sortClassName: true }, output);
 
   input = '<a class="moo <!-- htmlmin:ignore -->bar<!-- htmlmin:ignore --> foo baz"></a>';
   output = '<a class="moo bar foo baz"></a>';
-  assert.equal(minify(input), output);
-  assert.equal(minify(input, { sortClassName: false }), output);
+  test_minify(assert, input, output);
+  test_minify(assert, input, { sortClassName: false }, output);
   output = '<a class="baz foo moo bar"></a>';
-  assert.equal(minify(input, { sortClassName: true }), output);
+  test_minify(assert, input, { sortClassName: true }, output);
 
   input = '<div class="nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar"></div>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
-  }), input);
-  assert.equal(minify(input, {
+  }, input);
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: false
-  }), input);
-  assert.equal(minify(input, {
+  }, input);
+  test_minify(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: true
-  }), input);
+  }, input);
 
   input = '<a class="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z"></a>';
-  assert.equal(minify(input, { sortClassName: false }), input);
-  assert.equal(minify(input, { sortClassName: true }), input);
+  test_minify(assert, input, { sortClassName: false }, input);
+  test_minify(assert, input, { sortClassName: true }, input);
 
   input = '<a class="add sort keys createSorter"></a>';
-  assert.equal(minify(input, { sortClassName: false }), input);
+  test_minify(assert, input, { sortClassName: false }, input);
   output = '<a class="add createSorter keys sort"></a>';
-  assert.equal(minify(input, { sortClassName: true }), output);
+  test_minify(assert, input, { sortClassName: true }, output);
 
   input = '<span class="sprite sprite-{{sprite}}"></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }), input);
+  }, input);
 
   input = '<span class="{{sprite}}-sprite sprite"></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }), input);
+  }, input);
 
   input = '<span class="sprite-{{sprite}}-sprite"></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }), input);
+  }, input);
 
   input = '<span class="{{sprite}}"></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }), input);
+  }, input);
 
   input = '<span class={{sprite}}></span>';
   output = '<span class="{{sprite}}"></span>';
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }), output);
+  }, output);
 });
 
 QUnit.test('decode entity characters', function(assert) {
   var input, output;
 
   input = '<!-- &ne; -->';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { decodeEntities: false }), input);
-  assert.equal(minify(input, { decodeEntities: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { decodeEntities: false }, input);
+  test_minify(assert, input, { decodeEntities: true }, input);
 
   input = '<script type="text/html">&colon;</script>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { decodeEntities: false }), input);
-  assert.equal(minify(input, { decodeEntities: true }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { decodeEntities: false }, input);
+  test_minify(assert, input, { decodeEntities: true }, input);
   output = '<script type="text/html">:</script>';
-  assert.equal(minify(input, { decodeEntities: true, processScripts: ['text/html'] }), output);
+  test_minify(assert, input, { decodeEntities: true, processScripts: ['text/html'] }, output);
 
   input = '<div style="font: &quot;monospace&#34;">foo&dollar;</div>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { decodeEntities: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { decodeEntities: false }, input);
   output = '<div style=\'font: "monospace"\'>foo$</div>';
-  assert.equal(minify(input, { decodeEntities: true }), output);
+  test_minify(assert, input, { decodeEntities: true }, output);
   output = '<div style="font:&quot">foo&dollar;</div>';
-  assert.equal(minify(input, { minifyCSS: true }), output);
-  assert.equal(minify(input, { decodeEntities: false, minifyCSS: true }), output);
+  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, { decodeEntities: false, minifyCSS: true }, output);
   output = '<div style="font:monospace">foo$</div>';
-  assert.equal(minify(input, { decodeEntities: true, minifyCSS: true }), output);
+  test_minify(assert, input, { decodeEntities: true, minifyCSS: true }, output);
 
   input = '<a href="/?foo=1&amp;bar=&lt;2&gt;">baz&lt;moo&gt;&copy;</a>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { decodeEntities: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { decodeEntities: false }, input);
   output = '<a href="/?foo=1&bar=<2>">baz&lt;moo>\u00a9</a>';
-  assert.equal(minify(input, { decodeEntities: true }), output);
+  test_minify(assert, input, { decodeEntities: true }, output);
 
   input = '<? &amp; ?>&amp;<pre><? &amp; ?>&amp;</pre>';
-  assert.equal(minify(input), input);
-  assert.equal(minify(input, { collapseWhitespace: false, decodeEntities: false }), input);
-  assert.equal(minify(input, { collapseWhitespace: true, decodeEntities: false }), input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, { collapseWhitespace: false, decodeEntities: false }, input);
+  test_minify(assert, input, { collapseWhitespace: true, decodeEntities: false }, input);
   output = '<? &amp; ?>&<pre><? &amp; ?>&</pre>';
-  assert.equal(minify(input, { collapseWhitespace: false, decodeEntities: true }), output);
-  assert.equal(minify(input, { collapseWhitespace: true, decodeEntities: true }), output);
+  test_minify(assert, input, { collapseWhitespace: false, decodeEntities: true }, output);
+  test_minify(assert, input, { collapseWhitespace: true, decodeEntities: true }, output);
 });
 
 QUnit.test('tests from PHPTAL', function(assert) {
@@ -3341,7 +3393,7 @@ QUnit.test('tests from PHPTAL', function(assert) {
       'foo</body> </html>  <!-- bla -->'
     ]*/
   ].forEach(function(tokens) {
-    assert.equal(minify(tokens[1], {
+    test_minify(assert, tokens[1], {
       collapseBooleanAttributes: true,
       collapseWhitespace: true,
       removeAttributeQuotes: true,
@@ -3354,7 +3406,7 @@ QUnit.test('tests from PHPTAL', function(assert) {
       removeTagWhitespace: true,
       sortAttributes: true,
       useShortDoctype: true
-    }), tokens[0]);
+    }, tokens[0]);
   });
 });
 
@@ -3369,381 +3421,31 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   var input = '<div class="leaveAlone"><span> </span> foo  bar</div>';
   var output = '<div class="leaveAlone"><span> </span> foo  bar</div>';
 
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }), output);
+  }, output);
 
   // Regression test: Previously the first </div> would clear the internal
   // stackNo{Collapse,Trim}Whitespace, so that ' foo  bar' turned into ' foo bar'
   input = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
   output = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
 
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }), output);
+  }, output);
 
   // Make sure that the stack does get reset when leaving the element for which
   // the hooks returned false:
   input = '<div class="leaveAlone"></div><div> foo  bar </div>';
   output = '<div class="leaveAlone"></div><div>foo bar</div>';
 
-  assert.equal(minify(input, {
+  test_minify(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }), output);
-});
-
-QUnit.test('style minification with callback', function(assert) {
-  var input = '<style>div#foo { background-color: red; color: white }</style>';
-  var output = '<style>div#foo { background-color: red; color: white } callback!</style>';
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('script minification with callback', function(assert) {
-  var input = '<script>(function(){ console.log("Hello"); })()</script>';
-  var output = '<script>(function(){ console.log("Hello"); })()(function(){ console.log("World"); })()</script>';
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + '(function(){ console.log("World"); })()');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('style async minification with script sync minification', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var output = '<style>div#foo { background-color: red; } callback!</style><script>console.log("Hello World")</script>';
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      },
-      minifyJS: true
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('style sync minification with script async minification', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var output = '<style>div#foo{background-color:red}</style><script>console . log("Hello World") ; callback!</script>';
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: true,
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('style async minification with script async minification', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      },
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('async minification alongside sync minification', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var syncOutput = '<style>div#foo{background-color:red}</style><script>console.log("Hello World")</script>';
-  var asyncOutput = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      },
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, asyncOutput);
-      done();
-    }
-  ));
-
-  assert.equal(minify(input, {
-    minifyCSS: true,
-    minifyJS: true
-  }), syncOutput);
-});
-
-QUnit.test('multiple async minifications', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
-  var done = assert.async(2);
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      },
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          cb(css + ' callback!');
-        }, 0);
-      },
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          cb(js + ' callback!');
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('sync minify with callback', function(assert) {
-  var input = '<html><head><title>Test</title></head><body>Hello World</body></html>';
-  var output = input;
-  var done = assert.async();
-  assert.notOk(minify(
-    input,
-    {},
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('minify error with callback', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><invalid html';
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {},
-    function(error) {
-      assert.ok(error);
-      assert.equal(error.message, 'Parse Error: <invalid html');
-      done();
-    }
-  ));
-});
-
-QUnit.test('error in callback', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style>';
-  var error = new Error();
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function() {
-        throw error;
-      }
-    },
-    function(err) {
-      assert.strictEqual(err, error);
-      done();
-    }
-  ));
-});
-
-QUnit.test('call callback multiple times', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><script>console . log("Hello World") ;</script>';
-  var output = '<style>div#foo { background-color: red; } callback!</style><script>console . log("Hello World") ; callback!</script>';
-  var done = assert.async(3);
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(css, cb) {
-        setTimeout(function() {
-          try {
-            cb(css + ' callback!');
-            cb(css + ' callback!');
-
-            assert.ok(false, 'An error should be thrown.');
-            done();
-          }
-          catch (error) {
-            assert.equal(error.message, 'Async completion has already occurred.');
-            done();
-          }
-        }, 0);
-      },
-      minifyJS: function(js, inline, cb) {
-        setTimeout(function() {
-          try {
-            cb(js + ' callback!');
-            cb(js + ' callback!');
-
-            assert.ok(false, 'An error should be thrown.');
-            done();
-          }
-          catch (error) {
-            assert.equal(error.message, 'Async completion has already occurred.');
-            done();
-          }
-        }, 0);
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('inline script with callback', function(assert) {
-  var input = '<p onclick="alert(1 + 2);">';
-  var output = '<p onclick="JS"></p>';
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {
-      customEventAttributes: [/^on*/],
-      minifyJS: function(text, inline, cb) {
-        cb('JS');
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('inline style with callback', function(assert) {
-  var input = '<p style="display: none;">';
-  var output = '<p style="CSS"></p>';
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(text, cb) {
-        cb('CSS');
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
-});
-
-QUnit.test('inline style media with callback', function(assert) {
-  var input = '<style media="{max-width: 100px}"></style>';
-  var output = '<style media="CSS">CSS</style>';
-  var done = assert.async();
-
-  assert.notOk(minify(
-    input,
-    {
-      minifyCSS: function(text, cb) {
-        cb('CSS');
-      }
-    },
-    function(error, result) {
-      assert.notOk(error);
-      assert.equal(result, output);
-      done();
-    }
-  ));
+  }, output);
 });

From ee3054f0afd3d8b74295469304b6f31e361e78fd Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 15:18:57 +1200
Subject: [PATCH 20/66] Fix potential issue with placeholder not being at the
 same index it was put at when it comes to replacing it with content.

---
 src/htmlminifier.js | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 388e9bdf..a2cbf118 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1310,8 +1310,8 @@ function minify(value, options, partialMarkup, cb) {
           return;
         }
 
-        var insertIndex = buffer.length;
-        buffer.push(null);
+        var placeholder = {}; // Some unique object.
+        buffer.push(placeholder);
 
         // Create a new AsyncTask that will update the buffer once complete.
         asyncTasks.push(
@@ -1319,7 +1319,9 @@ function minify(value, options, partialMarkup, cb) {
             asyncSubtasks,
             text,
             function(result) {
-              buffer[insertIndex] = result;
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              buffer[buffer.indexOf(placeholder)] = result;
             }
           )
         );

From aa56a66f04de624a6a0fa33e93a6339a80bc447f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 16:26:51 +1200
Subject: [PATCH 21/66] Refactored.

---
 src/htmlminifier.js | 108 +++++++++++++++++++++++++++++---------------
 1 file changed, 72 insertions(+), 36 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index a2cbf118..6d4fc93a 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -862,7 +862,7 @@ function minify(value, options, partialMarkup, cb) {
    *
    * @param {AsyncSubtask[]} tasks
    * @param {string} content
-   * @param {Function<string>} cb
+   * @param {Function<Error, string>} cb
    */
   function AsyncTask(tasks, content, cb) {
     this.tasks = tasks;
@@ -871,47 +871,59 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   /**
-   * Run the subtasks at the given index, giving it a callback to run the next
-   * subtask the same way. This therefore asynchronously runs all subtasks from
-   * the given index in series.
+   * Asynchronously runs all subtasks in this task in series.
    *
    * @private
-   * @param {string} content
-   * @param {number} index
+   * @param {Function<Error, string>} cb
    */
-  AsyncTask.prototype.runSubtask = function(content, index) {
-    if (index < this.tasks.length) {
-      try {
-        this.tasks[index].exec(
-          content,
-          function(result) {
-            if (this.tasks[index].cbExecuted) {
-              throw new Error('Async completion has already occurred.');
-            }
-            this.tasks[index].cbExecuted = true;
+  AsyncTask.prototype.execSubtaskChain = function(cb) {
+    /**
+     * Run the subtask at the given index, giving it a callback to run the next
+     * subtask the same way.
+     *
+     * @param {string} content
+     * @param {number} index
+     */
+    (function implementation(content, index) {
+      if (index < this.tasks.length) {
+        try {
+          this.tasks[index].exec(
+            content,
+            function(result) {
+              if (this.tasks[index].cbExecuted) {
+                throw new Error('Async completion has already occurred.');
+              }
+              this.tasks[index].cbExecuted = true;
 
-            this.runSubtask(result, index + 1);
-          }.bind(this)
-        );
-      }
-      catch (error) {
-        cb(error);
+              implementation.call(this, result, index + 1, cb);
+            }.bind(this)
+          );
+        }
+        catch (error) {
+          cb.call(this, error);
+        }
       }
-    }
-    else {
-      this.cb(content);
-      if (++asyncTasksComplete === asyncTasks.length) {
-        cb(null, finalize());
+      else {
+        cb.call(this, null, content);
       }
-    }
+    }.bind(this))(this.content, 0);
   };
 
   /**
    * Execute this task.
+   *
+   * @param {Function<Error>} cb
    */
-  AsyncTask.prototype.exec = function() {
-    // Recursively run all subtasks.
-    this.runSubtask(this.content, 0);
+  AsyncTask.prototype.exec = function(cb) {
+    // Execute all subtasks.
+    this.execSubtaskChain(function(error, result) {
+      if (typeof this.cb === 'function') {
+        this.cb(error, result);
+      }
+      if (typeof cb === 'function') {
+        cb(error, result);
+      }
+    });
   };
 
   /**
@@ -1318,7 +1330,12 @@ function minify(value, options, partialMarkup, cb) {
           new AsyncTask(
             asyncSubtasks,
             text,
-            function(result) {
+            function(error, result) {
+              // Don't do anything if there is an error.
+              if (error) {
+                return;
+              }
+
               // The index of the placeholder may not be the same as where it
               // was originally inserted at; therefore we need to search for it.
               buffer[buffer.indexOf(placeholder)] = result;
@@ -1415,20 +1432,39 @@ function minify(value, options, partialMarkup, cb) {
     return finalize();
   }
 
-  // No async tasks?
-  if (asyncTasks.length === 0) {
+  function callCallBack() {
     try {
       cb(null, finalize());
     }
     catch (error) {
       cb(error);
     }
-    return;
+  }
+
+  // No async tasks?
+  if (asyncTasks.length === 0) {
+    return callCallBack();
+  }
+
+  var asyncTasksCallbackCalled = false;
+  function onAsyncTasksComplete(error) {
+    // If an error occurs immediately call the callback.
+    // If other tasks complete afterwards, ignore them.
+    if (!asyncTasksCallbackCalled) {
+      if (error) {
+        cb(error);
+        asyncTasksCallbackCalled = true;
+        return;
+      }
+      if (++asyncTasksComplete === asyncTasks.length) {
+        return callCallBack();
+      }
+    }
   }
 
   // Execute all the async tasks.
   for (var i = 0; i < asyncTasks.length; i++) {
-    asyncTasks[i].exec();
+    asyncTasks[i].exec(onAsyncTasksComplete);
   }
   return;
 }

From f82ca4a7326828c1bc187296bdfd8e6222c3c0b2 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 16:53:54 +1200
Subject: [PATCH 22/66] Asynchronously tests now give more helpful feedback
 when an error occurs.

---
 tests/minifier.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 1bfee7e0..d733f7d8 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -52,7 +52,15 @@ function test_minify(assert, input, options, output, description) {
 
   // Asynchronously test.
   assert.notOk(minify(input, options, function(error, result) {
-    assert.notOk(error);
+    // Error should be null
+    if (error !== null) {
+      if (error instanceof Error) {
+        assert.equal(error, null, 'An error occurred - stack trace:\n' + error.stack);
+      }
+      else {
+        assert.equal(error, null, 'Something that\'s not of type Error was returned as an error.');
+      }
+    }
     assert.equal(result, output, 'Asynchronous Test: ' + description);
     done();
   }));

From 314c4b82809b088b464ffab6b40d90dcf718cb15 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 17:42:21 +1200
Subject: [PATCH 23/66] Created a test_minify_error function to test for
 expected errors.

---
 tests/minifier.js | 71 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 57 insertions(+), 14 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index d733f7d8..3d517461 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -55,10 +55,10 @@ function test_minify(assert, input, options, output, description) {
     // Error should be null
     if (error !== null) {
       if (error instanceof Error) {
-        assert.equal(error, null, 'An error occurred - stack trace:\n' + error.stack);
+        assert.equal(error, null, 'Asynchronous Test: An error occurred - stack trace:\n' + error.stack);
       }
       else {
-        assert.equal(error, null, 'Something that\'s not of type Error was returned as an error.');
+        assert.ok(false, 'Asynchronous Test: Something that\'s not of type Error was returned as an error.');
       }
     }
     assert.equal(result, output, 'Asynchronous Test: ' + description);
@@ -66,6 +66,47 @@ function test_minify(assert, input, options, output, description) {
   }));
 }
 
+/**
+ * Test the minify function both synchronously and asynchronously for an expected error.
+ *
+ * @param {QUnit.assert} assert
+ * @param {string} input
+ * @param {Object} options
+ * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
+ * @param {string} [description]
+ */
+function test_minify_error(assert, input, options, errorMatcher, description) {
+  // Remove optional errorMatcher parameter if it is not given.
+  if (typeof errorMatcher === 'string') {
+    description = errorMatcher;
+    errorMatcher = null;
+  }
+
+  // Set default description as input.
+  if (typeof description === 'undefined') {
+    description = input;
+  }
+
+  // Synchronously test.
+  assert.throws(function() { minify(input, options); }, errorMatcher, 'Synchronous Test: ' + description);
+
+  // Asynchronously test.
+  var done = assert.async();
+  assert.notOk(minify(input, options, function(error, result) {
+    if (error === null) {
+      assert.ok(false, 'Asynchronous Test: An error should have occurred.');
+    }
+    else if (error instanceof Error) {
+      assert.throws(function() { throw error; }, errorMatcher, 'Asynchronous Test: ' + description);
+    }
+    else {
+      assert.ok(false, 'Asynchronous Test: Something that\'s not of type Error was returned as an error.');
+    }
+    assert.notOk(result);
+    done();
+  }));
+}
+
 QUnit.test('`minifiy` exists', function(assert) {
   assert.ok(minify);
 });
@@ -121,9 +162,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   test_minify(assert, input, input);
 
   input = '<$unicorn>';
-  assert.throws(function() {
-    minify(input);
-  }, 'Invalid tag name');
+  test_minify_error(assert, input, {}, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
   test_minify(assert, input, input);
@@ -153,9 +192,12 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
   test_minify(assert, input, input);
-  assert.throws(function() {
-    minify('<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>');
-  }, 'invalid attribute name');
+  test_minify_error(
+    assert,
+    '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>',
+    {},
+    'invalid attribute name'
+  );
 
   // https://github.com/kangax/html-minifier/issues/512
   input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
@@ -166,18 +208,19 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
   test_minify(assert, input, input);
-  assert.throws(function() {
-    minify(
-      '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
+  test_minify_error(
+    assert,
+    '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
       ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
       ' placeholder="YYYY-MM-DD"' +
       ' date-range-picker' +
       ' data-ng-model="vm.value"' +
       ' data-ng-model-options="{ debounce: 1000 }"' +
       ' data-ng-pattern="vm.options.format"' +
-      ' data-options="vm.datepickerOptions">'
-    );
-  }, 'HTML comment inside tag');
+      ' data-options="vm.datepickerOptions">',
+    {},
+    'HTML comment inside tag'
+  );
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';

From 5bcb767e0e1d65208e87937122cb9d2dc05372ba Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 17:43:55 +1200
Subject: [PATCH 24/66] Fixed issue with code still executing after callback.

---
 src/htmlminifier.js | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 6d4fc93a..c223ddb0 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1506,19 +1506,17 @@ exports.minify = function(value, options, cb) {
     if (error) {
       if (hasCallback) {
         cb(error);
+        return;
       }
-      else {
-        throw error;
-      }
+      throw error;
     }
 
     options.log('minified in: ' + (Date.now() - start) + 'ms');
     if (hasCallback) {
       cb(null, result);
+      return;
     }
-    else {
-      minified = result;
-    }
+    minified = result;
   });
   return minified;
 };

From 3f2bc2439570e11f8e642ce82998fb940ad5138d Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 19:34:52 +1200
Subject: [PATCH 25/66] Initial step to get normalizeAttr working with a
 callback.

---
 src/htmlminifier.js | 109 ++++++++++++++++++++++++++++++++------------
 1 file changed, 81 insertions(+), 28 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index c223ddb0..930babe1 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -521,7 +521,7 @@ function canTrimWhitespace(tag) {
   return !/^(?:pre|textarea)$/.test(tag);
 }
 
-function normalizeAttr(attr, attrs, tag, options) {
+function normalizeAttr(attr, attrs, tag, options, cb) {
   var attrName = options.caseSensitive ? attr.name : attr.name.toLowerCase(),
       attrValue = attr.value;
 
@@ -535,25 +535,25 @@ function normalizeAttr(attr, attrs, tag, options) {
     attrName === 'type' && isScriptTypeAttribute(attrValue) ||
     options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
     attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) {
-    return;
+    return cb();
   }
 
   attrValue = cleanAttributeValue(tag, attrName, attrValue, options, attrs);
 
   if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
-    return;
+    return cb();
   }
 
   if (options.decodeEntities && attrValue) {
     attrValue = attrValue.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp;$1');
   }
 
-  return {
+  return cb(null, {
     attr: attr,
     name: attrName,
     value: attrValue
-  };
+  });
 }
 
 function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
@@ -889,7 +889,11 @@ function minify(value, options, partialMarkup, cb) {
         try {
           this.tasks[index].exec(
             content,
-            function(result) {
+            function(error, result) {
+              if (error) {
+                throw error;
+              }
+
               if (this.tasks[index].cbExecuted) {
                 throw new Error('Async completion has already occurred.');
               }
@@ -946,7 +950,7 @@ function minify(value, options, partialMarkup, cb) {
     // Finished synchronously?
     if (typeof result !== 'undefined') {
       // Call the callback manually.
-      cb(result);
+      cb(null, result);
     }
   };
 
@@ -1130,29 +1134,78 @@ function minify(value, options, partialMarkup, cb) {
           options.sortAttributes(tag, attrs);
         }
 
-        var parts = [];
-        for (var i = attrs.length, isLast = true; --i >= 0;) {
-          var normalized = normalizeAttr(attrs[i], attrs, tag, options);
-          if (normalized) {
-            parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
-            isLast = false;
-          }
-        }
-        if (parts.length > 0) {
-          buffer.push(' ');
-          buffer.push.apply(buffer, parts);
-        }
-        // start tag must never be omitted if it has any attributes
-        else if (optional && optionalStartTags(tag)) {
-          optionalStartTag = tag;
-        }
+        var placeholder = {}; // Some unique object.
+        buffer.push(placeholder);
 
-        buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
+        // Create a new AsyncTask that will update the buffer once complete.
+        asyncTasks.push(
+          new AsyncTask(
+            [new AsyncSubtask(function(content, cb) {
+              var parts = [];
+              var isLast = true;
+
+              // Loop through all the attributes and normalize them.
+              return (function normalizeAttrLoop(i) {
+                // Attributes to normalize?
+                if (--i >= 0) {
+                  var loopResult;
+                  // Normalize all the attributes in series.
+                  normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
+                    if (error) {
+                      cb(error);
+                      return;
+                    }
+
+                    if (normalized) {
+                      parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
+                      isLast = false;
+                    }
+
+                    loopResult = normalizeAttrLoop(i);
+                  });
+                  return loopResult;
+                }
 
-        if (autoGenerated && !options.includeAutoGeneratedTags) {
-          removeStartTag();
-          optionalStartTag = '';
-        }
+                // Attributes all normalize?
+                var bufferChanges = [];
+
+                if (parts.length > 0) {
+                  bufferChanges.push(' ');
+                  bufferChanges.push.apply(bufferChanges, parts);
+                }
+                // start tag must never be omitted if it has any attributes
+                else if (optional && optionalStartTags(tag)) {
+                  optionalStartTag = tag;
+                }
+
+                if (bufferChanges.length > 0) {
+                  bufferChanges.push(bufferChanges.pop() + (hasUnarySlash ? '/' : '') + '>');
+                }
+                else {
+                  bufferChanges.push((hasUnarySlash ? '/' : '') + '>');
+                }
+
+                if (autoGenerated && !options.includeAutoGeneratedTags) {
+                  removeStartTag();
+                  optionalStartTag = '';
+                }
+
+                return bufferChanges;
+              })(attrs.length);
+            })],
+            null,
+            function(error, result) {
+              // Don't do anything if there is an error.
+              if (error) {
+                return;
+              }
+
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              buffer.splice.apply(buffer, [buffer.indexOf(placeholder), 1].concat(result));
+            }
+          )
+        );
       },
       end: function(tag, attrs, autoGenerated) {
         var lowerTag = tag.toLowerCase();

From 0a5e9b826232cb35198e933bd75ca5f49aebdde8 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 21:39:16 +1200
Subject: [PATCH 26/66] Fixed conversion from sync to async minifyJS and
 minifyCSS.

---
 tests/minifier.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 3d517461..c6fbd410 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -37,14 +37,14 @@ function test_minify(assert, input, options, output, description) {
     if (typeof options.minifyJS === 'function') {
       var minifyJS = options.minifyJS;
       options.minifyJS = function(text, inline, callback) {
-        callback(minifyJS(text, inline));
+        callback(null, minifyJS(text, inline));
       };
     }
     // Convert `minifyCSS` to use a callback.
     if (typeof options.minifyCSS === 'function') {
       var minifyCSS = options.minifyCSS;
       options.minifyCSS = function(text, type, callback) {
-        callback(minifyCSS(text, type));
+        callback(null, minifyCSS(text, type));
       };
     }
   }

From fe5da2d1eed09d32e2cce4ff5f738d75928777d1 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 18 Apr 2018 21:40:01 +1200
Subject: [PATCH 27/66] Refactored.

---
 src/htmlminifier.js | 227 ++++++++++++++++++++++----------------------
 1 file changed, 111 insertions(+), 116 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 930babe1..2902dbf5 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -843,7 +843,7 @@ function minify(value, options, partialMarkup, cb) {
   /**
    * Set of tasks to perform asynchronously.
    *
-   * @type {AsyncTask[]}
+   * @type {Array<AsyncTask|AsyncTaskGroup>}
    */
   var asyncTasks = [];
 
@@ -855,40 +855,57 @@ function minify(value, options, partialMarkup, cb) {
   var asyncTasksComplete = 0;
 
   /**
-   * A task that will be executed asynchronously after all the synchronous
-   * code has executed.
+   * A placeholder that can be inserted into the buffer in place of a string.
+   *
+   * Placeholder objects in the buffer will be removed by async tasks before
+   * completion of the `minify` function.
+   *
+   * @constructor
+   */
+  function Placeholder() {}
+
+  /**
+   * A group of AsyncTasks to execute in series.
    *
    * @constructor
    *
-   * @param {AsyncSubtask[]} tasks
-   * @param {string} content
-   * @param {Function<Error, string>} cb
+   * @param {AsyncTask[]} tasks
+   * @param {*} data
+   * @param {Function<Error, *>} cb
    */
-  function AsyncTask(tasks, content, cb) {
+  function AsyncTaskGroup(tasks, data, cb) {
     this.tasks = tasks;
-    this.content = content;
+    this.data = data;
     this.cb = cb;
   }
 
   /**
-   * Asynchronously runs all subtasks in this task in series.
+   * Asynchronously runs all tasks in this group in series.
    *
-   * @private
-   * @param {Function<Error, string>} cb
+   * @param {Function<Error, *>} cb
    */
-  AsyncTask.prototype.execSubtaskChain = function(cb) {
+  AsyncTaskGroup.prototype.exec = function(cb) {
+    function multiCb(error, result) {
+      if (typeof this.cb === 'function') {
+        this.cb(error, result);
+      }
+      if (typeof cb === 'function') {
+        cb(error, result);
+      }
+    }
+
     /**
-     * Run the subtask at the given index, giving it a callback to run the next
-     * subtask the same way.
+     * Run the task at the given index, giving it a callback to run the next
+     * task the same way.
      *
-     * @param {string} content
+     * @param {string} data
      * @param {number} index
      */
-    (function implementation(content, index) {
+    (function implementation(data, index) {
       if (index < this.tasks.length) {
         try {
+          this.tasks[index].data = data;
           this.tasks[index].exec(
-            content,
             function(error, result) {
               if (error) {
                 throw error;
@@ -899,59 +916,40 @@ function minify(value, options, partialMarkup, cb) {
               }
               this.tasks[index].cbExecuted = true;
 
-              implementation.call(this, result, index + 1, cb);
+              implementation.call(this, result, index + 1);
             }.bind(this)
           );
         }
         catch (error) {
-          cb.call(this, error);
+          multiCb.call(this, error);
         }
       }
       else {
-        cb.call(this, null, content);
+        multiCb.call(this, null, data);
       }
-    }.bind(this))(this.content, 0);
+    }.bind(this))(this.data, 0);
   };
 
   /**
-   * Execute this task.
-   *
-   * @param {Function<Error>} cb
-   */
-  AsyncTask.prototype.exec = function(cb) {
-    // Execute all subtasks.
-    this.execSubtaskChain(function(error, result) {
-      if (typeof this.cb === 'function') {
-        this.cb(error, result);
-      }
-      if (typeof cb === 'function') {
-        cb(error, result);
-      }
-    });
-  };
-
-  /**
-   * A subtask in an AsyncTask.
+   * An async task.
    *
    * @constructor
    *
-   * @param {Function<string, Function<string>>} task
+   * @param {Function<string, Function<Error, *>>} task
+   * @param {*} [data]
    */
-  function AsyncSubtask(task) {
+  function AsyncTask(task, data) {
     this.task = task;
+    this.data = data;
   }
 
   /**
-   * Execute this subtask.
+   * Execute this task.
+   *
+   * @param {Function<Error, *>} cb
    */
-  AsyncSubtask.prototype.exec = function(content, cb) {
-    var result = this.task(content, cb);
-
-    // Finished synchronously?
-    if (typeof result !== 'undefined') {
-      // Call the callback manually.
-      cb(null, result);
-    }
+  AsyncTask.prototype.exec = function(cb) {
+    this.task(this.data, cb);
   };
 
   // temporarily replace ignored chunks with comments,
@@ -1134,77 +1132,68 @@ function minify(value, options, partialMarkup, cb) {
           options.sortAttributes(tag, attrs);
         }
 
-        var placeholder = {}; // Some unique object.
+        var placeholder = new Placeholder(); // Some unique reference.
         buffer.push(placeholder);
 
-        // Create a new AsyncTask that will update the buffer once complete.
+        // Create a new AsyncTask that will update the buffer.
         asyncTasks.push(
-          new AsyncTask(
-            [new AsyncSubtask(function(content, cb) {
-              var parts = [];
-              var isLast = true;
-
-              // Loop through all the attributes and normalize them.
-              return (function normalizeAttrLoop(i) {
-                // Attributes to normalize?
-                if (--i >= 0) {
-                  var loopResult;
-                  // Normalize all the attributes in series.
-                  normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
-                    if (error) {
-                      cb(error);
-                      return;
-                    }
-
-                    if (normalized) {
-                      parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
-                      isLast = false;
-                    }
-
-                    loopResult = normalizeAttrLoop(i);
-                  });
-                  return loopResult;
-                }
+          new AsyncTask(function(data, cb) {
+            var parts = [];
+            var isLast = true;
+
+            // Loop through all the attributes and normalize them.
+            (function normalizeAttrLoop(i) {
+              // Attributes to normalize?
+              if (--i >= 0) {
+                var innerLoopResult;
+                // Normalize all the attributes in series.
+                normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
+                  if (error) {
+                    cb(error);
+                    return;
+                  }
 
-                // Attributes all normalize?
-                var bufferChanges = [];
+                  if (normalized) {
+                    parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
+                    isLast = false;
+                  }
 
-                if (parts.length > 0) {
-                  bufferChanges.push(' ');
-                  bufferChanges.push.apply(bufferChanges, parts);
-                }
-                // start tag must never be omitted if it has any attributes
-                else if (optional && optionalStartTags(tag)) {
-                  optionalStartTag = tag;
-                }
+                  innerLoopResult = normalizeAttrLoop(i);
+                });
+                return innerLoopResult;
+              }
 
-                if (bufferChanges.length > 0) {
-                  bufferChanges.push(bufferChanges.pop() + (hasUnarySlash ? '/' : '') + '>');
-                }
-                else {
-                  bufferChanges.push((hasUnarySlash ? '/' : '') + '>');
-                }
+              // Attributes all normalize?
+              var bufferChanges = [];
 
-                if (autoGenerated && !options.includeAutoGeneratedTags) {
-                  removeStartTag();
-                  optionalStartTag = '';
-                }
+              if (parts.length > 0) {
+                bufferChanges.push(' ');
+                bufferChanges.push.apply(bufferChanges, parts);
+              }
+              // start tag must never be omitted if it has any attributes
+              else if (optional && optionalStartTags(tag)) {
+                optionalStartTag = tag;
+              }
 
-                return bufferChanges;
-              })(attrs.length);
-            })],
-            null,
-            function(error, result) {
-              // Don't do anything if there is an error.
-              if (error) {
-                return;
+              if (bufferChanges.length > 0) {
+                bufferChanges.push(bufferChanges.pop() + (hasUnarySlash ? '/' : '') + '>');
+              }
+              else {
+                bufferChanges.push((hasUnarySlash ? '/' : '') + '>');
+              }
+
+              if (autoGenerated && !options.includeAutoGeneratedTags) {
+                removeStartTag();
+                optionalStartTag = '';
               }
 
+              // Update the buffer.
               // The index of the placeholder may not be the same as where it
               // was originally inserted at; therefore we need to search for it.
-              buffer.splice.apply(buffer, [buffer.indexOf(placeholder), 1].concat(result));
-            }
-          )
+              buffer.splice.apply(buffer, [buffer.indexOf(placeholder), 1].concat(bufferChanges));
+              return cb();
+            })(attrs.length);
+          })
         );
       },
       end: function(tag, attrs, autoGenerated) {
@@ -1330,13 +1319,19 @@ function minify(value, options, partialMarkup, cb) {
           text = processScript(text, options, currentAttrs);
         }
         if (isExecutableScript(currentTag, currentAttrs)) {
-          asyncSubtasks.push(new AsyncSubtask(function(content, cb) {
-            return options.minifyJS(content, null, cb);
+          asyncSubtasks.push(new AsyncTask(function(data, cb) {
+            var result = options.minifyJS(data, null, cb);
+            if (typeof result !== 'undefined') {
+              cb(null, result);
+            }
           }));
         }
         if (isStyleSheet(currentTag, currentAttrs)) {
-          asyncSubtasks.push(new AsyncSubtask(function(content, cb) {
-            return options.minifyCSS(content, null, cb);
+          asyncSubtasks.push(new AsyncTask(function(data, cb) {
+            var result = options.minifyCSS(data, null, cb);
+            if (typeof result !== 'undefined') {
+              cb(null, result);
+            }
           }));
         }
         if (options.removeOptionalTags && text) {
@@ -1375,12 +1370,12 @@ function minify(value, options, partialMarkup, cb) {
           return;
         }
 
-        var placeholder = {}; // Some unique object.
+        var placeholder = new Placeholder(); // Some unique reference.
         buffer.push(placeholder);
 
-        // Create a new AsyncTask that will update the buffer once complete.
+        // Create a new AsyncTaskGroup that will update the buffer once complete.
         asyncTasks.push(
-          new AsyncTask(
+          new AsyncTaskGroup(
             asyncSubtasks,
             text,
             function(error, result) {

From f23648e0c0243326944e39c51de920202404e340 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 19 Apr 2018 12:52:47 +1200
Subject: [PATCH 28/66] Async start tasks now modifies the buffer inplace.

---
 src/htmlminifier.js | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 0ae433e0..686ef5d3 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1163,34 +1163,33 @@ function minify(value, options, partialMarkup, cb) {
                 return innerLoopResult;
               }
 
-              // Attributes all normalize?
-              var bufferChanges = [];
+              // All attributes are now normalize.
+
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              var insertionIndex = buffer.indexOf(placeholder);
+
+              // Remove the placeholder.
+              buffer.splice(insertionIndex, 1);
 
               if (parts.length > 0) {
-                bufferChanges.push(' ');
-                bufferChanges.push.apply(bufferChanges, parts);
+                buffer.splice.apply(buffer, [insertionIndex, 0, ' '].concat(parts));
+                insertionIndex += 1 + parts.length;
               }
               // start tag must never be omitted if it has any attributes
               else if (optional && optionalStartTags(tag)) {
                 optionalStartTag = tag;
               }
 
-              if (bufferChanges.length > 0) {
-                bufferChanges.push(bufferChanges.pop() + (hasUnarySlash ? '/' : '') + '>');
-              }
-              else {
-                bufferChanges.push((hasUnarySlash ? '/' : '') + '>');
-              }
+              // Remove the last inserted element, modify it and put it back.
+              var lastElem = buffer.splice(--insertionIndex, 1)[0];
+              buffer.splice(insertionIndex++, 0, lastElem + (hasUnarySlash ? '/' : '') + '>');
 
               if (autoGenerated && !options.includeAutoGeneratedTags) {
                 removeStartTag();
                 optionalStartTag = '';
               }
 
-              // Update the buffer.
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              buffer.splice.apply(buffer, [buffer.indexOf(placeholder), 1].concat(bufferChanges));
               return cb();
             })(attrs.length);
           })

From 37b4ea7088ec5be211af6936b235b0e9fe6a276a Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 19 Apr 2018 13:20:09 +1200
Subject: [PATCH 29/66] removeStartTag and removeEndTag now take an indexBound
 which prevents modification to the buffer at or past its value.

---
 src/htmlminifier.js | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 686ef5d3..9b84317e 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1018,20 +1018,28 @@ function minify(value, options, partialMarkup, cb) {
     return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);
   }
 
-  function removeStartTag() {
-    var index = buffer.length - 1;
+  function removeStartTag(indexBound) {
+    if (typeof indexBound === 'undefined') {
+      indexBound = buffer.length;
+    }
+
+    var index = indexBound - 1;
     while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
       index--;
     }
-    buffer.length = Math.max(0, index);
+    return buffer.splice(index, indexBound - index).length;
   }
 
-  function removeEndTag() {
-    var index = buffer.length - 1;
+  function removeEndTag(indexBound) {
+    if (typeof indexBound === 'undefined') {
+      indexBound = buffer.length;
+    }
+
+    var index = indexBound - 1;
     while (index > 0 && !/^<\//.test(buffer[index])) {
       index--;
     }
-    buffer.length = Math.max(0, index);
+    return buffer.splice(index, indexBound - index).length;
   }
 
   // look for trailing whitespaces, bypass any inline tags
@@ -1186,7 +1194,7 @@ function minify(value, options, partialMarkup, cb) {
               buffer.splice(insertionIndex++, 0, lastElem + (hasUnarySlash ? '/' : '') + '>');
 
               if (autoGenerated && !options.includeAutoGeneratedTags) {
-                removeStartTag();
+                insertionIndex -= removeStartTag(insertionIndex);
                 optionalStartTag = '';
               }
 

From cebb7177a2a51c139a2e3aa030e0403f64b11953 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 19 Apr 2018 17:55:02 +1200
Subject: [PATCH 30/66] Added callbacks to more functions and wrapped them in
 AsyncTasks.

---
 src/htmlminifier.js | 875 ++++++++++++++++++++++++--------------------
 1 file changed, 478 insertions(+), 397 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 9b84317e..81b7f955 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -358,20 +358,22 @@ function unwrapMediaQuery(text) {
   return matches ? matches[1] : text;
 }
 
-function cleanConditionalComment(comment, options) {
+function cleanConditionalComment(comment, options, cb) {
   return options.processConditionalComments ? comment.replace(/^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, function(match, prefix, text, suffix) {
-    return prefix + minify(text, options, true) + suffix;
-  }) : comment;
+    return minify(text, options, true, function(error, result) {
+      return cb(error, prefix + result + suffix);
+    });
+  }) : cb(null, comment);
 }
 
-function processScript(text, options, currentAttrs) {
+function processScript(text, options, currentAttrs, cb) {
   for (var i = 0, len = currentAttrs.length; i < len; i++) {
     if (currentAttrs[i].name.toLowerCase() === 'type' &&
         options.processScripts.indexOf(currentAttrs[i].value) > -1) {
-      return minify(text, options);
+      return minify(text, options, false, cb);
     }
   }
-  return text;
+  return cb(text);
 }
 
 // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
@@ -726,7 +728,7 @@ function uniqueId(value) {
 
 var specialContentTags = createMapFromString('script,style');
 
-function createSortFns(value, options, uidIgnore, uidAttr) {
+function createSortFns(value, options, uidIgnore, uidAttr, cb) {
   var attrChains = options.sortAttributes && Object.create(null);
   var classChain = options.sortClassName && new TokenChain();
 
@@ -781,33 +783,41 @@ function createSortFns(value, options, uidIgnore, uidAttr) {
   options.log = identity;
   options.sortAttributes = false;
   options.sortClassName = false;
-  scan(minify(value, options));
-  options.log = log;
-  if (attrChains) {
-    var attrSorters = Object.create(null);
-    for (var tag in attrChains) {
-      attrSorters[tag] = attrChains[tag].createSorter();
+  minify(value, options, false, function(error, result) {
+    if (error) {
+      return cb(error);
     }
-    options.sortAttributes = function(tag, attrs) {
-      var sorter = attrSorters[tag];
-      if (sorter) {
-        var attrMap = Object.create(null);
-        var names = attrNames(attrs);
-        names.forEach(function(name, index) {
-          (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
-        });
-        sorter.sort(names).forEach(function(name, index) {
-          attrs[index] = attrMap[name].shift();
-        });
+
+    scan(result);
+    options.log = log;
+    if (attrChains) {
+      var attrSorters = Object.create(null);
+      for (var tag in attrChains) {
+        attrSorters[tag] = attrChains[tag].createSorter();
       }
-    };
-  }
-  if (classChain) {
-    var sorter = classChain.createSorter();
-    options.sortClassName = function(value) {
-      return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');
-    };
-  }
+      options.sortAttributes = function(tag, attrs) {
+        var sorter = attrSorters[tag];
+        if (sorter) {
+          var attrMap = Object.create(null);
+          var names = attrNames(attrs);
+          names.forEach(function(name, index) {
+            (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
+          });
+          sorter.sort(names).forEach(function(name, index) {
+            attrs[index] = attrMap[name].shift();
+          });
+        }
+      };
+    }
+    if (classChain) {
+      var sorter = classChain.createSorter();
+      options.sortClassName = function(value) {
+        return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');
+      };
+    }
+
+    return cb();
+  });
 }
 
 /**
@@ -815,8 +825,8 @@ function createSortFns(value, options, uidIgnore, uidAttr) {
  *
  * @param {string} value
  * @param {Object} options
- * @param {boolean} [partialMarkup=false]
- * @param {Function<Error, string>} [cb]
+ * @param {boolean} partialMarkup
+ * @param {Function<Error, string>} cb
  */
 function minify(value, options, partialMarkup, cb) {
   if (options.collapseWhitespace) {
@@ -826,7 +836,6 @@ function minify(value, options, partialMarkup, cb) {
   var buffer = [],
       charsPrevTag,
       currentChars = '',
-      hasCallback = typeof cb === 'function',
       hasChars,
       currentTag = '',
       currentAttrs = [],
@@ -847,13 +856,6 @@ function minify(value, options, partialMarkup, cb) {
    */
   var asyncTasks = [];
 
-  /**
-   * The number of async tasks that have completed.
-   *
-   * @type {number}
-   */
-  var asyncTasksComplete = 0;
-
   /**
    * A placeholder that can be inserted into the buffer in place of a string.
    *
@@ -869,12 +871,12 @@ function minify(value, options, partialMarkup, cb) {
    *
    * @constructor
    *
-   * @param {AsyncTask[]} tasks
-   * @param {*} data
-   * @param {Function<Error, *>} cb
+   * @param {AsyncTask[]} [tasks]
+   * @param {*} [data]
+   * @param {Function<Error, *>} [cb]
    */
   function AsyncTaskGroup(tasks, data, cb) {
-    this.tasks = tasks;
+    this.tasks = tasks ? tasks : [];
     this.data = data;
     this.cb = cb;
   }
@@ -904,7 +906,9 @@ function minify(value, options, partialMarkup, cb) {
     (function implementation(data, index) {
       if (index < this.tasks.length) {
         try {
-          this.tasks[index].data = data;
+          if (typeof this.tasks[index].data === 'undefined') {
+            this.tasks[index].data = data;
+          }
           this.tasks[index].exec(
             function(error, result) {
               if (error) {
@@ -1007,7 +1011,9 @@ function minify(value, options, partialMarkup, cb) {
 
   if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||
       options.sortClassName && typeof options.sortClassName !== 'function') {
-    createSortFns(value, options, uidIgnore, uidAttr);
+    asyncTasks.push(new AsyncTask(function(data, cb) {
+      createSortFns(value, options, uidIgnore, uidAttr, cb);
+    }));
   }
 
   function _canCollapseWhitespace(tag, attrs) {
@@ -1070,109 +1076,150 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
-  try {
-    new HTMLParser(value, {
-      partialMarkup: partialMarkup,
-      html5: options.html5,
-
-      start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-        var lowerTag = tag.toLowerCase();
+  asyncTasks.push(new AsyncTask(function(data, cb) {
+    try {
+      new HTMLParser(value, {
+        partialMarkup: partialMarkup,
+        html5: options.html5,
 
-        if (lowerTag === 'svg') {
-          options = Object.create(options);
-          options.keepClosingSlash = true;
-          options.caseSensitive = true;
-        }
+        start: function(tag, attrs, unary, unarySlash, autoGenerated) {
+          var placeholder = new Placeholder(); // Some unique reference.
+          buffer.push(placeholder);
 
-        tag = options.caseSensitive ? tag : lowerTag;
+          asyncTasks.push(
+            new AsyncTask(function(data, cb) {
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              var insertionIndex = buffer.indexOf(placeholder);
 
-        currentTag = tag;
-        charsPrevTag = tag;
-        if (!inlineTextTags(tag)) {
-          currentChars = '';
-        }
-        hasChars = false;
-        currentAttrs = attrs;
-
-        var optional = options.removeOptionalTags;
-        if (optional) {
-          var htmlTag = htmlTags(tag);
-          // <html> may be omitted if first thing inside is not comment
-          // <head> may be omitted if first thing inside is an element
-          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-          // <colgroup> may be omitted if first thing inside is <col>
-          // <tbody> may be omitted if first thing inside is <tr>
-          if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
-            removeStartTag();
-          }
-          optionalStartTag = '';
-          // end-tag-followed-by-start-tag omission rules
-          if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
-            removeEndTag();
-            // <colgroup> cannot be omitted if preceding </colgroup> is omitted
-            // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
-            optional = !isStartTagMandatory(optionalEndTag, tag);
-          }
-          optionalEndTag = '';
-        }
+              // Remove the placeholder.
+              buffer.splice(insertionIndex, 1);
 
-        // set whitespace flags for nested tags (eg. <code> within a <pre>)
-        if (options.collapseWhitespace) {
-          if (!stackNoTrimWhitespace.length) {
-            squashTrailingWhitespace(tag);
-          }
-          if (!unary) {
-            if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
-              stackNoTrimWhitespace.push(tag);
-            }
-            if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
-              stackNoCollapseWhitespace.push(tag);
-            }
-          }
-        }
+              var lowerTag = data.tag.toLowerCase();
 
-        var openTag = '<' + tag;
-        var hasUnarySlash = unarySlash && options.keepClosingSlash;
+              if (lowerTag === 'svg') {
+                options = Object.create(options);
+                options.keepClosingSlash = true;
+                options.caseSensitive = true;
+              }
 
-        buffer.push(openTag);
+              data.tag = options.caseSensitive ? data.tag : lowerTag;
 
-        if (options.sortAttributes) {
-          options.sortAttributes(tag, attrs);
-        }
+              currentTag = data.tag;
+              charsPrevTag = data.tag;
+              if (!inlineTextTags(data.tag)) {
+                currentChars = '';
+              }
+              hasChars = false;
+              currentAttrs = data.attrs;
+
+              var optional = options.removeOptionalTags;
+              if (optional) {
+                var htmlTag = htmlTags(data.tag);
+                // <html> may be omitted if first thing inside is not comment
+                // <head> may be omitted if first thing inside is an element
+                // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+                // <colgroup> may be omitted if first thing inside is <col>
+                // <tbody> may be omitted if first thing inside is <tr>
+                if (htmlTag && canRemoveParentTag(optionalStartTag, data.tag)) {
+                  insertionIndex -= removeStartTag(insertionIndex);
+                }
+                optionalStartTag = '';
+                // end-data.tag-followed-by-start-data.tag omission rules
+                if (htmlTag && canRemovePrecedingTag(optionalEndTag, data.tag)) {
+                  insertionIndex -= removeEndTag(insertionIndex);
+                  // <colgroup> cannot be omitted if preceding </colgroup> is omitted
+                  // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
+                  optional = !isStartTagMandatory(optionalEndTag, data.tag);
+                }
+                optionalEndTag = '';
+              }
 
-        var placeholder = new Placeholder(); // Some unique reference.
-        buffer.push(placeholder);
-
-        // Create a new AsyncTask that will update the buffer.
-        asyncTasks.push(
-          new AsyncTask(function(data, cb) {
-            var parts = [];
-            var isLast = true;
-
-            // Loop through all the attributes and normalize them.
-            (function normalizeAttrLoop(i) {
-              // Attributes to normalize?
-              if (--i >= 0) {
-                var innerLoopResult;
-                // Normalize all the attributes in series.
-                normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
-                  if (error) {
-                    cb(error);
-                    return;
+              // set whitespace flags for nested tags (eg. <code> within a <pre>)
+              if (options.collapseWhitespace) {
+                if (!stackNoTrimWhitespace.length) {
+                  squashTrailingWhitespace(data.tag);
+                }
+                if (!data.unary) {
+                  if (!_canTrimWhitespace(data.tag, data.attrs) || stackNoTrimWhitespace.length) {
+                    stackNoTrimWhitespace.push(data.tag);
                   }
-
-                  if (normalized) {
-                    parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
-                    isLast = false;
+                  if (!_canCollapseWhitespace(data.tag, data.attrs) || stackNoCollapseWhitespace.length) {
+                    stackNoCollapseWhitespace.push(data.tag);
                   }
+                }
+              }
+
+              var openTag = '<' + data.tag;
+              var hasUnarySlash = data.unarySlash && options.keepClosingSlash;
 
-                  innerLoopResult = normalizeAttrLoop(i);
-                });
-                return innerLoopResult;
+              buffer.splice(insertionIndex++, 0, openTag);
+
+              if (options.sortAttributes) {
+                options.sortAttributes(data.tag, data.attrs);
               }
 
-              // All attributes are now normalize.
+              var parts = [];
+              var isLast = true;
+
+              // Loop through all the attributes and normalize them.
+              (function normalizeAttrLoop(i) {
+                // Attributes to normalize?
+                if (--i >= 0) {
+                  var innerLoopResult;
+                  // Normalize all the attributes in series.
+                  normalizeAttr(data.attrs[i], data.attrs, data.tag, options, function(error, normalized) {
+                    if (error) {
+                      return cb(error);
+                    }
+
+                    if (normalized) {
+                      parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
+                      isLast = false;
+                    }
+
+                    innerLoopResult = normalizeAttrLoop(i);
+                  });
+                  return innerLoopResult;
+                }
+
+                // All attributes are now normalize.
+
+                if (parts.length > 0) {
+                  buffer.splice.apply(buffer, [insertionIndex, 0, ' '].concat(parts));
+                  insertionIndex += 1 + parts.length;
+                }
+                // start tag must never be omitted if it has any attributes
+                else if (optional && optionalStartTags(data.tag)) {
+                  optionalStartTag = data.tag;
+                }
+
+                // Remove the last inserted element, modify it and put it back.
+                var lastElem = buffer.splice(--insertionIndex, 1)[0];
+                buffer.splice(insertionIndex++, 0, lastElem + (hasUnarySlash ? '/' : '') + '>');
+
+                if (data.autoGenerated && !options.includeAutoGeneratedTags) {
+                  insertionIndex -= removeStartTag(insertionIndex);
+                  optionalStartTag = '';
+                }
+
+                return cb(null, data);
+              })(data.attrs.length);
+            }, {
+              tag: tag,
+              attrs: attrs,
+              unary: unary,
+              unarySlash: unarySlash,
+              autoGenerated: autoGenerated
+            })
+          );
+        },
+        end: function(tag, attrs, autoGenerated) {
+          var placeholder = new Placeholder(); // Some unique reference.
+          buffer.push(placeholder);
 
+          asyncTasks.push(
+            new AsyncTask(function(data, cb) {
               // The index of the placeholder may not be the same as where it
               // was originally inserted at; therefore we need to search for it.
               var insertionIndex = buffer.indexOf(placeholder);
@@ -1180,262 +1227,316 @@ function minify(value, options, partialMarkup, cb) {
               // Remove the placeholder.
               buffer.splice(insertionIndex, 1);
 
-              if (parts.length > 0) {
-                buffer.splice.apply(buffer, [insertionIndex, 0, ' '].concat(parts));
-                insertionIndex += 1 + parts.length;
+              var lowerTag = data.tag.toLowerCase();
+              if (lowerTag === 'svg') {
+                options = Object.getPrototypeOf(options);
+              }
+              data.tag = options.caseSensitive ? data.tag : lowerTag;
+
+              // check if current tag is in a whitespace stack
+              if (options.collapseWhitespace) {
+                if (stackNoTrimWhitespace.length) {
+                  if (data.tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+                    stackNoTrimWhitespace.pop();
+                  }
+                }
+                else {
+                  squashTrailingWhitespace('/' + data.tag);
+                }
+                if (stackNoCollapseWhitespace.length &&
+                  data.tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+                  stackNoCollapseWhitespace.pop();
+                }
               }
-              // start tag must never be omitted if it has any attributes
-              else if (optional && optionalStartTags(tag)) {
-                optionalStartTag = tag;
+
+              var isElementEmpty = false;
+              if (data.tag === currentTag) {
+                currentTag = '';
+                isElementEmpty = !hasChars;
               }
 
-              // Remove the last inserted element, modify it and put it back.
-              var lastElem = buffer.splice(--insertionIndex, 1)[0];
-              buffer.splice(insertionIndex++, 0, lastElem + (hasUnarySlash ? '/' : '') + '>');
+              if (options.removeOptionalTags) {
+                // <html>, <head> or <body> may be omitted if the element is empty
+                if (isElementEmpty && topLevelTags(optionalStartTag)) {
+                  insertionIndex -= removeStartTag(insertionIndex);
+                }
+                optionalStartTag = '';
+                // </html> or </body> may be omitted if not followed by comment
+                // </head> may be omitted if not followed by space or comment
+                // </p> may be omitted if no more content in non-</a> parent
+                // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
+                if (htmlTags(data.tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(data.tag))) {
+                  insertionIndex -= removeEndTag(insertionIndex);
+                }
+                optionalEndTag = optionalEndTags(data.tag) ? data.tag : '';
+              }
 
-              if (autoGenerated && !options.includeAutoGeneratedTags) {
+              if (options.removeEmptyElements && isElementEmpty && canRemoveElement(data.tag, data.attrs)) {
+                // remove last "element" from buffer
                 insertionIndex -= removeStartTag(insertionIndex);
                 optionalStartTag = '';
+                optionalEndTag = '';
+              }
+              else {
+                if (data.autoGenerated && !options.includeAutoGeneratedTags) {
+                  optionalEndTag = '';
+                }
+                else {
+                  buffer.splice(insertionIndex, 0, '</' + data.tag + '>');
+                }
+                charsPrevTag = '/' + data.tag;
+                if (!inlineTags(data.tag)) {
+                  currentChars = '';
+                }
+                else if (isElementEmpty) {
+                  currentChars += '|';
+                }
               }
 
-              return cb();
-            })(attrs.length);
-          })
-        );
-      },
-      end: function(tag, attrs, autoGenerated) {
-        var lowerTag = tag.toLowerCase();
-        if (lowerTag === 'svg') {
-          options = Object.getPrototypeOf(options);
-        }
-        tag = options.caseSensitive ? tag : lowerTag;
-
-        // check if current tag is in a whitespace stack
-        if (options.collapseWhitespace) {
-          if (stackNoTrimWhitespace.length) {
-            if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
-              stackNoTrimWhitespace.pop();
-            }
-          }
-          else {
-            squashTrailingWhitespace('/' + tag);
-          }
-          if (stackNoCollapseWhitespace.length &&
-            tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
-            stackNoCollapseWhitespace.pop();
-          }
-        }
+              return cb(null, data);
+            }, {
+              tag: tag,
+              attrs: attrs,
+              autoGenerated: autoGenerated
+            })
+          );
+        },
+        chars: function(text, prevTag, nextTag) {
+          var placeholder = new Placeholder(); // Some unique reference.
+          buffer.push(placeholder);
 
-        var isElementEmpty = false;
-        if (tag === currentTag) {
-          currentTag = '';
-          isElementEmpty = !hasChars;
-        }
+          asyncTasks.push(
+            new AsyncTask(function(data, cb) {
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              var insertionIndex = buffer.indexOf(placeholder);
 
-        if (options.removeOptionalTags) {
-          // <html>, <head> or <body> may be omitted if the element is empty
-          if (isElementEmpty && topLevelTags(optionalStartTag)) {
-            removeStartTag();
-          }
-          optionalStartTag = '';
-          // </html> or </body> may be omitted if not followed by comment
-          // </head> may be omitted if not followed by space or comment
-          // </p> may be omitted if no more content in non-</a> parent
-          // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
-          if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
-            removeEndTag();
-          }
-          optionalEndTag = optionalEndTags(tag) ? tag : '';
-        }
+              // Remove the placeholder.
+              buffer.splice(insertionIndex, 1);
 
-        if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-          // remove last "element" from buffer
-          removeStartTag();
-          optionalStartTag = '';
-          optionalEndTag = '';
-        }
-        else {
-          if (autoGenerated && !options.includeAutoGeneratedTags) {
-            optionalEndTag = '';
-          }
-          else {
-            buffer.push('</' + tag + '>');
-          }
-          charsPrevTag = '/' + tag;
-          if (!inlineTags(tag)) {
-            currentChars = '';
-          }
-          else if (isElementEmpty) {
-            currentChars += '|';
-          }
-        }
-      },
-      chars: function(text, prevTag, nextTag) {
-        prevTag = prevTag === '' ? 'comment' : prevTag;
-        nextTag = nextTag === '' ? 'comment' : nextTag;
-        var asyncSubtasks = [];
-        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-          text = decode(text);
-        }
-        if (options.collapseWhitespace) {
-          if (!stackNoTrimWhitespace.length) {
-            if (prevTag === 'comment') {
-              var prevComment = buffer[buffer.length - 1];
-              if (prevComment.indexOf(uidIgnore) === -1) {
-                if (!prevComment) {
-                  prevTag = charsPrevTag;
+              var subtasks = [];
+              data.prevTag = data.prevTag === '' ? 'comment' : data.prevTag;
+              data.nextTag = data.nextTag === '' ? 'comment' : data.nextTag;
+              if (options.decodeEntities && data.text && !specialContentTags(currentTag)) {
+                data.text = decode(data.text);
+              }
+              if (options.collapseWhitespace) {
+                if (!stackNoTrimWhitespace.length) {
+                  if (data.prevTag === 'comment') {
+                    var prevComment = buffer[insertionIndex - 1];
+                    if (prevComment.indexOf(uidIgnore) === -1) {
+                      if (!prevComment) {
+                        data.prevTag = charsPrevTag;
+                      }
+                      if (insertionIndex > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
+                        var charsIndex = insertionIndex - 2;
+                        buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
+                          data.text = trailingSpaces + data.text;
+                          return '';
+                        });
+                      }
+                    }
+                  }
+                  if (data.prevTag) {
+                    if (data.prevTag === '/nobr' || data.prevTag === 'wbr') {
+                      if (/^\s/.test(data.text)) {
+                        var tagIndex = insertionIndex - 1;
+                        while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + data.prevTag) !== 0) {
+                          tagIndex--;
+                        }
+                        trimTrailingWhitespace(tagIndex - 1, 'br');
+                      }
+                    }
+                    else if (inlineTextTags(data.prevTag.charAt(0) === '/' ? data.prevTag.slice(1) : data.prevTag)) {
+                      data.text = collapseWhitespace(data.text, options, /(?:^|\s)$/.test(currentChars));
+                    }
+                  }
+                  if (data.prevTag || data.nextTag) {
+                    data.text = collapseWhitespaceSmart(data.text, data.prevTag, data.nextTag, options);
+                  }
+                  else {
+                    data.text = collapseWhitespace(data.text, options, true, true);
+                  }
+                  if (!data.text && /\s$/.test(currentChars) && data.prevTag && data.prevTag.charAt(0) === '/') {
+                    trimTrailingWhitespace(insertionIndex - 1, data.nextTag);
+                  }
                 }
-                if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
-                  var charsIndex = buffer.length - 2;
-                  buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
-                    text = trailingSpaces + text;
-                    return '';
-                  });
+                if (!stackNoCollapseWhitespace.length && data.nextTag !== 'html' && !(data.prevTag && data.nextTag)) {
+                  data.text = collapseWhitespace(data.text, options, false, false, true);
                 }
               }
-            }
-            if (prevTag) {
-              if (prevTag === '/nobr' || prevTag === 'wbr') {
-                if (/^\s/.test(text)) {
-                  var tagIndex = buffer.length - 1;
-                  while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
-                    tagIndex--;
+              if (options.processScripts && specialContentTags(currentTag)) {
+                subtasks.push(new AsyncTask(function(data, cb) {
+                  processScript(data.text, options, currentAttrs, function(error, result) {
+                    data.text = result;
+                    return cb(error, data);
+                  });
+                }));
+              }
+              if (isExecutableScript(currentTag, currentAttrs)) {
+                subtasks.push(new AsyncTask(function(data, cb) {
+                  var result = options.minifyJS(data.text, null, minifyJS_cb);
+                  if (typeof result !== 'undefined') {
+                    return minifyJS_cb(null, result);
                   }
-                  trimTrailingWhitespace(tagIndex - 1, 'br');
-                }
+
+                  var callbackCalled = false;
+                  function minifyJS_cb(error, result) {
+                    if (!callbackCalled) {
+                      callbackCalled = true;
+                      data.text = result;
+                      return cb(error, data);
+                    }
+                  }
+                }));
               }
-              else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
-                text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
+              if (isStyleSheet(currentTag, currentAttrs)) {
+                subtasks.push(new AsyncTask(function(data, cb) {
+                  var result = options.minifyCSS(data.text, null, minifyCSS_cb);
+                  if (typeof result !== 'undefined') {
+                    return minifyCSS_cb(null, result);
+                  }
+
+                  var callbackCalled = false;
+                  function minifyCSS_cb(error, result) {
+                    if (!callbackCalled) {
+                      callbackCalled = true;
+                      data.text = result;
+                      return cb(error, data);
+                    }
+                  }
+                }));
               }
-            }
-            if (prevTag || nextTag) {
-              text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
-            }
-            else {
-              text = collapseWhitespace(text, options, true, true);
-            }
-            if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
-              trimTrailingWhitespace(buffer.length - 1, nextTag);
-            }
-          }
-          if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
-            text = collapseWhitespace(text, options, false, false, true);
-          }
-        }
-        if (options.processScripts && specialContentTags(currentTag)) {
-          text = processScript(text, options, currentAttrs);
-        }
-        if (isExecutableScript(currentTag, currentAttrs)) {
-          asyncSubtasks.push(new AsyncTask(function(data, cb) {
-            var result = options.minifyJS(data, null, cb);
-            if (typeof result !== 'undefined') {
-              cb(null, result);
-            }
-          }));
-        }
-        if (isStyleSheet(currentTag, currentAttrs)) {
-          asyncSubtasks.push(new AsyncTask(function(data, cb) {
-            var result = options.minifyCSS(data, null, cb);
-            if (typeof result !== 'undefined') {
-              cb(null, result);
-            }
-          }));
-        }
-        if (options.removeOptionalTags && text) {
-          // <html> may be omitted if first thing inside is not comment
-          // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-          if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-            removeStartTag();
-          }
-          optionalStartTag = '';
-          // </html> or </body> may be omitted if not followed by comment
-          // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-          if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-            removeEndTag();
-          }
-          optionalEndTag = '';
-        }
-        charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-        if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-          // semi-colon can be omitted
-          // https://mathiasbynens.be/notes/ambiguous-ampersands
-          text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
-        }
-        if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-          text = text.replace(uidPattern, function(match, prefix, index) {
-            return ignoredCustomMarkupChunks[+index][0];
-          });
-        }
-        currentChars += text;
-        if (text) {
-          hasChars = true;
-        }
+              subtasks.push(
+                new AsyncTask(function(data, cb) {
+                  if (options.removeOptionalTags && data.text) {
+                    // <html> may be omitted if first thing inside is not comment
+                    // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+                    if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(data.text)) {
+                      insertionIndex -= removeStartTag(insertionIndex);
+                    }
+                    optionalStartTag = '';
+                    // </html> or </body> may be omitted if not followed by comment
+                    // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
+                    if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(data.text)) {
+                      insertionIndex -= removeEndTag(insertionIndex);
+                    }
+                    optionalEndTag = '';
+                  }
+                  charsPrevTag = /^\s*$/.test(data.text) ? data.prevTag : 'comment';
+                  if (options.decodeEntities && data.text && !specialContentTags(currentTag)) {
+                    // semi-colon can be omitted
+                    // https://mathiasbynens.be/notes/ambiguous-ampersands
+                    data.text = data.text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+                  }
+                  if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+                    data.text = data.text.replace(uidPattern, function(match, prefix, index) {
+                      return ignoredCustomMarkupChunks[+index][0];
+                    });
+                  }
+                  currentChars += data.text;
+                  if (data.text) {
+                    hasChars = true;
+                  }
 
-        // Nothing to do asynchronously?
-        if (asyncSubtasks.length === 0) {
-          buffer.push(text);
-          return;
-        }
+                  buffer.splice(insertionIndex++, 0, data.text);
+                  return cb(null, data);
+                })
+              );
+
+              // Run the subtasks.
+              new AsyncTaskGroup(subtasks, data).exec(cb);
+            }, {
+              text: text,
+              prevTag: prevTag,
+              nextTag: nextTag
+            })
+          );
+        },
+        comment: function(text, nonStandard) {
+          var placeholder = new Placeholder(); // Some unique reference.
+          buffer.push(placeholder);
+
+          asyncTasks.push(
+            new AsyncTask(function(data, cb) {
+              // The index of the placeholder may not be the same as where it
+              // was originally inserted at; therefore we need to search for it.
+              var insertionIndex = buffer.indexOf(placeholder);
 
-        var placeholder = new Placeholder(); // Some unique reference.
-        buffer.push(placeholder);
+              // Remove the placeholder.
+              buffer.splice(insertionIndex, 1);
 
-        // Create a new AsyncTaskGroup that will update the buffer once complete.
-        asyncTasks.push(
-          new AsyncTaskGroup(
-            asyncSubtasks,
-            text,
-            function(error, result) {
-              // Don't do anything if there is an error.
-              if (error) {
-                return;
+              var subtasks = [];
+              var prefix = data.nonStandard ? '<!' : '<!--';
+              var suffix = data.nonStandard ? '>' : '-->';
+              if (isConditionalComment(data.text)) {
+                subtasks.push(new AsyncTask(function(data, cb) {
+                  cleanConditionalComment(data.text, options, function(error, result) {
+                    data.text = prefix + result + suffix;
+                    return cb(error, data);
+                  });
+                }));
+              }
+              else if (options.removeComments) {
+                if (isIgnoredComment(data.text, options)) {
+                  data.text = '<!--' + data.text + '-->';
+                }
+                else {
+                  data.text = '';
+                }
+              }
+              else {
+                data.text = prefix + data.text + suffix;
               }
 
+              subtasks.push(new AsyncTask(function(data, cb) {
+                if (options.removeOptionalTags && data.text) {
+                  // preceding comments suppress tag omissions
+                  optionalStartTag = '';
+                  optionalEndTag = '';
+                }
+                buffer.splice(insertionIndex++, 0, data.text);
+                cb(null, data);
+              }));
+
+              // Run the subtasks.
+              new AsyncTaskGroup(subtasks, data).exec(cb);
+            }, {
+              text: text,
+              nonStandard: nonStandard
+            })
+          );
+        },
+        doctype: function(doctype) {
+          var placeholder = new Placeholder(); // Some unique reference.
+          buffer.push(placeholder);
+
+          asyncTasks.push(
+            new AsyncTask(function(data, cb) {
               // The index of the placeholder may not be the same as where it
               // was originally inserted at; therefore we need to search for it.
-              buffer[buffer.indexOf(placeholder)] = result;
-            }
-          )
-        );
-      },
-      comment: function(text, nonStandard) {
-        var prefix = nonStandard ? '<!' : '<!--';
-        var suffix = nonStandard ? '>' : '-->';
-        if (isConditionalComment(text)) {
-          text = prefix + cleanConditionalComment(text, options) + suffix;
-        }
-        else if (options.removeComments) {
-          if (isIgnoredComment(text, options)) {
-            text = '<!--' + text + '-->';
-          }
-          else {
-            text = '';
-          }
-        }
-        else {
-          text = prefix + text + suffix;
-        }
-        if (options.removeOptionalTags && text) {
-          // preceding comments suppress tag omissions
-          optionalStartTag = '';
-          optionalEndTag = '';
-        }
-        buffer.push(text);
-      },
-      doctype: function(doctype) {
-        buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
-      },
-      customAttrAssign: options.customAttrAssign,
-      customAttrSurround: options.customAttrSurround
-    });
-  }
-  catch (error) {
-    if (hasCallback) {
-      cb(error);
-      return;
+              var insertionIndex = buffer.indexOf(placeholder);
+
+              // Remove the placeholder.
+              buffer.splice(insertionIndex, 1);
+
+              buffer.splice(insertionIndex++, 0, options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(data.doctype));
+              return cb(null, data);
+            }, {
+              doctype: doctype
+            })
+          );
+        },
+        customAttrAssign: options.customAttrAssign,
+        customAttrSurround: options.customAttrSurround
+      });
+
+      return cb();
     }
-    throw error;
-  }
+    catch (error) {
+      return cb(error);
+    }
+  }));
 
   function finalize() {
     if (options.removeOptionalTags) {
@@ -1482,17 +1583,12 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  // Sync execution?
-  if (!hasCallback) {
-    return finalize();
-  }
-
   function callCallBack() {
     try {
-      cb(null, finalize());
+      return cb(null, finalize());
     }
     catch (error) {
-      cb(error);
+      return cb(error);
     }
   }
 
@@ -1501,26 +1597,13 @@ function minify(value, options, partialMarkup, cb) {
     return callCallBack();
   }
 
-  var asyncTasksCallbackCalled = false;
-  function onAsyncTasksComplete(error) {
-    // If an error occurs immediately call the callback.
-    // If other tasks complete afterwards, ignore them.
-    if (!asyncTasksCallbackCalled) {
+  new AsyncTaskGroup(asyncTasks)
+    .exec(function(error) {
       if (error) {
-        cb(error);
-        asyncTasksCallbackCalled = true;
-        return;
-      }
-      if (++asyncTasksComplete === asyncTasks.length) {
-        return callCallBack();
+        return cb(error);
       }
-    }
-  }
-
-  // Execute all the async tasks.
-  for (var i = 0; i < asyncTasks.length; i++) {
-    asyncTasks[i].exec(onAsyncTasksComplete);
-  }
+      return callCallBack();
+    });
   return;
 }
 
@@ -1569,16 +1652,14 @@ exports.minify = function(value, options, cb) {
   minify(value, options, false, function(error, result) {
     if (error) {
       if (hasCallback) {
-        cb(error);
-        return;
+        return cb(error);
       }
       throw error;
     }
 
     options.log('minified in: ' + (Date.now() - start) + 'ms');
     if (hasCallback) {
-      cb(null, result);
-      return;
+      return cb(null, result);
     }
     minified = result;
   });

From 706702751fae74e8de3613ac91866894d220ef2f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 19 Apr 2018 18:52:05 +1200
Subject: [PATCH 31/66] squashTrailingWhitespace now uses indexBound.

---
 src/htmlminifier.js | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 81b7f955..6f53a789 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1065,10 +1065,14 @@ function minify(value, options, partialMarkup, cb) {
   // look for trailing whitespaces from previously processed text
   // which may not be trimmed due to a following comment or an empty
   // element which has now been removed
-  function squashTrailingWhitespace(nextTag) {
-    var charsIndex = buffer.length - 1;
-    if (buffer.length > 1) {
-      var item = buffer[buffer.length - 1];
+  function squashTrailingWhitespace(nextTag, indexBound) {
+    if (typeof indexBound === 'undefined') {
+      indexBound = buffer.length;
+    }
+
+    var charsIndex = indexBound - 1;
+    if (indexBound > 1) {
+      var item = buffer[indexBound - 1];
       if (/^(?:<!|$)/.test(item) && item.indexOf(uidIgnore) === -1) {
         charsIndex--;
       }
@@ -1138,7 +1142,7 @@ function minify(value, options, partialMarkup, cb) {
               // set whitespace flags for nested tags (eg. <code> within a <pre>)
               if (options.collapseWhitespace) {
                 if (!stackNoTrimWhitespace.length) {
-                  squashTrailingWhitespace(data.tag);
+                  squashTrailingWhitespace(data.tag, insertionIndex);
                 }
                 if (!data.unary) {
                   if (!_canTrimWhitespace(data.tag, data.attrs) || stackNoTrimWhitespace.length) {
@@ -1241,7 +1245,7 @@ function minify(value, options, partialMarkup, cb) {
                   }
                 }
                 else {
-                  squashTrailingWhitespace('/' + data.tag);
+                  squashTrailingWhitespace('/' + data.tag, insertionIndex);
                 }
                 if (stackNoCollapseWhitespace.length &&
                   data.tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {

From 690f85edc58d9602e5e542d31d57449d50f31917 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 13:22:39 +1200
Subject: [PATCH 32/66] Fixed issue with bad error reporting when the minify
 function never calls it's callback.

---
 tests/minifier.js | 1802 +++++++++++++++++++++++----------------------
 1 file changed, 916 insertions(+), 886 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index df3ec678..fa50f2b5 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -7,7 +7,7 @@ if (typeof minify === 'undefined') {
 }
 
 /**
- * Test the minify function both synchronously and asynchronously.
+ * Test the minify function synchronously, both with a callback and without.
  *
  * @param {QUnit.assert} assert
  * @param {string} input
@@ -15,7 +15,7 @@ if (typeof minify === 'undefined') {
  * @param {string} output
  * @param {string} [description]
  */
-function test_minify(assert, input, options, output, description) {
+function test_minify_sync(assert, input, options, output, description) {
   // Remove optional options parameter if it is not given.
   if (typeof options === 'string') {
     description = output;
@@ -28,10 +28,12 @@ function test_minify(assert, input, options, output, description) {
     description = input;
   }
 
-  // Synchronously test.
-  assert.equal(minify(input, options), output, 'Synchronous Test: ' + description);
+  var descriptionPrefix = 'Synchronous Standard Test: ';
 
-  // Asynchronously test setup.
+  // Standard test.
+  assert.equal(minify(input, options), output, descriptionPrefix + description);
+
+  // Callback setup.
   if (options) {
     // Convert `minifyJS` to use a callback.
     if (typeof options.minifyJS === 'function') {
@@ -48,26 +50,39 @@ function test_minify(assert, input, options, output, description) {
       };
     }
   }
+
+  descriptionPrefix = 'Synchronous Callback Test: ';
   var done = assert.async();
+  var callbackTestFinished = false;
 
-  // Asynchronously test.
+  // Callback test.
   assert.notOk(minify(input, options, function(error, result) {
-    // Error should be null
-    if (error !== null) {
-      if (error instanceof Error) {
-        assert.equal(error, null, 'Asynchronous Test: An error occurred - stack trace:\n' + error.stack);
-      }
-      else {
-        assert.ok(false, 'Asynchronous Test: Something that\'s not of type Error was returned as an error.');
+    if (!callbackTestFinished) {
+      // Error should be null
+      if (error !== null) {
+        if (error instanceof Error) {
+          assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
+        }
+        else {
+          assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
+        }
       }
+      assert.equal(result, output, descriptionPrefix + description);
+      callbackTestFinished = true;
+      done();
     }
-    assert.equal(result, output, 'Asynchronous Test: ' + description);
-    done();
   }));
+
+  // If callback test didn't finish synchronously.
+  if (!callbackTestFinished) {
+    assert.ok(false, descriptionPrefix + 'Didn\'t finish synchronously.');
+    callbackTestFinished = true;
+    done();
+  }
 }
 
 /**
- * Test the minify function both synchronously and asynchronously for an expected error.
+ * Test the minify function synchronously for an expected error, both with a callback and without.
  *
  * @param {QUnit.assert} assert
  * @param {string} input
@@ -75,7 +90,7 @@ function test_minify(assert, input, options, output, description) {
  * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
  * @param {string} [description]
  */
-function test_minify_error(assert, input, options, errorMatcher, description) {
+function test_minify_sync_error(assert, input, options, errorMatcher, description) {
   // Remove optional errorMatcher parameter if it is not given.
   if (typeof errorMatcher === 'string') {
     description = errorMatcher;
@@ -87,24 +102,39 @@ function test_minify_error(assert, input, options, errorMatcher, description) {
     description = input;
   }
 
-  // Synchronously test.
-  assert.throws(function() { minify(input, options); }, errorMatcher, 'Synchronous Test: ' + description);
+  var descriptionPrefix = 'Synchronous Standard Test: ';
+
+  // Standard test.
+  assert.throws(function() { minify(input, options); }, errorMatcher, descriptionPrefix + description);
 
-  // Asynchronously test.
+  descriptionPrefix = 'Synchronous Callback Test: ';
   var done = assert.async();
+  var callbackTestFinished = false;
+
+  // Callback test.
   assert.notOk(minify(input, options, function(error, result) {
-    if (error === null) {
-      assert.ok(false, 'Asynchronous Test: An error should have occurred.');
-    }
-    else if (error instanceof Error) {
-      assert.throws(function() { throw error; }, errorMatcher, 'Asynchronous Test: ' + description);
-    }
-    else {
-      assert.ok(false, 'Asynchronous Test: Something that\'s not of type Error was returned as an error.');
+    if (!callbackTestFinished) {
+      if (error === null) {
+        assert.ok(false, descriptionPrefix + 'An error should have occurred.');
+      }
+      else if (error instanceof Error) {
+        assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
+      }
+      else {
+        assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
+      }
+      assert.notOk(result);
+      callbackTestFinished = true;
+      done();
     }
-    assert.notOk(result);
-    done();
   }));
+
+  // If callback test didn't finish synchronously.
+  if (!callbackTestFinished) {
+    assert.ok(false, descriptionPrefix + 'Didn\'t finish synchronously.');
+    callbackTestFinished = true;
+    done();
+  }
 }
 
 QUnit.test('`minifiy` exists', function(assert) {
@@ -114,85 +144,85 @@ QUnit.test('`minifiy` exists', function(assert) {
 QUnit.test('parsing non-trivial markup', function(assert) {
   var input, output;
 
-  test_minify(assert, '</td>', '');
-  test_minify(assert, '</p>', '<p></p>');
-  test_minify(assert, '</br>', '<br>');
-  test_minify(assert, '<br>x</br>', '<br>x<br>');
-  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
-  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
-  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
-  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
-  test_minify(assert, '<p foo.bar=baz>xxx</p>', '<p foo.bar="baz">xxx</p>');
+  test_minify_sync(assert, '</td>', '');
+  test_minify_sync(assert, '</p>', '<p></p>');
+  test_minify_sync(assert, '</br>', '<br>');
+  test_minify_sync(assert, '<br>x</br>', '<br>x<br>');
+  test_minify_sync(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify_sync(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify_sync(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify_sync(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify_sync(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
+  test_minify_sync(assert, '<p foo.bar=baz>xxx</p>', '<p foo.bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
 
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
-  test_minify(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')</script>');
-  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', '<script>alert(\'<!-- foo -->\')</script>');
-  test_minify(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')</script>');
+  test_minify_sync(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')</script>');
+  test_minify_sync(assert, '<script>alert(\'<!-- foo -->\')</script>', '<script>alert(\'<!-- foo -->\')</script>');
+  test_minify_sync(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')</script>');
 
-  test_minify(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
-  test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
-  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  test_minify(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
-  test_minify(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
-  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>',
+  test_minify_sync(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
+  test_minify_sync(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
+  test_minify_sync(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify_sync(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
+  test_minify_sync(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
+  test_minify_sync(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>',
     '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>'
   );
 
-  test_minify(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x"></ng-include>');
-  test_minify(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x"></ng:include>');
-  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>',
+  test_minify_sync(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x"></ng-include>');
+  test_minify_sync(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x"></ng:include>');
+  test_minify_sync(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>',
     '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>'
   );
 
   // will cause test to time-out if fail
   input = '<p>For more information, read <a href=https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685>this Stack Overflow answer</a>.</p>';
   output = '<p>For more information, read <a href="https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685">this Stack Overflow answer</a>.</p>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<html ⚡></html>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   input = '<h:ællæ></h:ællæ>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   input = '<$unicorn>';
-  test_minify_error(assert, input, {}, 'Invalid tag name');
+  test_minify_sync_error(assert, input, {}, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   // https://github.com/kangax/html-minifier/issues/41
-  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>',
+  test_minify_sync(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>',
     '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>'
   );
 
   // https://github.com/kangax/html-minifier/issues/40
-  test_minify(assert, '[\']["]', '[\']["]');
+  test_minify_sync(assert, '[\']["]', '[\']["]');
 
   // https://github.com/kangax/html-minifier/issues/21
-  test_minify(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html"><div>hey</div></a>');
+  test_minify_sync(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html"><div>hey</div></a>');
 
   // https://github.com/kangax/html-minifier/issues/17
-  test_minify(assert, ':) <a href="http://example.com">link</a>', ':) <a href="http://example.com">link</a>');
+  test_minify_sync(assert, ':) <a href="http://example.com">link</a>', ':) <a href="http://example.com">link</a>');
 
   // https://github.com/kangax/html-minifier/issues/169
-  test_minify(assert, '<a href>ok</a>', '<a href>ok</a>');
+  test_minify_sync(assert, '<a href>ok</a>', '<a href>ok</a>');
 
-  test_minify(assert, '<a onclick></a>', '<a onclick></a>');
+  test_minify_sync(assert, '<a onclick></a>', '<a onclick></a>');
 
   // https://github.com/kangax/html-minifier/issues/229
-  test_minify(assert, '<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>', '<custom-tag></custom-tag><div>Hello :)</div>');
+  test_minify_sync(assert, '<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>', '<custom-tag></custom-tag><div>Hello :)</div>');
 
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
-  test_minify(assert, input, input);
-  test_minify_error(
+  test_minify_sync(assert, input, input);
+  test_minify_sync_error(
     assert,
     '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>',
     {},
@@ -207,8 +237,8 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-model-options="{ debounce: 1000 }"' +
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
-  test_minify(assert, input, input);
-  test_minify_error(
+  test_minify_sync(assert, input, input);
+  test_minify_sync_error(
     assert,
     '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
       ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
@@ -224,18 +254,18 @@ QUnit.test('parsing non-trivial markup', function(assert) {
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
   output = '<br a="\u00A0"b="\u00A0"c="\u00A0">';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     decodeEntities: true,
     removeTagWhitespace: true,
   }, output);
   output = '<br a=\u00A0 b=\u00A0 c=\u00A0>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     decodeEntities: true,
     removeAttributeQuotes: true
   }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     decodeEntities: true,
     removeAttributeQuotes: true,
     removeTagWhitespace: true,
@@ -244,46 +274,46 @@ QUnit.test('parsing non-trivial markup', function(assert) {
 
 QUnit.test('options', function(assert) {
   var input = '<p>blah<span>blah 2<span>blah 3</span></span></p>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {}, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {}, input);
 });
 
 QUnit.test('case normalization', function(assert) {
-  test_minify(assert, '<P>foo</p>', '<p>foo</p>');
-  test_minify(assert, '<DIV>boo</DIV>', '<div>boo</div>');
-  test_minify(assert, '<DIV title="moo">boo</DiV>', '<div title="moo">boo</div>');
-  test_minify(assert, '<DIV TITLE="blah">boo</DIV>', '<div title="blah">boo</div>');
-  test_minify(assert, '<DIV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
-  test_minify(assert, '<DiV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify_sync(assert, '<P>foo</p>', '<p>foo</p>');
+  test_minify_sync(assert, '<DIV>boo</DIV>', '<div>boo</div>');
+  test_minify_sync(assert, '<DIV title="moo">boo</DiV>', '<div title="moo">boo</div>');
+  test_minify_sync(assert, '<DIV TITLE="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify_sync(assert, '<DIV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify_sync(assert, '<DiV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
 });
 
 QUnit.test('space normalization between attributes', function(assert) {
-  test_minify(assert, '<p title="bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify(assert, '<img src="test"/>', '<img src="test">');
-  test_minify(assert, '<p title = "bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify(assert, '<p title\n\n\t  =\n     "bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify(assert, '<img src="test" \n\t />', '<img src="test">');
-  test_minify(assert, '<input title="bar"       id="boo"    value="hello world">', '<input title="bar" id="boo" value="hello world">');
+  test_minify_sync(assert, '<p title="bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify_sync(assert, '<img src="test"/>', '<img src="test">');
+  test_minify_sync(assert, '<p title = "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify_sync(assert, '<p title\n\n\t  =\n     "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify_sync(assert, '<img src="test" \n\t />', '<img src="test">');
+  test_minify_sync(assert, '<input title="bar"       id="boo"    value="hello world">', '<input title="bar" id="boo" value="hello world">');
 });
 
 QUnit.test('space normalization around text', function(assert) {
   var input, output;
   input = '   <p>blah</p>\n\n\n   ';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<p>blah</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   output = ' <p>blah</p> ';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
   output = '<p>blah</p>\n';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
   output = ' <p>blah</p>\n';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
@@ -293,43 +323,43 @@ QUnit.test('space normalization around text', function(assert) {
     'mark', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup',
     'time', 'tt', 'u', 'var'
   ].forEach(function(el) {
-    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
-    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
-    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
-    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
-    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
-    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
+    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
+    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
+    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
+    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
+    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
   });
   // Don't trim whitespace around element, but do trim within
   [
     'bdi', 'bdo', 'button', 'cite', 'code', 'dfn', 'math', 'q', 'rt', 'rtc', 'ruby', 'svg'
   ].forEach(function(el) {
-    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
+    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
+    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
+    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
   });
   [
     ['<span> foo </span>', '<span>foo</span>'],
@@ -355,36 +385,36 @@ QUnit.test('space normalization around text', function(assert) {
     ['a <nobr> b</nobr> c', 'a <nobr>b</nobr> c'],
     ['a <nobr> b </nobr> c', 'a <nobr>b</nobr> c']
   ].forEach(function(inputs) {
-    test_minify(assert, inputs[0], {
+    test_minify_sync(assert, inputs[0], {
       collapseWhitespace: true,
       conservativeCollapse: true
     }, inputs[0], inputs[0]);
-    test_minify(assert, inputs[0], { collapseWhitespace: true }, inputs[1], inputs[0]);
+    test_minify_sync(assert, inputs[0], { collapseWhitespace: true }, inputs[1], inputs[0]);
     var input = '<div>' + inputs[0] + '</div>';
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
     }, input, input);
     var output = '<div>' + inputs[1] + '</div>';
-    test_minify(assert, input, { collapseWhitespace: true }, output, input);
+    test_minify_sync(assert, input, { collapseWhitespace: true }, output, input);
   });
-  test_minify(assert, '<p>foo <img> bar</p>', { collapseWhitespace: true }, '<p>foo <img> bar</p>');
-  test_minify(assert, '<p>foo<img>bar</p>', { collapseWhitespace: true }, '<p>foo<img>bar</p>');
-  test_minify(assert, '<p>foo <img>bar</p>', { collapseWhitespace: true }, '<p>foo <img>bar</p>');
-  test_minify(assert, '<p>foo<img> bar</p>', { collapseWhitespace: true }, '<p>foo<img> bar</p>');
-  test_minify(assert, '<p>foo <wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
-  test_minify(assert, '<p>foo<wbr>bar</p>', { collapseWhitespace: true }, '<p>foo<wbr>bar</p>');
-  test_minify(assert, '<p>foo <wbr>bar</p>', { collapseWhitespace: true }, '<p>foo <wbr>bar</p>');
-  test_minify(assert, '<p>foo<wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
-  test_minify(assert, '<p>foo <wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
-  test_minify(assert, '<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo="">bar</p>');
-  test_minify(assert, '<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo <wbr baz moo="">bar</p>');
-  test_minify(assert, '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
-  test_minify(assert, '<p>  <a href="#">  <code>foo</code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify(assert, '<p><a href="#"><code>foo  </code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify(assert, '<p>  <a href="#">  <code>   foo</code></a> bar   </p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify(assert, '<div> Empty <!-- or --> not </div>', { collapseWhitespace: true }, '<div>Empty<!-- or --> not</div>');
-  test_minify(assert, '<div> a <input><!-- b --> c </div>', {
+  test_minify_sync(assert, '<p>foo <img> bar</p>', { collapseWhitespace: true }, '<p>foo <img> bar</p>');
+  test_minify_sync(assert, '<p>foo<img>bar</p>', { collapseWhitespace: true }, '<p>foo<img>bar</p>');
+  test_minify_sync(assert, '<p>foo <img>bar</p>', { collapseWhitespace: true }, '<p>foo <img>bar</p>');
+  test_minify_sync(assert, '<p>foo<img> bar</p>', { collapseWhitespace: true }, '<p>foo<img> bar</p>');
+  test_minify_sync(assert, '<p>foo <wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
+  test_minify_sync(assert, '<p>foo<wbr>bar</p>', { collapseWhitespace: true }, '<p>foo<wbr>bar</p>');
+  test_minify_sync(assert, '<p>foo <wbr>bar</p>', { collapseWhitespace: true }, '<p>foo <wbr>bar</p>');
+  test_minify_sync(assert, '<p>foo<wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
+  test_minify_sync(assert, '<p>foo <wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
+  test_minify_sync(assert, '<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo="">bar</p>');
+  test_minify_sync(assert, '<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo <wbr baz moo="">bar</p>');
+  test_minify_sync(assert, '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
+  test_minify_sync(assert, '<p>  <a href="#">  <code>foo</code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify_sync(assert, '<p><a href="#"><code>foo  </code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify_sync(assert, '<p>  <a href="#">  <code>   foo</code></a> bar   </p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
+  test_minify_sync(assert, '<div> Empty <!-- or --> not </div>', { collapseWhitespace: true }, '<div>Empty<!-- or --> not</div>');
+  test_minify_sync(assert, '<div> a <input><!-- b --> c </div>', {
     collapseWhitespace: true,
     removeComments: true
   }, '<div>a <input> c</div>');
@@ -399,29 +429,29 @@ QUnit.test('space normalization around text', function(assert) {
     ' a <? b ?> c<!-- d --> ',
     ' a <? b ?> c <!-- d -->'
   ].forEach(function(input) {
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
     }, input, input);
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       removeComments: true
     }, 'a <? b ?> c', input);
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
     }, ' a <? b ?> c ', input);
     input = '<p>' + input + '</p>';
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
     }, input, input);
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       removeComments: true
     }, '<p>a <? b ?> c</p>', input);
-    test_minify(assert, input, {
+    test_minify_sync(assert, input, {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
@@ -429,34 +459,34 @@ QUnit.test('space normalization around text', function(assert) {
   });
   input = '<li><i></i> <b></b> foo</li>';
   output = '<li><i></i> <b></b> foo</li>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<li><i> </i> <b></b> foo</li>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<li> <i></i> <b></b> foo</li>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<li><i></i> <b> </b> foo</li>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<li> <i> </i> <b> </b> foo</li>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<div> <a href="#"> <span> <b> foo </b> <i> bar </i> </span> </a> </div>';
   output = '<div><a href="#"><span><b>foo </b><i>bar</i></span></a></div>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<head> <!-- a --> <!-- b --><link> </head>';
   output = '<head><!-- a --><!-- b --><link></head>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<head> <!-- a --> <!-- b --> <!-- c --><link> </head>';
   output = '<head><!-- a --><!-- b --><!-- c --><link></head>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<p> foo\u00A0bar\nbaz  \u00A0\nmoo\t</p>';
   output = '<p>foo\u00A0bar baz \u00A0 moo</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<label> foo </label>\n' +
           '<input>\n' +
           '<object> bar </object>\n' +
           '<select> baz </select>\n' +
           '<textarea> moo </textarea>\n';
   output = '<label>foo</label> <input> <object>bar</object> <select>baz</select> <textarea> moo </textarea>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   input = '<pre>\n' +
           'foo\n' +
           '<br>\n' +
@@ -464,130 +494,130 @@ QUnit.test('space normalization around text', function(assert) {
           '</pre>\n' +
           'baz\n';
   output = '<pre>\nfoo\n<br>\nbar\n</pre>baz';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('types of whitespace that should always be preserved', function(assert) {
   // Hair space:
   var input = '<div>\u200afo\u200ao\u200a</div>';
-  test_minify(assert, input, { collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
 
   // Hair space passed as HTML entity:
   var inputWithEntities = '<div>&#8202;fo&#8202;o&#8202;</div>';
-  test_minify(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
+  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
 
   // Hair space passed as HTML entity, in decodeEntities:true mode:
-  test_minify(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
+  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
 
 
   // Non-breaking space:
   input = '<div>\xa0fo\xa0o\xa0</div>';
-  test_minify(assert, input, { collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
 
   // Non-breaking space passed as HTML entity:
   inputWithEntities = '<div>&nbsp;fo&nbsp;o&nbsp;</div>';
-  test_minify(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
+  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
 
   // Non-breaking space passed as HTML entity, in decodeEntities:true mode:
-  test_minify(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
+  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
 
   // Do not remove hair space when preserving line breaks between tags:
   input = '<p></p>\u200a\n<p></p>\n';
-  test_minify(assert, input, { collapseWhitespace: true, preserveLineBreaks: true }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true, preserveLineBreaks: true }, input);
 
   // Preserve hair space in attributes:
   input = '<p class="foo\u200abar"></p>';
-  test_minify(assert, input, { collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
 
   // Preserve hair space in class names when deduplicating and reordering:
   input = '<a class="0 1\u200a3 2 3"></a>';
-  test_minify(assert, input, { sortClassName: false }, input);
-  test_minify(assert, input, { sortClassName: true }, input);
+  test_minify_sync(assert, input, { sortClassName: false }, input);
+  test_minify_sync(assert, input, { sortClassName: true }, input);
 });
 
 QUnit.test('doctype normalization', function(assert) {
   var input;
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"\n    "http://www.w3.org/TR/html4/strict.dtd">';
-  test_minify(assert, input, { useShortDoctype: true }, '<!DOCTYPE html>');
+  test_minify_sync(assert, input, { useShortDoctype: true }, '<!DOCTYPE html>');
 
   input = '<!DOCTYPE html>';
-  test_minify(assert, input, { useShortDoctype: true }, input);
+  test_minify_sync(assert, input, { useShortDoctype: true }, input);
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">';
-  test_minify(assert, input, { useShortDoctype: false }, input);
+  test_minify_sync(assert, input, { useShortDoctype: false }, input);
 });
 
 QUnit.test('removing comments', function(assert) {
   var input;
 
   input = '<!-- test -->';
-  test_minify(assert, input, { removeComments: true }, '');
+  test_minify_sync(assert, input, { removeComments: true }, '');
 
   input = '<!-- foo --><div>baz</div><!-- bar\n\n moo -->';
-  test_minify(assert, input, { removeComments: true }, '<div>baz</div>');
-  test_minify(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: true }, '<div>baz</div>');
+  test_minify_sync(assert, input, { removeComments: false }, input);
 
   input = '<p title="<!-- comment in attribute -->">foo</p>';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<script><!-- alert(1) --></script>';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<STYLE><!-- alert(1) --></STYLE>';
-  test_minify(assert, input, { removeComments: true }, '<style><!-- alert(1) --></style>');
+  test_minify_sync(assert, input, { removeComments: true }, '<style><!-- alert(1) --></style>');
 });
 
 QUnit.test('ignoring comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: false }, input);
 
   input = '<!--! foo --><div>baz</div><!--! bar\n\n moo -->';
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: false }, input);
 
   input = '<!--! foo --><div>baz</div><!-- bar\n\n moo -->';
-  test_minify(assert, input, { removeComments: true }, '<!--! foo --><div>baz</div>');
-  test_minify(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: true }, '<!--! foo --><div>baz</div>');
+  test_minify_sync(assert, input, { removeComments: false }, input);
 
   input = '<!-- ! test -->';
-  test_minify(assert, input, { removeComments: true }, '');
-  test_minify(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: true }, '');
+  test_minify_sync(assert, input, { removeComments: false }, input);
 
   input = '<div>\n\n   \t<div><div>\n\n<p>\n\n<!--!      \t\n\nbar\n\n moo         -->      \n\n</p>\n\n        </div>  </div></div>';
   output = '<div><div><div><p><!--!      \t\n\nbar\n\n moo         --></p></div></div></div>';
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, output);
-  test_minify(assert, input, { removeComments: false }, input);
-  test_minify(assert, input, { removeComments: false, collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify_sync(assert, input, { removeComments: false, collapseWhitespace: true }, output);
 
   input = '<p rel="<!-- comment in attribute -->" title="<!--! ignored comment in attribute -->">foo</p>';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 });
-
+// FIXME:
 QUnit.test('conditional comments', function(assert) {
   var input, output;
 
   input = '<![if IE 5]>test<![endif]>';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 6]>test<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 7]>-->test<!--<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<!--[if IE 8]><!-->test<!--<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<!--[if lt IE 5.5]>test<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<!--[if (gt IE 5)&(lt IE 7)]>test<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 
   input = '<html>\n' +
           '  <head>\n' +
@@ -605,7 +635,7 @@ QUnit.test('conditional comments', function(assert) {
            '        alert("ie8!");\n' +
            '      </script>\n' +
            '    <![endif]-->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
@@ -613,7 +643,7 @@ QUnit.test('conditional comments', function(assert) {
     removeScriptTypeAttributes: true
   }, output);
   output = '<head><!--[if lte IE 8]><script>alert("ie8!")</script><![endif]-->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
@@ -648,11 +678,11 @@ QUnit.test('conditional comments', function(assert) {
            '<!--[if IE 8]><html class="no-js ie8"><![endif]-->' +
            '<!--[if gt IE 8]><!--><html class="no-js"><!--<![endif]-->' +
            '<title>Document</title></head><body></body></html>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true
   }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
@@ -665,16 +695,16 @@ QUnit.test('collapsing space in conditional comments', function(assert) {
   input = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
             '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css" />\n\t' +
           '<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, input);
   output = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">\n\t' +
            '<![endif]-->';
-  test_minify(assert, input, { removeComments: true, processConditionalComments: true }, output);
+  test_minify_sync(assert, input, { removeComments: true, processConditionalComments: true }, output);
   output = '<!--[if IE 7]>' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">' +
            '<![endif]-->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
@@ -683,12 +713,12 @@ QUnit.test('collapsing space in conditional comments', function(assert) {
   input = '<!--[if lte IE 6]>\n    \n   \n\n\n\t' +
             '<p title=" sigificant     whitespace   ">blah blah</p>' +
           '<![endif]-->';
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, input);
   output = '<!--[if lte IE 6]>' +
              '<p title=" sigificant     whitespace   ">blah blah</p>' +
            '<![endif]-->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
@@ -699,181 +729,181 @@ QUnit.test('remove comments from scripts', function(assert) {
   var input, output;
 
   input = '<script><!--\nalert(1);\n--></script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--alert(2);--></script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--alert(3);\n--></script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script><!--\nalert(4);--></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><!--alert(5);\nalert(6);\nalert(7);--></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><!--alert(8)</script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->"); -->\n\n   </script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->");\n -->\n\n   </script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script type="text/javascript">alert("--\\x3e")</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script> //   <!--   \n  alert(1)   //  --> </script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/html">\n<div>\n</div>\n<!-- aa -->\n</script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 });
 
 QUnit.test('remove comments from styles', function(assert) {
   var input, output;
 
   input = '<style><!--\np.a{background:red}\n--></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.a{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.b{background:red}--></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.b{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.c{background:red}\n--></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.c{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--\np.d{background:red}--></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.d{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><!--p.e{background:red}\np.f{background:red}\np.g{background:red}--></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.e{background:red}p.f{background:red}p.g{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style>p.h{background:red}<!--\np.i{background:red}\n-->p.j{background:red}</style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.h{background:red}p.i{background:red}p.j{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/css"><!-- p { color: red } --></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style type="text/css">p{color:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/css">p::before { content: "<!--" }</style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style type="text/css">p::before{content:"<!--"}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/html">\n<div>\n</div>\n<!-- aa -->\n</style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: true }, input);
 });
 
 QUnit.test('remove CDATA sections from scripts/styles', function(assert) {
   var input, output;
 
   input = '<script><![CDATA[\nalert(1)\n]]></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(2)]]></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(3)\n]]></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[\nalert(4)]]></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script><![CDATA[alert(5)\nalert(6)\nalert(7)]]></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script>/*<![CDATA[*/alert(8)/*]]>*/</script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script>alert(8)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script>//<![CDATA[\nalert(9)\n//]]></script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script>alert(9)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript"> /* \n\t  <![CDATA[  */ alert(10) /*  ]]>  */ \n </script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script type="text/javascript">alert(10)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script>\n\n//<![CDATA[\nalert(11)//]]></script>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<script>alert(11)</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<style><![CDATA[\np.a{background:red}\n]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style></style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.b{background:red}]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style></style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.c{background:red}\n]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style></style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[\np.d{background:red}]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style></style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style><![CDATA[p.e{background:red}\np.f{background:red}\np.g{background:red}]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.f{background:red}p.g{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style>p.h{background:red}<![CDATA[\np.i{background:red}\n]]>p.j{background:red}</style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p.h{background:red}]]>p.j{background:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style>/* <![CDATA[ */p { color: red } // ]]></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p{color:red}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style type="text/html">\n<div>\n</div>\n<![CDATA[ aa ]]>\n</style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: true }, input);
 });
 
 QUnit.test('custom processors', function(assert) {
@@ -884,125 +914,125 @@ QUnit.test('custom processors', function(assert) {
   }
 
   input = '<style>\n.foo { font: 12pt "bar" } </style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: null }, input);
-  test_minify(assert, input, { minifyCSS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: null }, input);
+  test_minify_sync(assert, input, { minifyCSS: false }, input);
   output = '<style>Normal CSS</style>';
-  test_minify(assert, input, { minifyCSS: css }, output);
+  test_minify_sync(assert, input, { minifyCSS: css }, output);
 
   input = '<p style="font: 12pt \'bar\'"></p>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: null }, input);
-  test_minify(assert, input, { minifyCSS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: null }, input);
+  test_minify_sync(assert, input, { minifyCSS: false }, input);
   output = '<p style="inline CSS"></p>';
-  test_minify(assert, input, { minifyCSS: css }, output);
+  test_minify_sync(assert, input, { minifyCSS: css }, output);
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: null }, input);
-  test_minify(assert, input, { minifyCSS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: null }, input);
+  test_minify_sync(assert, input, { minifyCSS: false }, input);
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="media CSS">';
-  test_minify(assert, input, { minifyCSS: css }, output);
+  test_minify_sync(assert, input, { minifyCSS: css }, output);
 
   input = '<style media="(max-width: 737px)"></style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: null }, input);
-  test_minify(assert, input, { minifyCSS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: null }, input);
+  test_minify_sync(assert, input, { minifyCSS: false }, input);
   output = '<style media="media CSS">Normal CSS</style>';
-  test_minify(assert, input, { minifyCSS: css }, output);
+  test_minify_sync(assert, input, { minifyCSS: css }, output);
 
   function js(text, inline) {
     return inline ? 'Inline JS' : 'Normal JS';
   }
 
   input = '<script>\nalert(1); </script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: null }, input);
-  test_minify(assert, input, { minifyJS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: null }, input);
+  test_minify_sync(assert, input, { minifyJS: false }, input);
   output = '<script>Normal JS</script>';
-  test_minify(assert, input, { minifyJS: js }, output);
+  test_minify_sync(assert, input, { minifyJS: js }, output);
 
   input = '<p onload="alert(1);"></p>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyJS: null }, input);
-  test_minify(assert, input, { minifyJS: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyJS: null }, input);
+  test_minify_sync(assert, input, { minifyJS: false }, input);
   output = '<p onload="Inline JS"></p>';
-  test_minify(assert, input, { minifyJS: js }, output);
+  test_minify_sync(assert, input, { minifyJS: js }, output);
 
   function url() {
     return 'URL';
   }
 
   input = '<a href="http://site.com/foo">bar</a>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyURLs: null }, input);
-  test_minify(assert, input, { minifyURLs: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyURLs: null }, input);
+  test_minify_sync(assert, input, { minifyURLs: false }, input);
   output = '<a href="URL">bar</a>';
-  test_minify(assert, input, { minifyURLs: url }, output);
+  test_minify_sync(assert, input, { minifyURLs: url }, output);
 
   input = '<style>\n.foo { background: url("http://site.com/foo") } </style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyURLs: null }, input);
-  test_minify(assert, input, { minifyURLs: false }, input);
-  test_minify(assert, input, { minifyURLs: url }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyURLs: null }, input);
+  test_minify_sync(assert, input, { minifyURLs: false }, input);
+  test_minify_sync(assert, input, { minifyURLs: url }, input);
   output = '<style>.foo{background:url(URL)}</style>';
-  test_minify(assert, input, { minifyCSS: true, minifyURLs: url }, output);
+  test_minify_sync(assert, input, { minifyCSS: true, minifyURLs: url }, output);
 });
 
 QUnit.test('empty attributes', function(assert) {
   var input;
 
   input = '<p id="" class="" STYLE=" " title="\n" lang="" dir="">x</p>';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
 
   input = '<p onclick=""   ondblclick=" " onmousedown="" ONMOUSEUP="" onmouseover=" " onmousemove="" onmouseout="" ' +
           'onkeypress=\n\n  "\n     " onkeydown=\n"" onkeyup\n="">x</p>';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
 
   input = '<input onfocus="" onblur="" onchange=" " value=" boo ">';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<input value=" boo ">');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<input value=" boo ">');
 
   input = '<input value="" name="foo">';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<input name="foo">');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<input name="foo">');
 
   input = '<img src="" alt="">';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<img src="" alt="">');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<img src="" alt="">');
 
   // preserve unrecognized attribute
   // remove recognized attrs with unspecified values
   input = '<div data-foo class id style title lang dir onfocus onblur onchange onclick ondblclick onmousedown onmouseup onmouseover onmousemove onmouseout onkeypress onkeydown onkeyup></div>';
-  test_minify(assert, input, { removeEmptyAttributes: true }, '<div data-foo></div>');
+  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<div data-foo></div>');
 
   // additional remove attributes
   input = '<img src="" alt="">';
-  test_minify(assert, input, { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } }, '<img alt="">');
+  test_minify_sync(assert, input, { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } }, '<img alt="">');
 });
 
 QUnit.test('cleaning class/style attributes', function(assert) {
   var input, output;
 
   input = '<p class=" foo bar  ">foo bar baz</p>';
-  test_minify(assert, input, '<p class="foo bar">foo bar baz</p>');
+  test_minify_sync(assert, input, '<p class="foo bar">foo bar baz</p>');
 
   input = '<p class=" foo      ">foo bar baz</p>';
-  test_minify(assert, input, '<p class="foo">foo bar baz</p>');
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<p class=foo>foo bar baz</p>');
+  test_minify_sync(assert, input, '<p class="foo">foo bar baz</p>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p class=foo>foo bar baz</p>');
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n   ">foo bar baz</p>';
   output = '<p class="foo">foo bar baz</p>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n  class1 class-23 ">foo bar baz</p>';
   output = '<p class="foo class1 class-23">foo bar baz</p>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<p style="    color: red; background-color: rgb(100, 75, 200);  "></p>';
   output = '<p style="color: red; background-color: rgb(100, 75, 200);"></p>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<p style="font-weight: bold  ; "></p>';
   output = '<p style="font-weight: bold;"></p>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('cleaning URI-based attributes', function(assert) {
@@ -1010,41 +1040,41 @@ QUnit.test('cleaning URI-based attributes', function(assert) {
 
   input = '<a href="   http://example.com  ">x</a>';
   output = '<a href="http://example.com">x</a>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<a href="  \t\t  \n \t  ">x</a>';
   output = '<a href="">x</a>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<img src="   http://example.com  " title="bleh   " longdesc="  http://example.com/longdesc \n\n   \t ">';
   output = '<img src="http://example.com" title="bleh   " longdesc="http://example.com/longdesc">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<img src="" usemap="   http://example.com  ">';
   output = '<img src="" usemap="http://example.com">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<form action="  somePath/someSubPath/someAction?foo=bar&baz=qux     "></form>';
   output = '<form action="somePath/someSubPath/someAction?foo=bar&baz=qux"></form>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<BLOCKQUOTE cite=" \n\n\n http://www.mycom.com/tolkien/twotowers.html     "><P>foobar</P></BLOCKQUOTE>';
   output = '<blockquote cite="http://www.mycom.com/tolkien/twotowers.html"><p>foobar</p></blockquote>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<head profile="       http://gmpg.org/xfn/11    "></head>';
   output = '<head profile="http://gmpg.org/xfn/11"></head>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<object codebase="   http://example.com  "></object>';
   output = '<object codebase="http://example.com"></object>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<span profile="   1, 2, 3  ">foo</span>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   input = '<div action="  foo-bar-baz ">blah</div>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 });
 
 QUnit.test('cleaning Number-based attributes', function(assert) {
@@ -1052,27 +1082,27 @@ QUnit.test('cleaning Number-based attributes', function(assert) {
 
   input = '<a href="#" tabindex="   1  ">x</a><button tabindex="   2  ">y</button>';
   output = '<a href="#" tabindex="1">x</a><button tabindex="2">y</button>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<input value="" maxlength="     5 ">';
   output = '<input value="" maxlength="5">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<select size="  10   \t\t "><option>x</option></select>';
   output = '<select size="10"><option>x</option></select>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<textarea rows="   20  " cols="  30      "></textarea>';
   output = '<textarea rows="20" cols="30"></textarea>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<COLGROUP span="   40  "><COL span="  39 "></COLGROUP>';
   output = '<colgroup span="40"><col span="39"></colgroup>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<tr><td colspan="    2   ">x</td><td rowspan="   3 "></td></tr>';
   output = '<tr><td colspan="2">x</td><td rowspan="3"></td></tr>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('cleaning other attributes', function(assert) {
@@ -1080,50 +1110,50 @@ QUnit.test('cleaning other attributes', function(assert) {
 
   input = '<a href="#" onclick="  window.prompt(\'boo\'); " onmouseover=" \n\n alert(123)  \t \n\t  ">blah</a>';
   output = '<a href="#" onclick="window.prompt(\'boo\');" onmouseover="alert(123)">blah</a>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</p></body>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;form method="get" ...>)', function(assert) {
   var input;
 
   input = '<form method="get">hello world</form>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<form>hello world</form>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<form>hello world</form>');
 
   input = '<form method="post">hello world</form>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<form method="post">hello world</form>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<form method="post">hello world</form>');
 });
 
 QUnit.test('removing redundant attributes (&lt;input type="text" ...>)', function(assert) {
   var input;
 
   input = '<input type="text">';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<input>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input>');
 
   input = '<input type="  TEXT  " value="foo">';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<input value="foo">');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input value="foo">');
 
   input = '<input type="checkbox">';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<input type="checkbox">');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input type="checkbox">');
 });
 
 QUnit.test('removing redundant attributes (&lt;a name="..." id="..." ...>)', function(assert) {
   var input;
 
   input = '<a id="foo" name="foo">blah</a>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<a id="foo">blah</a>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<a id="foo">blah</a>');
 
   input = '<input id="foo" name="foo">';
-  test_minify(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<a name="foo">blah</a>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<a href="..." name="  bar  " id="bar" >blah</a>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<a href="..." id="bar">blah</a>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<a href="..." id="bar">blah</a>');
 });
 
 QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)', function(assert) {
@@ -1131,125 +1161,125 @@ QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)'
 
   input = '<script type="text/javascript" charset="UTF-8">alert(222);</script>';
   output = '<script type="text/javascript">alert(222);</script>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
 
   input = '<script type="text/javascript" src="http://example.com" charset="UTF-8">alert(222);</script>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
 
   input = '<script CHARSET=" ... ">alert(222);</script>';
   output = '<script>alert(222);</script>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;... language="javascript" ...>)', function(assert) {
   var input;
 
   input = '<script language="Javascript">x=2,y=4</script>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
 
   input = '<script LANGUAGE = "  javaScript  ">x=2,y=4</script>';
-  test_minify(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
 });
 
 QUnit.test('removing redundant attributes (&lt;area shape="rect" ...>)', function(assert) {
   var input = '<area shape="rect" coords="696,25,958,47" href="#" title="foo">';
   var output = '<area coords="696,25,958,47" href="#" title="foo">';
-  test_minify(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;... = "javascript: ..." ...>)', function(assert) {
   var input;
 
   input = '<p onclick="javascript:alert(1)">x</p>';
-  test_minify(assert, input, '<p onclick="alert(1)">x</p>');
+  test_minify_sync(assert, input, '<p onclick="alert(1)">x</p>');
 
   input = '<p onclick="javascript:x">x</p>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<p onclick=x>x</p>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p onclick=x>x</p>');
 
   input = '<p onclick=" JavaScript: x">x</p>';
-  test_minify(assert, input, '<p onclick="x">x</p>');
+  test_minify_sync(assert, input, '<p onclick="x">x</p>');
 
   input = '<p title="javascript:(function() { /* some stuff here */ })()">x</p>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 });
 
 QUnit.test('removing javascript type attributes', function(assert) {
   var input, output;
 
   input = '<script type="">alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: false }, input);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: false }, input);
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="text/javascript">alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: false }, input);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: false }, input);
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<SCRIPT TYPE="  text/javascript ">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="application/javascript;version=1.8">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
 
   input = '<script type="text/vbscript">MsgBox("foo bar")</script>';
   output = '<script type="text/vbscript">MsgBox("foo bar")</script>';
-  test_minify(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
 });
 
 QUnit.test('removing type="text/css" attributes', function(assert) {
   var input, output;
 
   input = '<style type="">.foo { color: red }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: false }, input);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: false }, input);
   output = '<style>.foo { color: red }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<style type="text/css">.foo { color: red }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: false }, input);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: false }, input);
   output = '<style>.foo { color: red }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<STYLE TYPE = "  text/CSS ">body { font-size: 1.75em }</style>';
   output = '<style>body { font-size: 1.75em }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<style type="text/plain">.foo { background: green }</style>';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, input);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, input);
 
   input = '<link rel="stylesheet" type="text/css" href="http://example.com">';
   output = '<link rel="stylesheet" href="http://example.com">';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
 
   input = '<link rel="alternate" type="application/atom+xml" href="data.xml">';
-  test_minify(assert, input, { removeStyleLinkTypeAttributes: true }, input);
+  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, input);
 });
 
 QUnit.test('removing attribute quotes', function(assert) {
   var input;
 
   input = '<p title="blah" class="a23B-foo.bar_baz:qux" id="moo">foo</p>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
 
   input = '<input value="hello world">';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<input value="hello world">');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<input value="hello world">');
 
   input = '<a href="#" title="foo#bar">x</a>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<a href=# title=foo#bar>x</a>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a href=# title=foo#bar>x</a>');
 
   input = '<a href="http://example.com/" title="blah">\nfoo\n\n</a>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<a href=http://example.com/ title=blah>\nfoo\n\n</a>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a href=http://example.com/ title=blah>\nfoo\n\n</a>');
 
   input = '<a title="blah" href="http://example.com/">\nfoo\n\n</a>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<a title=blah href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a title=blah href=http://example.com/ >\nfoo\n\n</a>');
 
   input = '<a href="http://example.com/" title="">\nfoo\n\n</a>';
-  test_minify(assert, input, { removeAttributeQuotes: true, removeEmptyAttributes: true }, '<a href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true, removeEmptyAttributes: true }, '<a href=http://example.com/ >\nfoo\n\n</a>');
 
   input = '<p class=foo|bar:baz></p>';
-  test_minify(assert, input, { removeAttributeQuotes: true }, '<p class=foo|bar:baz></p>');
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p class=foo|bar:baz></p>');
 });
 
 QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
@@ -1261,10 +1291,10 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   input = '<input checked="checked">';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   // With multiple rules
   customAttrOptions = {
@@ -1275,16 +1305,16 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   input = '<input {{#unless value}}checked="checked"{{/unless}}>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   input = '<input {{#if value1}}data-attr="example" {{/if}}{{#unless value2}}checked="checked"{{/unless}}>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   input = '<input checked="checked">';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 
   // With multiple rules and richer options
   customAttrOptions = {
@@ -1297,13 +1327,13 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify(assert, input, customAttrOptions, '<input {{#if value}}checked{{/if}}>');
+  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value}}checked{{/if}}>');
 
   input = '<input {{#if value1}}checked="checked"{{/if}} {{#if value2}}data-attr="foo"{{/if}}/>';
-  test_minify(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>');
+  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>');
 
   customAttrOptions.keepClosingSlash = true;
-  test_minify(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>');
+  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>');
 });
 
 QUnit.test('preserving custom attribute-joining markup', function(assert) {
@@ -1313,9 +1343,9 @@ QUnit.test('preserving custom attribute-joining markup', function(assert) {
     customAttrAssign: [polymerConditionalAttributeJoin]
   };
   input = '<div flex?="{{mode != cover}}"></div>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
   input = '<div flex?="{{mode != cover}}" class="foo"></div>';
-  test_minify(assert, input, customAttrOptions, input);
+  test_minify_sync(assert, input, customAttrOptions, input);
 });
 
 QUnit.test('collapsing whitespace', function(assert) {
@@ -1323,37 +1353,37 @@ QUnit.test('collapsing whitespace', function(assert) {
 
   input = '<script type="text/javascript">  \n\t   alert(1) \n\n\n  \t </script>';
   output = '<script type="text/javascript">alert(1)</script>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo</p>    <p> bar</p>\n\n   \n\t\t  <div title="quz">baz  </div>';
   output = '<p>foo</p><p>bar</p><div title="quz">baz</div>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p> foo    bar</p>';
   output = '<p>foo bar</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo\nbar</p>';
   output = '<p>foo bar</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p> foo    <span>  blah     <i>   22</i>    </span> bar <img src=""></p>';
   output = '<p>foo <span>blah <i>22</i> </span>bar <img src=""></p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
   output = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<div><textarea></textarea>    </div>';
   output = '<div><textarea></textarea></div>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<div><pRe> $foo = "baz"; </pRe>    </div>';
   output = '<div><pre> $foo = "baz"; </pre></div>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
   output = '<div><pRe>$foo = "baz";</pRe></div>';
-  test_minify(assert, input, { collapseWhitespace: true, caseSensitive: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, caseSensitive: true }, output);
 
   input = '<script type="text/javascript">var = "hello";</script>\r\n\r\n\r\n' +
           '<style type="text/css">#foo { color: red;        }          </style>\r\n\r\n\r\n' +
@@ -1371,153 +1401,153 @@ QUnit.test('collapsing whitespace', function(assert) {
            '</div></div></div></div></div></div>' +
            '<pre>       \r\nxxxx</pre><span>x</span> <span>Hello</span> <b>billy</b> ' +
            '<input type="text"> <textarea></textarea><pre></pre>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<pre title="some title...">   hello     world </pre>';
   output = '<pre title="some title...">   hello     world </pre>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<pre title="some title..."><code>   hello     world </code></pre>';
   output = '<pre title="some title..."><code>   hello     world </code></pre>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<script>alert("foo     bar")    </script>';
   output = '<script>alert("foo     bar")</script>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<style>alert("foo     bar")    </style>';
   output = '<style>alert("foo     bar")</style>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('removing empty elements', function(assert) {
   var input, output;
 
-  test_minify(assert, '<p>x</p>', { removeEmptyElements: true }, '<p>x</p>');
-  test_minify(assert, '<p></p>', { removeEmptyElements: true }, '');
+  test_minify_sync(assert, '<p>x</p>', { removeEmptyElements: true }, '<p>x</p>');
+  test_minify_sync(assert, '<p></p>', { removeEmptyElements: true }, '');
 
   input = '<p>foo<span>bar</span><span></span></p>';
   output = '<p>foo<span>bar</span></p>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<a href="http://example/com" title="hello world"></a>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<iframe></iframe>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<iframe src="page.html"></iframe>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<iframe srcdoc="<h1>Foo</h1>"></iframe>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<video></video>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<video src="preview.ogg"></video>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<audio autoplay></audio>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<audio src="startup.mp3" autoplay></audio>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<object type="application/x-shockwave-flash"></object>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<object data="game.swf" type="application/x-shockwave-flash"></object>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<applet archive="game.zip" width="250" height="150"></applet>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<applet code="game.class" archive="game.zip" width="250" height="150"></applet>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<textarea cols="10" rows="10"></textarea>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<div>hello<span>world</span></div>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<p>x<span title="<" class="blah-moo"></span></p>';
   output = '<p>x</p>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<div>x<div>y <div>blah</div><div></div>foo</div>z</div>';
   output = '<div>x<div>y <div>blah</div>foo</div>z</div>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<img src="">';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
 
   input = '<p><!-- x --></p>';
   output = '';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
 
   input = '<script src="foo.js"></script>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
   input = '<script></script>';
-  test_minify(assert, input, { removeEmptyElements: true }, '');
+  test_minify_sync(assert, input, { removeEmptyElements: true }, '');
 
   input = '<div>after<span></span> </div>';
   output = '<div>after </div>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
   output = '<div>after</div>';
-  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>before <span></span></div>';
   output = '<div>before </div>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
   output = '<div>before</div>';
-  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>both <span></span> </div>';
   output = '<div>both  </div>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
   output = '<div>both</div>';
-  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>unary <span></span><link></div>';
   output = '<div>unary <link></div>';
-  test_minify(assert, input, { removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
   output = '<div>unary<link></div>';
-  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 
   input = '<div>Empty <!-- NOT --> </div>';
-  test_minify(assert, input, { removeEmptyElements: true }, input);
+  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
   output = '<div>Empty<!-- NOT --></div>';
-  test_minify(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
 });
 
 QUnit.test('collapsing boolean attributes', function(assert) {
   var input, output;
 
   input = '<input disabled="disabled">';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input disabled>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input disabled>');
 
   input = '<input CHECKED = "checked" readonly="readonly">';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input checked readonly>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input checked readonly>');
 
   input = '<option name="blah" selected="selected">moo</option>';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<option name="blah" selected>moo</option>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<option name="blah" selected>moo</option>');
 
   input = '<input autofocus="autofocus">';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input autofocus>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input autofocus>');
 
   input = '<input required="required">';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input required>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input required>');
 
   input = '<input multiple="multiple">';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, '<input multiple>');
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input multiple>');
 
   input = '<div Allowfullscreen=foo Async=foo Autofocus=foo Autoplay=foo Checked=foo Compact=foo Controls=foo ' +
     'Declare=foo Default=foo Defaultchecked=foo Defaultmuted=foo Defaultselected=foo Defer=foo Disabled=foo ' +
@@ -1529,129 +1559,129 @@ QUnit.test('collapsing boolean attributes', function(assert) {
     'defaultmuted defaultselected defer disabled enabled formnovalidate hidden indeterminate inert ' +
     'ismap itemscope loop multiple muted nohref noresize noshade novalidate nowrap open pauseonexit readonly ' +
     'required reversed scoped seamless selected sortable truespeed typemustmatch visible></div>';
-  test_minify(assert, input, { collapseBooleanAttributes: true }, output);
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, output);
   output = '<div Allowfullscreen Async Autofocus Autoplay Checked Compact Controls Declare Default Defaultchecked ' +
     'Defaultmuted Defaultselected Defer Disabled Enabled Formnovalidate Hidden Indeterminate Inert ' +
     'Ismap Itemscope Loop Multiple Muted Nohref Noresize Noshade Novalidate Nowrap Open Pauseonexit Readonly ' +
     'Required Reversed Scoped Seamless Selected Sortable Truespeed Typemustmatch Visible></div>';
-  test_minify(assert, input, { collapseBooleanAttributes: true, caseSensitive: true }, output);
+  test_minify_sync(assert, input, { collapseBooleanAttributes: true, caseSensitive: true }, output);
 });
 
 QUnit.test('collapsing enumerated attributes', function(assert) {
-  test_minify(assert, '<div draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
-  test_minify(assert, '<div draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
-  test_minify(assert, '<div draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div Draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div Draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
-  test_minify(assert, '<div Draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
-  test_minify(assert, '<div Draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div Draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify(assert, '<div draggable="Auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
+  test_minify_sync(assert, '<div draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
+  test_minify_sync(assert, '<div draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div Draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div Draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
+  test_minify_sync(assert, '<div Draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
+  test_minify_sync(assert, '<div Draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div Draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify_sync(assert, '<div draggable="Auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
 });
 
 QUnit.test('keeping trailing slashes in tags', function(assert) {
-  test_minify(assert, '<img src="test"/>', { keepClosingSlash: true }, '<img src="test"/>');
+  test_minify_sync(assert, '<img src="test"/>', { keepClosingSlash: true }, '<img src="test"/>');
   // https://github.com/kangax/html-minifier/issues/233
-  test_minify(assert, '<img src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img src=test />');
-  test_minify(assert, '<img src="test" id=""/>', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true }, '<img src=test />');
-  test_minify(assert, '<img title="foo" src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img title=foo src=test />');
+  test_minify_sync(assert, '<img src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img src=test />');
+  test_minify_sync(assert, '<img src="test" id=""/>', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true }, '<img src=test />');
+  test_minify_sync(assert, '<img title="foo" src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img title=foo src=test />');
 });
 
 QUnit.test('removing optional tags', function(assert) {
   var input, output;
 
   input = '<p>foo';
-  test_minify(assert, input, { removeOptionalTags: true }, input);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
 
   input = '</p>';
   output = '<p>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<body></body>';
   output = '';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
-  test_minify(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
 
   input = '<html><head></head><body></body></html>';
   output = '';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
-  test_minify(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
 
   input = ' <html></html>';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html> </html>';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html></html> ';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = ' <html><body></body></html>';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html> <body></body></html>';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body> </body></html>';
   output = '<body> ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body></body> </html>';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><body></body></html> ';
   output = ' ';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<html><head><title>hello</title></head><body><p>foo<span>bar</span></p></body></html>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<title>hello</title><p>foo<span>bar</span>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<html lang=""><head><title>hello</title></head><body style=""><p>foo<span>bar</span></p></body></html>';
   output = '<html lang=""><title>hello</title><body style=""><p>foo<span>bar</span>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
   output = '<title>hello</title><p>foo<span>bar</span>';
-  test_minify(assert, input, { removeOptionalTags: true, removeEmptyAttributes: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyAttributes: true }, output);
 
   input = '<html><head><title>a</title><link href="b.css" rel="stylesheet"/></head><body><a href="c.html"></a><div class="d"><input value="e"/></div></body></html>';
   output = '<title>a</title><link href="b.css" rel="stylesheet"><a href="c.html"></a><div class="d"><input value="e"></div>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><div><p>This is some text in a div</p><details>Followed by some details</details></div><div><p>This is some more text in a div</p></div></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><div><p>This is some text in a div<details>Followed by some details</details></div><div><p>This is some more text in a div</div>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><noscript><p>This is some text in a noscript</p><details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><body><noscript><p>This is some text in a noscript<details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<md-list-item ui-sref=".app-config"><md-icon md-font-icon="mdi-settings"></md-icon><p translate>Configure</p></md-list-item>';
-  test_minify(assert, input, { removeOptionalTags: true }, input);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
 });
 
 QUnit.test('removing optional tags in tables', function(assert) {
@@ -1662,22 +1692,22 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<tbody><tr><td>boo</td><td>moo</td><td>loo</td></tr> </tbody>' +
             '<tfoot><tr><th>baz</th> <th>qux</th><td>boo</td></tr></tfoot>' +
           '</table>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar</th> <th>baz</thead> ' +
              '<tr><td>boo<td>moo<td>loo</tr> ' +
              '<tfoot><tr><th>baz</th> <th>qux<td>boo' +
            '</table>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar<th>baz' +
              '<tbody><tr><td>boo<td>moo<td>loo' +
              '<tfoot><tr><th>baz<th>qux<td>boo' +
            '</table>';
-  test_minify(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
-  test_minify(assert, output, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, output, { collapseWhitespace: true, removeOptionalTags: true }, output);
 
   input = '<table>' +
             '<caption>foo</caption>' +
@@ -1686,7 +1716,7 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<!-- blah -->' +
             '<tbody><tr><th>bar</th><td>baz</td><th>qux</th></tr></tbody>' +
           '</table>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   output = '<table>' +
              '<caption>foo</caption>' +
@@ -1695,23 +1725,23 @@ QUnit.test('removing optional tags in tables', function(assert) {
              '<!-- blah -->' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
-  test_minify(assert, output, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, output, { removeOptionalTags: true }, output);
 
   output = '<table>' +
              '<caption>foo' +
              '<col span="2"><col>' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  test_minify(assert, input, { removeComments: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeComments: true, removeOptionalTags: true }, output);
 
   input = '<table>' +
             '<tbody></tbody>' +
           '</table>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
   output = '<table><tbody></table>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 });
 
 QUnit.test('removing optional tags in options', function(assert) {
@@ -1719,17 +1749,17 @@ QUnit.test('removing optional tags in options', function(assert) {
 
   input = '<select><option>foo</option><option>bar</option></select>';
   output = '<select><option>foo<option>bar</select>';
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 
   input = '<select>\n' +
           '  <option>foo</option>\n' +
           '  <option>bar</option>\n' +
           '</select>';
-  test_minify(assert, input, { removeOptionalTags: true }, input);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
   output = '<select><option>foo<option>bar</select>';
-  test_minify(assert, input, { removeOptionalTags: true, collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true, collapseWhitespace: true }, output);
   output = '<select> <option>foo</option> <option>bar</option> </select>';
-  test_minify(assert, input, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true }, output);
 
   // example from htmldog.com
   input = '<select name="catsndogs">' +
@@ -1748,40 +1778,40 @@ QUnit.test('removing optional tags in options', function(assert) {
                '<option>Grey Wolf<option>Red Fox<option>Fennec' +
            '</select>';
 
-  test_minify(assert, input, { removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
 });
 
 QUnit.test('custom components', function(assert) {
   var input = '<custom-component>Oh, my.</custom-component>';
   var output = '<custom-component>Oh, my.</custom-component>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('HTML4: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  test_minify(assert, input, { html5: false }, input);
+  test_minify_sync(assert, input, { html5: false }, input);
 });
 
 QUnit.test('HTML5: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  test_minify(assert, input, { html5: true }, input);
+  test_minify_sync(assert, input, { html5: true }, input);
 });
 
 QUnit.test('HTML4: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"></a><div>Well, look at me! I\'m a div!</div>';
-  test_minify(assert, input, { html5: false }, output);
+  test_minify_sync(assert, input, { html5: false }, output);
 });
 
 QUnit.test('HTML5: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  test_minify(assert, input, { html5: true }, output);
+  test_minify_sync(assert, input, { html5: true }, output);
 });
 
 QUnit.test('HTML5: enabled by default', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  test_minify(assert, input, { html5: true }, minify(input));
+  test_minify_sync(assert, input, { html5: true }, minify(input));
 });
 
 QUnit.test('phrasing content', function(assert) {
@@ -1789,12 +1819,12 @@ QUnit.test('phrasing content', function(assert) {
 
   input = '<p>a<div>b</div>';
   output = '<p>a</p><div>b</div>';
-  test_minify(assert, input, { html5: true }, output);
+  test_minify_sync(assert, input, { html5: true }, output);
   output = '<p>a<div>b</div></p>';
-  test_minify(assert, input, { html5: false }, output);
+  test_minify_sync(assert, input, { html5: false }, output);
 
   input = '<label>a<div>b</div>c</label>';
-  test_minify(assert, input, { html5: true }, input);
+  test_minify_sync(assert, input, { html5: true }, input);
 });
 
 // https://github.com/kangax/html-minifier/issues/888
@@ -1803,29 +1833,29 @@ QUnit.test('ul/ol should be phrasing content', function(assert) {
 
   input = '<p>a<ul><li>item</li></ul>';
   output = '<p>a</p><ul><li>item</li></ul>';
-  test_minify(assert, input, { html5: true }, output);
+  test_minify_sync(assert, input, { html5: true }, output);
 
   output = '<p>a<ul><li>item</ul>';
-  test_minify(assert, input, { html5: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { html5: true, removeOptionalTags: true }, output);
 
   output = '<p>a<ul><li>item</li></ul></p>';
-  test_minify(assert, input, { html5: false }, output);
+  test_minify_sync(assert, input, { html5: false }, output);
 
   input = '<p>a<ol><li>item</li></ol></p>';
   output = '<p>a</p><ol><li>item</li></ol><p></p>';
-  test_minify(assert, input, { html5: true }, output);
+  test_minify_sync(assert, input, { html5: true }, output);
 
   output = '<p>a<ol><li>item</ol><p>';
-  test_minify(assert, input, { html5: true, removeOptionalTags: true }, output);
+  test_minify_sync(assert, input, { html5: true, removeOptionalTags: true }, output);
 
   output = '<p>a</p><ol><li>item</li></ol>';
-  test_minify(assert, input, { html5: true, removeEmptyElements: true }, output);
+  test_minify_sync(assert, input, { html5: true, removeEmptyElements: true }, output);
 });
 
 QUnit.test('phrasing content with Web Components', function(assert) {
   var input = '<span><phrasing-element></phrasing-element></span>';
   var output = '<span><phrasing-element></phrasing-element></span>';
-  test_minify(assert, input, { html5: true }, output);
+  test_minify_sync(assert, input, { html5: true }, output);
 });
 
 // https://github.com/kangax/html-minifier/issues/10
@@ -1835,23 +1865,23 @@ QUnit.test('Ignore custom fragments', function(assert) {
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n{{ ... }}\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %> <%= ... %> <? ... ?> No comment, but middle. {{ ... }} <?php ... ?> <?xml ... ?> Hello, this is the end!';
-  test_minify(assert, input, {}, input);
-  test_minify(assert, input, { removeComments: true, collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {}, input);
+  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     ignoreCustomFragments: reFragments
   }, output);
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle. {{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n{{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true,
@@ -1860,27 +1890,27 @@ QUnit.test('Ignore custom fragments', function(assert) {
 
   input = '{{ if foo? }}\r\n  <div class="bar">\r\n    ...\r\n  </div>\r\n{{ end \n}}';
   output = '{{ if foo? }}<div class="bar">...</div>{{ end }}';
-  test_minify(assert, input, {}, input);
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, { collapseWhitespace: true, ignoreCustomFragments: [] }, output);
+  test_minify_sync(assert, input, {}, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, ignoreCustomFragments: [] }, output);
 
   output = '{{ if foo? }} <div class="bar">...</div> {{ end \n}}';
-  test_minify(assert, input, { collapseWhitespace: true, ignoreCustomFragments: reFragments }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, ignoreCustomFragments: reFragments }, output);
 
   output = '{{ if foo? }}\n<div class="bar">\n...\n</div>\n{{ end \n}}';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true,
     ignoreCustomFragments: reFragments
   }, output);
 
   input = '<a class="<% if foo? %>bar<% end %> {{ ... }}"></a>';
-  test_minify(assert, input, {}, input);
-  test_minify(assert, input, { ignoreCustomFragments: reFragments }, input);
+  test_minify_sync(assert, input, {}, input);
+  test_minify_sync(assert, input, { ignoreCustomFragments: reFragments }, input);
 
   input = '<img src="{% static "images/logo.png" %}">';
   output = '<img src="{% static "images/logo.png" %}">';
-  test_minify(assert, input, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] }, output);
+  test_minify_sync(assert, input, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] }, output);
 
   input = '<p{% if form.name.errors %}class=\'error\'{% endif %}>' +
             '{{ form.name.label_tag }}' +
@@ -1892,7 +1922,7 @@ QUnit.test('Ignore custom fragments', function(assert) {
             '{% endfor %}' +
             '{% endif %}' +
           '</p>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
@@ -1909,7 +1939,7 @@ QUnit.test('Ignore custom fragments', function(assert) {
              '{% endfor %}' +
              '{% endif %}' +
            '</p>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
@@ -1919,14 +1949,14 @@ QUnit.test('Ignore custom fragments', function(assert) {
   }, output);
 
   input = '<a href="/legal.htm"<?php echo e(Request::path() == \'/\' ? \' rel="nofollow"\':\'\'); ?>>Legal Notices</a>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /<\?php[\s\S]*?\?>/g
     ]
   }, input);
 
   input = '<input type="checkbox"<%= (model.isChecked ? \'checked="checked"\' : \'\') %>>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /<%=[\s\S]*?%>/g
     ]
@@ -1936,7 +1966,7 @@ QUnit.test('Ignore custom fragments', function(assert) {
             '{{IF text}}' +
             'data-yashareDescription="{{shorted(text, 300)}}"' +
             '{{END IF}}></div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{\{[\s\S]*?\}\}/g
     ],
@@ -1944,14 +1974,14 @@ QUnit.test('Ignore custom fragments', function(assert) {
   }, input);
 
   input = '<img class="{% foo %} {% bar %}">';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ]
   }, input);
   // trimCustomFragments withOUT collapseWhitespace, does
   // not break the "{% foo %} {% bar %}" test
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
@@ -1959,7 +1989,7 @@ QUnit.test('Ignore custom fragments', function(assert) {
   }, input);
   // trimCustomFragments WITH collapseWhitespace, changes output
   output = '<img class="{% foo %}{% bar %}">';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
@@ -1968,21 +1998,21 @@ QUnit.test('Ignore custom fragments', function(assert) {
   }, output);
 
   input = '<img class="titi.<%=tsItem_[0]%>">';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
 
   input = '<table id="<?php echo $this->escapeHtmlAttr($this->table_id); ?>"></table>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
 
   input = '<!--{{comment}}-->{{if a}}<div>b</div>{{/if}}';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '{{if a}}<div>b</div>{{/if}}';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     ignoreCustomFragments: [
       /\{\{.*?\}\}/g
@@ -1991,69 +2021,69 @@ QUnit.test('Ignore custom fragments', function(assert) {
 
   // https://github.com/kangax/html-minifier/issues/722
   input = '<? echo "foo"; ?> <span>bar</span>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
   output = '<? echo "foo"; ?><span>bar</span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
   }, output);
 
   input = ' <? echo "foo"; ?> bar';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<? echo "foo"; ?> bar';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, output);
   output = '<? echo "foo"; ?>bar';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
   }, output);
 
   input = '<span>foo</span> <? echo "bar"; ?> baz';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
   output = '<span>foo</span><? echo "bar"; ?>baz';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
   }, output);
 
   input = '<span>foo</span> <? echo "bar"; ?> <? echo "baz"; ?> <span>foo</span>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
   output = '<span>foo</span><? echo "bar"; ?><? echo "baz"; ?><span>foo</span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     trimCustomFragments: true
   }, output);
 
   input = 'foo <WC@bar> baz moo </WC@bar> loo';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [
       /<(WC@[\s\S]*?)>(.*?)<\/\1>/
     ]
   }, input);
   output = 'foo<wc @bar>baz moo</wc>loo';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, output);
 
   input = '<link href="<?php echo \'http://foo/\' ?>">';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { removeAttributeQuotes: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { removeAttributeQuotes: true }, input);
 
   input = '<pre>\nfoo\n<? bar ?>\nbaz\n</pre>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
 });
 
 QUnit.test('bootstrap\'s span > button > span', function(assert) {
@@ -2063,15 +2093,15 @@ QUnit.test('bootstrap\'s span > button > span', function(assert) {
                 '\n  </button>' +
               '</span>';
   var output = '<span class=input-group-btn><button class="btn btn-default" type=button><span class="glyphicon glyphicon-search"></span></button></span>';
-  test_minify(assert, input, { collapseWhitespace: true, removeAttributeQuotes: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, removeAttributeQuotes: true }, output);
 });
 
 QUnit.test('caseSensitive', function(assert) {
   var input = '<div mixedCaseAttribute="value"></div>';
   var caseSensitiveOutput = '<div mixedCaseAttribute="value"></div>';
   var caseInSensitiveOutput = '<div mixedcaseattribute="value"></div>';
-  test_minify(assert, input, caseInSensitiveOutput);
-  test_minify(assert, input, { caseSensitive: true }, caseSensitiveOutput);
+  test_minify_sync(assert, input, caseInSensitiveOutput);
+  test_minify_sync(assert, input, { caseSensitive: true }, caseSensitiveOutput);
 });
 
 QUnit.test('source & track', function(assert) {
@@ -2081,8 +2111,8 @@ QUnit.test('source & track', function(assert) {
                 '<source src="foobar.wav">' +
                 '<track kind="captions" src="sampleCaptions.vtt" srclang="en">' +
               '</audio>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { removeOptionalTags: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
 });
 
 QUnit.test('mixed html and svg', function(assert) {
@@ -2107,18 +2137,18 @@ QUnit.test('mixed html and svg', function(assert) {
     '</svg>' +
     '</body></html>';
   // Should preserve case-sensitivity and closing slashes within svg tags
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('nested quotes', function(assert) {
   var input, output;
 
   input = '<div data=\'{"test":"\\"test\\""}\'></div>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { quoteCharacter: '\'' }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { quoteCharacter: '\'' }, input);
 
   output = '<div data="{&#34;test&#34;:&#34;\\&#34;test\\&#34;&#34;}"></div>';
-  test_minify(assert, input, { quoteCharacter: '"' }, output);
+  test_minify_sync(assert, input, { quoteCharacter: '"' }, output);
 });
 
 QUnit.test('script minification', function(assert) {
@@ -2126,32 +2156,32 @@ QUnit.test('script minification', function(assert) {
 
   input = '<script></script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()';
 
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script>alert("1 2")</script>';
 
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/JavaScript">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="text/JavaScript">alert("1 2")</script>';
 
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="application/javascript;version=1.8">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;version=1.8">alert("1 2")</script>';
 
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type=" application/javascript  ; charset=utf-8 ">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;charset=utf-8">alert("1 2")</script>';
 
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({\'gtm.start\':new Date().getTime(),event:\'gtm.js\'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!=\'dataLayer\'?\'&l=\'+l:\'\';j.async=true;j.src=\'//www.googletagmanager.com/gtm.js?id=\'+i+dl;f.parentNode.insertBefore(j,f);})(window,document,\'script\',\'dataLayer\',\'GTM-67NT\');</script>';
   output = '<script>!function(w,d,s,l,i){w[l]=w[l]||[],w[l].push({"gtm.start":(new Date).getTime(),event:"gtm.js"});var f=d.getElementsByTagName(s)[0],j=d.createElement(s);j.async=!0,j.src="//www.googletagmanager.com/gtm.js?id=GTM-67NT",f.parentNode.insertBefore(j,f)}(window,document,"script","dataLayer")</script>';
 
-  test_minify(assert, input, { minifyJS: { mangle: false } }, output);
+  test_minify_sync(assert, input, { minifyJS: { mangle: false } }, output);
 
   input = '<script>\n' +
           '  <!--\n' +
@@ -2164,7 +2194,7 @@ QUnit.test('script minification', function(assert) {
           '</script>';
   output = '<script>Platform.Mobile.Bootstrap.init(function(){Platform.Mobile.Core.Navigation.go("Login",{error:""})})</script>';
 
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('minification of scripts with different mimetypes', function(assert) {
@@ -2172,68 +2202,68 @@ QUnit.test('minification of scripts with different mimetypes', function(assert)
 
   input = '<script type="">function f(){  return 1  }</script>';
   output = '<script type="">function f(){return 1}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/javascript">function f(){  return 1  }</script>';
   output = '<script type="text/javascript">function f(){return 1}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script foo="bar">function f(){  return 1  }</script>';
   output = '<script foo="bar">function f(){return 1}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="text/ecmascript">function f(){  return 1  }</script>';
   output = '<script type="text/ecmascript">function f(){return 1}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="application/javascript">function f(){  return 1  }</script>';
   output = '<script type="application/javascript">function f(){return 1}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<script type="boo">function f(){  return 1  }</script>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<script type="text/html"><!-- ko if: true -->\n\n\n<div></div>\n\n\n<!-- /ko --></script>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 });
 
 QUnit.test('minification of scripts with custom fragments', function(assert) {
   var input, output;
 
   input = '<script><?php ?></script>';
-  test_minify(assert, input, { minifyJS: true }, input);
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
   }, input);
 
   input = '<script>\n<?php ?></script>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
   output = '<script> <?php ?></script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
   }, input);
 
   input = '<script><?php ?>\n</script>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
   output = '<script><?php ?> </script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
   }, input);
 
   input = '<script>\n<?php ?>\n</script>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
   output = '<script> <?php ?> </script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
@@ -2241,9 +2271,9 @@ QUnit.test('minification of scripts with custom fragments', function(assert) {
 
   input = '<script>// <% ... %></script>';
   output = '<script></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
@@ -2251,11 +2281,11 @@ QUnit.test('minification of scripts with custom fragments', function(assert) {
 
   input = '<script>// \n<% ... %></script>';
   output = '<script> \n<% ... %></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
   output = '<script> <% ... %></script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
   output = '<script>\n<% ... %></script>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
@@ -2263,9 +2293,9 @@ QUnit.test('minification of scripts with custom fragments', function(assert) {
 
   input = '<script>// <% ... %>\n</script>';
   output = '<script></script>';
-  test_minify(assert, input, { minifyJS: true }, output);
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
@@ -2273,11 +2303,11 @@ QUnit.test('minification of scripts with custom fragments', function(assert) {
 
   input = '<script>// \n<% ... %>\n</script>';
   output = '<script> \n<% ... %>\n</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
   output = '<script> <% ... %> </script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
   output = '<script>\n<% ... %>\n</script>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
@@ -2285,146 +2315,146 @@ QUnit.test('minification of scripts with custom fragments', function(assert) {
 
   input = '<script>function f(){  return <?php ?>  }</script>';
   output = '<script>function f(){return <?php ?>  }</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
   output = '<script>function f(){return <?php ?> }</script>';
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
 
   input = '<script>function f(){  return "<?php ?>"  }</script>';
   output = '<script>function f(){return"<?php ?>"}</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
-  test_minify(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
 });
 
 QUnit.test('event minification', function(assert) {
   var input, output;
 
   input = '<div only="alert(a + b)" one=";return false;"></div>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<div onclick="alert(a + b)"></div>';
   output = '<div onclick="alert(a+b)"></div>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<a href="/" onclick="this.href = getUpdatedURL (this.href);return true;">test</a>';
   output = '<a href="/" onclick="return this.href=getUpdatedURL(this.href),!0">test</a>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick=\'try{dcsMultiTrack("DCS.dcsuri","USPS","WT.ti")}catch(e){}\'> foobar</a>';
-  test_minify(assert, input, { minifyJS: { mangle: false } }, output);
-  test_minify(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '\'' }, output);
+  test_minify_sync(assert, input, { minifyJS: { mangle: false } }, output);
+  test_minify_sync(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '\'' }, output);
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick="try{dcsMultiTrack(&#34;DCS.dcsuri&#34;,&#34;USPS&#34;,&#34;WT.ti&#34;)}catch(e){}"> foobar</a>';
-  test_minify(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '"' }, output);
+  test_minify_sync(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '"' }, output);
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick=\'_gaq.push(["_trackEvent","FGF","banner_click"])\'></a>';
-  test_minify(assert, input, { minifyJS: true }, output);
-  test_minify(assert, input, { minifyJS: true, quoteCharacter: '\'' }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true, quoteCharacter: '\'' }, output);
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick="_gaq.push([&#34;_trackEvent&#34;,&#34;FGF&#34;,&#34;banner_click&#34;])"></a>';
-  test_minify(assert, input, { minifyJS: true, quoteCharacter: '"' }, output);
+  test_minify_sync(assert, input, { minifyJS: true, quoteCharacter: '"' }, output);
 
   input = '<button type="button" onclick=";return false;" id="appbar-guide-button"></button>';
   output = '<button type="button" onclick="return!1" id="appbar-guide-button"></button>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<button type="button" onclick=";return false;" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
   output = '<button type="button" onclick="return!1" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
-  test_minify(assert, input, { minifyJS: true }, output);
-  test_minify(assert, input, { minifyJS: true, customEventAttributes: [] }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [] }, input);
   output = '<button type="button" onclick=";return false;" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  test_minify(assert, input, { minifyJS: true, customEventAttributes: [/^ng-/] }, output);
+  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [/^ng-/] }, output);
   output = '<button type="button" onclick="return!1" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  test_minify(assert, input, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] }, output);
+  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] }, output);
 
   input = '<div onclick="<?= b ?>"></div>';
-  test_minify(assert, input, { minifyJS: true }, input);
+  test_minify_sync(assert, input, { minifyJS: true }, input);
 
   input = '<div onclick="alert(a + <?= b ?>)"></div>';
   output = '<div onclick="alert(a+ <?= b ?>)"></div>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 
   input = '<div onclick="alert(a + \'<?= b ?>\')"></div>';
   output = '<div onclick=\'alert(a+"<?= b ?>")\'></div>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('escaping closing script tag', function(assert) {
   var input = '<script>window.jQuery || document.write(\'<script src="jquery.js"><\\/script>\')</script>';
   var output = '<script>window.jQuery||document.write(\'<script src="jquery.js"><\\/script>\')</script>';
-  test_minify(assert, input, { minifyJS: true }, output);
+  test_minify_sync(assert, input, { minifyJS: true }, output);
 });
 
 QUnit.test('style minification', function(assert) {
   var input, output;
 
   input = '<style></style>div#foo { background-color: red; color: white }';
-  test_minify(assert, input, { minifyCSS: true }, input);
+  test_minify_sync(assert, input, { minifyCSS: true }, input);
 
   input = '<style>div#foo { background-color: red; color: white }</style>';
   output = '<style>div#foo{background-color:red;color:#fff}</style>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<style>div > p.foo + span { border: 10px solid black }</style>';
   output = '<style>div>p.foo+span{border:10px solid #000}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 
   input = '<div style="background: url(images/<% image %>);"></div>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  test_minify(assert, input, { minifyCSS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
   }, output);
 
   input = '<div style="background: url(\'images/<% image %>\')"></div>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  test_minify(assert, input, { minifyCSS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
   }, output);
 
   input = '<style>\np {\n  background: url(images/<% image %>);\n}\n</style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
   }, output);
 
   input = '<style>p { background: url("images/<% image %>") }</style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     minifyCSS: true
   }, output);
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width:737px)">';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
   output = '<link rel=stylesheet href=css/style-mobile.css media=(max-width:737px)>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     removeAttributeQuotes: true
   }, output);
 
   input = '<style media="(max-width: 737px)"></style>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
   output = '<style media="(max-width:737px)"></style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
   output = '<style media=(max-width:737px)></style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     removeAttributeQuotes: true
   }, output);
@@ -2433,7 +2463,7 @@ QUnit.test('style minification', function(assert) {
 QUnit.test('style attribute minification', function(assert) {
   var input = '<div style="color: red; background-color: yellow; font-family: Verdana, Arial, sans-serif;"></div>';
   var output = '<div style="color:red;background-color:#ff0;font-family:Verdana,Arial,sans-serif"></div>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
 });
 
 QUnit.test('url attribute minification', function(assert) {
@@ -2441,61 +2471,61 @@ QUnit.test('url attribute minification', function(assert) {
 
   input = '<link rel="stylesheet" href="http://website.com/style.css"><form action="http://website.com/folder/folder2/index.html"><a href="http://website.com/folder/file.html">link</a></form>';
   output = '<link rel="stylesheet" href="/style.css"><form action="folder2/"><a href="file.html">link</a></form>';
-  test_minify(assert, input, { minifyURLs: 'http://website.com/folder/' }, output);
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/folder/' } }, output);
+  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/folder/' }, output);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/folder/' } }, output);
 
   input = '<link rel="canonical" href="http://website.com/">';
-  test_minify(assert, input, { minifyURLs: 'http://website.com/' }, input);
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/' }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
 
   input = '<style>body { background: url(\'http://website.com/bg.png\') }</style>';
-  test_minify(assert, input, { minifyURLs: 'http://website.com/' }, input);
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/' }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
   output = '<style>body{background:url(http://website.com/bg.png)}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: 'http://website.com/'
   }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
   }, output);
 
   input = '<style>body { background: url("http://website.com/foo bar/bg.png") }</style>';
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo bar/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo bar/' } }, input);
   output = '<style>body{background:url("http://website.com/foo bar/bg.png")}</style>';
-  test_minify(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo bar/' }
   }, output);
 
   input = '<style>body { background: url("http://website.com/foo bar/(baz)/bg.png") }</style>';
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } }, input);
-  test_minify(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } }, input);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } }, input);
   output = '<style>body{background:url("foo%20bar/(baz)/bg.png")}</style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
   }, output);
   output = '<style>body{background:url("(baz)/bg.png")}</style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/' }
   }, output);
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' }
   }, output);
 
   input = '<img src="http://cdn.site.com/foo.png">';
   output = '<img src="//cdn.site.com/foo.png">';
-  test_minify(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
 });
 
 QUnit.test('srcset attribute minification', function(assert) {
@@ -2503,20 +2533,20 @@ QUnit.test('srcset attribute minification', function(assert) {
   input = '<source srcset="http://site.com/foo.gif ,http://site.com/bar.jpg 1x, baz moo 42w,' +
           '\n\n\n\n\n\t    http://site.com/zo om.png 1.00x">';
   output = '<source srcset="http://site.com/foo.gif, http://site.com/bar.jpg, baz moo 42w, http://site.com/zo om.png">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
   output = '<source srcset="foo.gif, bar.jpg, baz%20moo 42w, zo%20om.png">';
-  test_minify(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
+  test_minify_sync(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
 });
 
 QUnit.test('valueless attributes', function(assert) {
   var input = '<br foo>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 });
 
 QUnit.test('newlines becoming whitespaces', function(assert) {
   var input = 'test\n\n<input>\n\ntest';
   var output = 'test <input> test';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('conservative collapse', function(assert) {
@@ -2524,86 +2554,86 @@ QUnit.test('conservative collapse', function(assert) {
 
   input = '<b>   foo \n\n</b>';
   output = '<b> foo </b>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<html>\n\n<!--test-->\n\n</html>';
   output = '<html> </html>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, input);
 
   input = '<p> \u00A0</p>';
   output = '<p>\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>\u00A0 </p>';
   output = '<p>\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p> \u00A0 </p>';
   output = '<p>\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>\u00A0\u00A0 \u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>foo \u00A0\u00A0 \u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>\u00A0\u00A0 \u00A0 bar</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>foo \u00A0\u00A0 \u00A0 bar</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p> \u00A0foo\u00A0\t</p>';
   output = '<p>\u00A0foo\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
@@ -2611,8 +2641,8 @@ QUnit.test('conservative collapse', function(assert) {
 
   input = '<p> \u00A0\nfoo\u00A0\t</p>';
   output = '<p>\u00A0 foo\u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
@@ -2620,16 +2650,16 @@ QUnit.test('conservative collapse', function(assert) {
 
   input = '<p> \u00A0foo \u00A0\t</p>';
   output = '<p>\u00A0foo \u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
 
   input = '<p> \u00A0\nfoo \u00A0\t</p>';
   output = '<p>\u00A0 foo \u00A0</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
   }, output);
@@ -2662,11 +2692,11 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
@@ -2682,7 +2712,7 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true,
@@ -2691,19 +2721,19 @@ QUnit.test('collapse preseving a line break', function(assert) {
 
   input = '<div> text <span>\n text</span> \n</div>';
   output = '<div>text <span>\ntext</span>\n</div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
 
   input = '<div>  text \n </div>';
   output = '<div>text\n</div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
   output = '<div> text\n</div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
@@ -2711,12 +2741,12 @@ QUnit.test('collapse preseving a line break', function(assert) {
 
   input = '<div>\ntext  </div>';
   output = '<div>\ntext</div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     preserveLineBreaks: true
   }, output);
   output = '<div>\ntext </div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
@@ -2724,7 +2754,7 @@ QUnit.test('collapse preseving a line break', function(assert) {
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n<?= ... ?>\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n<?= ... ?>\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
@@ -2735,24 +2765,24 @@ QUnit.test('collapse inline tag whitespace', function(assert) {
   var input, output;
 
   input = '<button>a</button> <button>b</button>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, input);
 
   output = '<button>a</button><button>b</button>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
   }, output);
 
   input = '<p>where <math> <mi>R</mi> </math> is the Rici tensor.</p>';
   output = '<p>where <math><mi>R</mi></math> is the Rici tensor.</p>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true
   }, output);
 
   output = '<p>where<math><mi>R</mi></math>is the Rici tensor.</p>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
   }, output);
@@ -2762,34 +2792,34 @@ QUnit.test('ignore custom comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { removeComments: true }, input);
-  test_minify(assert, input, { ignoreCustomComments: false }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, { ignoreCustomComments: false }, input);
+  test_minify_sync(assert, input, {
     removeComments: true,
     ignoreCustomComments: []
   }, '');
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     ignoreCustomComments: false
   }, '');
 
   input = '<!-- htmlmin:ignore -->test<!-- htmlmin:ignore -->';
   output = 'test';
-  test_minify(assert, input, output);
-  test_minify(assert, input, { removeComments: true }, output);
-  test_minify(assert, input, { ignoreCustomComments: false }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, output);
+  test_minify_sync(assert, input, { removeComments: true }, output);
+  test_minify_sync(assert, input, { ignoreCustomComments: false }, output);
+  test_minify_sync(assert, input, {
     removeComments: true,
     ignoreCustomComments: []
   }, output);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     ignoreCustomComments: false
   }, output);
 
   input = '<!-- ko if: someExpressionGoesHere --><li>test</li><!-- /ko -->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     // ignore knockout comments
     ignoreCustomComments: [
@@ -2799,7 +2829,7 @@ QUnit.test('ignore custom comments', function(assert) {
   }, input);
 
   input = '<!--#include virtual="/cgi-bin/counter.pl" -->';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeComments: true,
     // ignore Apache SSI includes
     ignoreCustomComments: [
@@ -2811,7 +2841,7 @@ QUnit.test('ignore custom comments', function(assert) {
 QUnit.test('processScripts', function(assert) {
   var input = '<script type="text/ng-template"><!--test--><div>   <span> foobar </span> \n\n</div></script>';
   var output = '<script type="text/ng-template"><div><span>foobar</span></div></script>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     removeComments: true,
     processScripts: ['text/ng-template']
@@ -2825,10 +2855,10 @@ QUnit.test('ignore', function(assert) {
           '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>';
   output = '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>' +
            '<div class="blah" style="color: red">test <span><input disabled="disabled"> foo</span></div>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<!-- htmlmin:ignore --><!-- htmlmin:ignore -->';
-  test_minify(assert, input, '');
+  test_minify_sync(assert, input, '');
 
   input = '<p>.....</p><!-- htmlmin:ignore -->' +
           '@for( $i = 0 ; $i < $criterions->count() ; $i++ )' +
@@ -2840,23 +2870,23 @@ QUnit.test('ignore', function(assert) {
                '<h1>{{ $criterions[$i]->value }}</h1>' +
            '@endfor' +
            '<p>....</p>';
-  test_minify(assert, input, { removeComments: true }, output);
+  test_minify_sync(assert, input, { removeComments: true }, output);
 
   input = '<!-- htmlmin:ignore --> <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> <!-- htmlmin:ignore -->';
   output = ' <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> ';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<!-- htmlmin:ignore --><body <?php body_class(); ?>><!-- htmlmin:ignore -->';
   output = '<body <?php body_class(); ?>>';
-  test_minify(assert, input, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] }, output);
+  test_minify_sync(assert, input, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] }, output);
 
   input = 'a\n<!-- htmlmin:ignore -->b<!-- htmlmin:ignore -->';
   output = 'a b';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 
   input = '<p>foo <!-- htmlmin:ignore --><span>\n\tbar\n</span><!-- htmlmin:ignore -->.</p>';
   output = '<p>foo <span>\n\tbar\n</span>.</p>';
-  test_minify(assert, input, { collapseWhitespace: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
 });
 
 QUnit.test('meta viewport', function(assert) {
@@ -2864,36 +2894,36 @@ QUnit.test('meta viewport', function(assert) {
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<meta name="viewport" content="initial-scale=1, maximum-scale=1.0">';
   output = '<meta name="viewport" content="initial-scale=1,maximum-scale=1">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<meta name="viewport" content="width= 500 ,  initial-scale=1">';
   output = '<meta name="viewport" content="width=500,initial-scale=1">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0001, maximum-scale=3.140000">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1.0001,maximum-scale=3.14">';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('downlevel-revealed conditional comments', function(assert) {
   var input = '<![if !IE]><link href="non-ie.css" rel="stylesheet"><![endif]>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { removeComments: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { removeComments: true }, input);
 });
 
 QUnit.test('noscript', function(assert) {
   var input;
 
   input = '<SCRIPT SRC="x"></SCRIPT><NOSCRIPT>x</NOSCRIPT>';
-  test_minify(assert, input, '<script src="x"></script><noscript>x</noscript>');
+  test_minify_sync(assert, input, '<script src="x"></script><noscript>x</noscript>');
 
   input = '<noscript>\n<!-- anchor linking to external file -->\n' +
           '<a href="#" onclick="javascript:">External Link</a>\n</noscript>';
-  test_minify(assert, input, { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true },
+  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true },
     '<noscript><a href="#">External Link</a></noscript>');
 });
 
@@ -2902,57 +2932,57 @@ QUnit.test('max line length', function(assert) {
   var options = { maxLineLength: 25 };
 
   input = '123456789012345678901234567890';
-  test_minify(assert, input, options, input);
+  test_minify_sync(assert, input, options, input);
 
   input = '<div data-attr="foo"></div>';
-  test_minify(assert, input, options, '<div data-attr="foo">\n</div>');
+  test_minify_sync(assert, input, options, '<div data-attr="foo">\n</div>');
 
   input = '<code>    hello   world  \n    world   hello  </code>';
-  test_minify(assert, input, options, '<code>\n    hello   world  \n    world   hello  \n</code>');
+  test_minify_sync(assert, input, options, '<code>\n    hello   world  \n    world   hello  \n</code>');
 
-  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
-  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
-  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
-  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
+  test_minify_sync(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify_sync(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify_sync(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify_sync(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify_sync(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
-  test_minify(assert, input, input);
+  test_minify_sync(assert, input, input);
 
-  test_minify(assert, '<script>alert(\'<!--\')</script>', options, '<script>alert(\'<!--\')\n</script>');
+  test_minify_sync(assert, '<script>alert(\'<!--\')</script>', options, '<script>alert(\'<!--\')\n</script>');
   input = '<script>\nalert(\'<!-- foo -->\')\n</script>';
-  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', options, input);
-  test_minify(assert, input, options, input);
-  test_minify(assert, '<script>alert(\'-->\')</script>', options, '<script>alert(\'-->\')\n</script>');
-
-  test_minify(assert, '<a title="x"href=" ">foo</a>', options, '<a title="x" href="">foo\n</a>');
-  test_minify(assert, '<p id=""class=""title="">x', options, '<p id="" class="" \ntitle="">x</p>');
-  test_minify(assert, '<p x="x\'"">x</p>', options, '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  test_minify(assert, '<a href="#"><p>Click me</p></a>', options, '<a href="#"><p>Click me\n</p></a>');
+  test_minify_sync(assert, '<script>alert(\'<!-- foo -->\')</script>', options, input);
+  test_minify_sync(assert, input, options, input);
+  test_minify_sync(assert, '<script>alert(\'-->\')</script>', options, '<script>alert(\'-->\')\n</script>');
+
+  test_minify_sync(assert, '<a title="x"href=" ">foo</a>', options, '<a title="x" href="">foo\n</a>');
+  test_minify_sync(assert, '<p id=""class=""title="">x', options, '<p id="" class="" \ntitle="">x</p>');
+  test_minify_sync(assert, '<p x="x\'"">x</p>', options, '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify_sync(assert, '<a href="#"><p>Click me</p></a>', options, '<a href="#"><p>Click me\n</p></a>');
   input = '<span><button>Hit me\n</button></span>';
-  test_minify(assert, '<span><button>Hit me</button></span>', options, input);
-  test_minify(assert, input, options, input);
-  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', options,
+  test_minify_sync(assert, '<span><button>Hit me</button></span>', options, input);
+  test_minify_sync(assert, input, options, input);
+  test_minify_sync(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', options,
     '<object \ntype="image/svg+xml" \ndata="image.svg"><div>\n[fallback image]</div>\n</object>'
   );
 
-  test_minify(assert, '<ng-include src="x"></ng-include>', options, '<ng-include src="x">\n</ng-include>');
-  test_minify(assert, '<ng:include src="x"></ng:include>', options, '<ng:include src="x">\n</ng:include>');
-  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', options,
+  test_minify_sync(assert, '<ng-include src="x"></ng-include>', options, '<ng-include src="x">\n</ng-include>');
+  test_minify_sync(assert, '<ng:include src="x"></ng:include>', options, '<ng:include src="x">\n</ng:include>');
+  test_minify_sync(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', options,
     '<ng-include \nsrc="\'views/partial-notification.html\'">\n</ng-include><div \nng-view=""></div>'
   );
-  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', options,
+  test_minify_sync(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', options,
     '<some-tag-1>\n</some-tag-1>\n<some-tag-2>\n</some-tag-2>'
   );
-  test_minify(assert, '[\']["]', options, '[\']["]');
-  test_minify(assert, '<a href="test.html"><div>hey</div></a>', options, '<a href="test.html">\n<div>hey</div></a>');
-  test_minify(assert, ':) <a href="http://example.com">link</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
-  test_minify(assert, ':) <a href="http://example.com">\nlink</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
-  test_minify(assert, ':) <a href="http://example.com">\n\nlink</a>', options, ':) <a \nhref="http://example.com">\n\nlink</a>');
+  test_minify_sync(assert, '[\']["]', options, '[\']["]');
+  test_minify_sync(assert, '<a href="test.html"><div>hey</div></a>', options, '<a href="test.html">\n<div>hey</div></a>');
+  test_minify_sync(assert, ':) <a href="http://example.com">link</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
+  test_minify_sync(assert, ':) <a href="http://example.com">\nlink</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
+  test_minify_sync(assert, ':) <a href="http://example.com">\n\nlink</a>', options, ':) <a \nhref="http://example.com">\n\nlink</a>');
 
-  test_minify(assert, '<a href>ok</a>', options, '<a href>ok</a>');
+  test_minify_sync(assert, '<a href>ok</a>', options, '<a href>ok</a>');
 });
 
 QUnit.test('custom attribute collapse', function(assert) {
@@ -2969,15 +2999,15 @@ QUnit.test('custom attribute collapse', function(assert) {
           '">foo</div>';
   output = '<div data-bind="css: {fadeIn: selected(,fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
 
-  test_minify(assert, input, input);
-  test_minify(assert, input, { customAttrCollapse: /data-bind/ }, output);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { customAttrCollapse: /data-bind/ }, output);
 
   input = '<div style="' +
             'color: red;' +
             'font-size: 100em;' +
           '">bar</div>';
   output = '<div style="color: red;font-size: 100em;">bar</div>';
-  test_minify(assert, input, { customAttrCollapse: /style/ }, output);
+  test_minify_sync(assert, input, { customAttrCollapse: /style/ }, output);
 
   input = '<div ' +
     'class="fragment square" ' +
@@ -2989,13 +3019,13 @@ QUnit.test('custom attribute collapse', function(assert) {
   '> ' +
   '</div>';
   output = '<div class="fragment square" ng-hide="square1.hide" ng-class="{\'bounceInDown\': !square1.hide, \'bounceOutDown\': square1.hide }"> </div>';
-  test_minify(assert, input, { customAttrCollapse: /ng-class/ }, output);
+  test_minify_sync(assert, input, { customAttrCollapse: /ng-class/ }, output);
 });
 
 QUnit.test('custom attribute collapse with empty attribute value', function(assert) {
   var input = '<div ng-some\n\n></div>';
   var output = '<div ng-some></div>';
-  test_minify(assert, input, { customAttrCollapse: /.+/ }, output);
+  test_minify_sync(assert, input, { customAttrCollapse: /.+/ }, output);
 });
 
 QUnit.test('custom attribute collapse with newlines, whitespace, and carriage returns', function(assert) {
@@ -3004,7 +3034,7 @@ QUnit.test('custom attribute collapse with newlines, whitespace, and carriage re
           '               value2:false \n\r' +
           '               }"></div>';
   var output = '<div ng-class="{value:true,value2:false}"></div>';
-  test_minify(assert, input, { customAttrCollapse: /ng-class/ }, output);
+  test_minify_sync(assert, input, { customAttrCollapse: /ng-class/ }, output);
 });
 
 QUnit.test('do not escape attribute value', function(assert) {
@@ -3013,23 +3043,23 @@ QUnit.test('do not escape attribute value', function(assert) {
   input = '<div data=\'{\n' +
           '\t"element": "<div class=\\"test\\"></div>\n"' +
           '}\'></div>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { preventAttributesEscaping: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { preventAttributesEscaping: true }, input);
 
   input = '<div foo bar=\'\' baz="" moo=1 loo=\'2\' haa="3"></div>';
-  test_minify(assert, input, { preventAttributesEscaping: true }, input);
+  test_minify_sync(assert, input, { preventAttributesEscaping: true }, input);
   output = '<div foo bar="" baz="" moo="1" loo="2" haa="3"></div>';
-  test_minify(assert, input, output);
+  test_minify_sync(assert, input, output);
 });
 
 QUnit.test('quoteCharacter is single quote', function(assert) {
-  test_minify(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
-  test_minify(assert, '<div class="bar">foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
+  test_minify_sync(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
+  test_minify_sync(assert, '<div class="bar">foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
 });
 
 QUnit.test('quoteCharacter is not single quote or double quote', function(assert) {
-  test_minify(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
-  test_minify(assert, '<div class="bar">foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
+  test_minify_sync(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
+  test_minify_sync(assert, '<div class="bar">foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
 });
 
 QUnit.test('remove space between attributes', function(assert) {
@@ -3043,27 +3073,27 @@ QUnit.test('remove space between attributes', function(assert) {
 
   input = '<input data-attr="example" value="hello world!" checked="checked">';
   output = '<input data-attr=example value="hello world!"checked>';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 
   input = '<input checked="checked" value="hello world!" data-attr="example">';
   output = '<input checked value="hello world!"data-attr=example>';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 
   input = '<input checked="checked" data-attr="example" value="hello world!">';
   output = '<input checked data-attr=example value="hello world!">';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 
   input = '<input data-attr="example" value="hello world!" checked="checked"/>';
   output = '<input data-attr=example value="hello world!"checked/>';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 
   input = '<input checked="checked" value="hello world!" data-attr="example"/>';
   output = '<input checked value="hello world!"data-attr=example />';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 
   input = '<input checked="checked" data-attr="example" value="hello world!"/>';
   output = '<input checked data-attr=example value="hello world!"/>';
-  test_minify(assert, input, options, output);
+  test_minify_sync(assert, input, options, output);
 });
 
 QUnit.test('markups from Angular 2', function(assert) {
@@ -3089,7 +3119,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '  </div>\n' +
            '  <button type="submit" [disabled]="!theForm.form.valid">Submit</button>\n' +
            '</form>';
-  test_minify(assert, input, { caseSensitive: true }, output);
+  test_minify_sync(assert, input, { caseSensitive: true }, output);
   output = '<template ngFor #hero [ngForOf]=heroes>' +
            '<hero-detail *ngIf=hero [hero]=hero></hero-detail>' +
            '</template>' +
@@ -3100,7 +3130,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '</div>' +
            '<button type=submit [disabled]=!theForm.form.valid>Submit</button>' +
            '</form>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseWhitespace: true,
@@ -3120,51 +3150,51 @@ QUnit.test('auto-generated tags', function(assert) {
   var input, output;
 
   input = '</p>';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
 
   input = '<p id=""class=""title="">x';
   output = '<p id="" class="" title="">x';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, output);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, output);
   output = '<p id="" class="" title="">x</p>';
-  test_minify(assert, input, output);
-  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify_sync(assert, input, output);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</body>';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, output);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, output);
 
   input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   output = '<a href="#"><div>Well, look at me! I\'m a div!</div>';
-  test_minify(assert, input, { html5: false, includeAutoGeneratedTags: false }, output);
-  test_minify(assert, '<p id=""class=""title="">x', {
+  test_minify_sync(assert, input, { html5: false, includeAutoGeneratedTags: false }, output);
+  test_minify_sync(assert, '<p id=""class=""title="">x', {
     maxLineLength: 25,
     includeAutoGeneratedTags: false
   }, '<p id="" class="" \ntitle="">x');
 
   input = '<p>foo';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify_sync(assert, input, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
   }, input);
 
   input = '</p>';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
   }, output);
 
   input = '<select><option>foo<option>bar</select>';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '<select><option>foo</option><option>bar</option></select>';
-  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
 
   input = '<datalist><option label="A" value="1"><option label="B" value="2"></datalist>';
-  test_minify(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
   output = '<datalist><option label="A" value="1"></option><option label="B" value="2"></option></datalist>';
-  test_minify(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
 });
 
 QUnit.test('sort attributes', function(assert) {
@@ -3173,26 +3203,26 @@ QUnit.test('sort attributes', function(assert) {
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<link type="text/css" href="app.css" rel="stylesheet" async>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { sortAttributes: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { sortAttributes: false }, input);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<link href="app.css" rel="stylesheet" async type="text/css">';
-  test_minify(assert, input, { sortAttributes: true }, output);
+  test_minify_sync(assert, input, { sortAttributes: true }, output);
 
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { sortAttributes: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { sortAttributes: false }, input);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  test_minify(assert, input, { sortAttributes: true }, output);
+  test_minify_sync(assert, input, { sortAttributes: true }, output);
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link href="app.css" rel="stylesheet" async type="text/css"></script>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     processScripts: [
       'text/html'
     ],
@@ -3205,11 +3235,11 @@ QUnit.test('sort attributes', function(assert) {
   output = '<link href="foo.css" type="text/css">' +
            '<link href="bar.css" type="text/abc" rel="stylesheet">' +
            '<link href="baz.css">';
-  test_minify(assert, input, { sortAttributes: true }, output);
+  test_minify_sync(assert, input, { sortAttributes: true }, output);
   output = '<link href="foo.css">' +
            '<link href="bar.css" rel="stylesheet" type="text/abc">' +
            '<link href="baz.css">';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     removeStyleLinkTypeAttributes: true,
     sortAttributes: true
   }, output);
@@ -3219,31 +3249,31 @@ QUnit.test('sort attributes', function(assert) {
           '<a baz bar foo></a>' +
           '<a baz foo moo></a>' +
           '<a moo baz></a>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { sortAttributes: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { sortAttributes: false }, input);
   output = '<a foo moo></a>' +
            '<a foo bar></a>' +
            '<a foo bar baz></a>' +
            '<a foo baz moo></a>' +
            '<a baz moo></a>';
-  test_minify(assert, input, { sortAttributes: true }, output);
+  test_minify_sync(assert, input, { sortAttributes: true }, output);
 
   input = '<span nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
   }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: false
   }, input);
   output = '<span foo_bar nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> ></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: true
   }, output);
 
   input = '<a 0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z></a>';
-  test_minify(assert, input, { sortAttributes: true }, input);
+  test_minify_sync(assert, input, { sortAttributes: true }, input);
 });
 
 QUnit.test('sort style classes', function(assert) {
@@ -3254,46 +3284,46 @@ QUnit.test('sort style classes', function(assert) {
           '<i class="baz bar foo"></i>' +
           '<s class="baz foo moo"></s>' +
           '<u class="moo baz"></u>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { sortClassName: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { sortClassName: false }, input);
   output = '<a class="foo moo"></a>' +
            '<b class="foo bar"></b>' +
            '<i class="foo bar baz"></i>' +
            '<s class="foo baz moo"></s>' +
            '<u class="baz moo"></u>';
-  test_minify(assert, input, { sortClassName: true }, output);
+  test_minify_sync(assert, input, { sortClassName: true }, output);
 
   input = '<a class="moo <!-- htmlmin:ignore -->bar<!-- htmlmin:ignore --> foo baz"></a>';
   output = '<a class="moo bar foo baz"></a>';
-  test_minify(assert, input, output);
-  test_minify(assert, input, { sortClassName: false }, output);
+  test_minify_sync(assert, input, output);
+  test_minify_sync(assert, input, { sortClassName: false }, output);
   output = '<a class="baz foo moo bar"></a>';
-  test_minify(assert, input, { sortClassName: true }, output);
+  test_minify_sync(assert, input, { sortClassName: true }, output);
 
   input = '<div class="nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar"></div>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
   }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: false
   }, input);
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: true
   }, input);
 
   input = '<a class="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z"></a>';
-  test_minify(assert, input, { sortClassName: false }, input);
-  test_minify(assert, input, { sortClassName: true }, input);
+  test_minify_sync(assert, input, { sortClassName: false }, input);
+  test_minify_sync(assert, input, { sortClassName: true }, input);
 
   input = '<a class="add sort keys createSorter"></a>';
-  test_minify(assert, input, { sortClassName: false }, input);
+  test_minify_sync(assert, input, { sortClassName: false }, input);
   output = '<a class="add createSorter keys sort"></a>';
-  test_minify(assert, input, { sortClassName: true }, output);
+  test_minify_sync(assert, input, { sortClassName: true }, output);
 
   input = '<span class="sprite sprite-{{sprite}}"></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
@@ -3301,7 +3331,7 @@ QUnit.test('sort style classes', function(assert) {
   }, input);
 
   input = '<span class="{{sprite}}-sprite sprite"></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
@@ -3309,7 +3339,7 @@ QUnit.test('sort style classes', function(assert) {
   }, input);
 
   input = '<span class="sprite-{{sprite}}-sprite"></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
@@ -3317,7 +3347,7 @@ QUnit.test('sort style classes', function(assert) {
   }, input);
 
   input = '<span class="{{sprite}}"></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
@@ -3326,7 +3356,7 @@ QUnit.test('sort style classes', function(assert) {
 
   input = '<span class={{sprite}}></span>';
   output = '<span class="{{sprite}}"></span>';
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
@@ -3338,41 +3368,41 @@ QUnit.test('decode entity characters', function(assert) {
   var input, output;
 
   input = '<!-- &ne; -->';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { decodeEntities: false }, input);
-  test_minify(assert, input, { decodeEntities: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { decodeEntities: false }, input);
+  test_minify_sync(assert, input, { decodeEntities: true }, input);
 
   input = '<script type="text/html">&colon;</script>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { decodeEntities: false }, input);
-  test_minify(assert, input, { decodeEntities: true }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { decodeEntities: false }, input);
+  test_minify_sync(assert, input, { decodeEntities: true }, input);
   output = '<script type="text/html">:</script>';
-  test_minify(assert, input, { decodeEntities: true, processScripts: ['text/html'] }, output);
+  test_minify_sync(assert, input, { decodeEntities: true, processScripts: ['text/html'] }, output);
 
   input = '<div style="font: &quot;monospace&#34;">foo&dollar;</div>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { decodeEntities: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { decodeEntities: false }, input);
   output = '<div style=\'font: "monospace"\'>foo$</div>';
-  test_minify(assert, input, { decodeEntities: true }, output);
+  test_minify_sync(assert, input, { decodeEntities: true }, output);
   output = '<div style="font:&quot">foo&dollar;</div>';
-  test_minify(assert, input, { minifyCSS: true }, output);
-  test_minify(assert, input, { decodeEntities: false, minifyCSS: true }, output);
+  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify_sync(assert, input, { decodeEntities: false, minifyCSS: true }, output);
   output = '<div style="font:monospace">foo$</div>';
-  test_minify(assert, input, { decodeEntities: true, minifyCSS: true }, output);
+  test_minify_sync(assert, input, { decodeEntities: true, minifyCSS: true }, output);
 
   input = '<a href="/?foo=1&amp;bar=&lt;2&gt;">baz&lt;moo&gt;&copy;</a>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { decodeEntities: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { decodeEntities: false }, input);
   output = '<a href="/?foo=1&bar=<2>">baz&lt;moo>\u00a9</a>';
-  test_minify(assert, input, { decodeEntities: true }, output);
+  test_minify_sync(assert, input, { decodeEntities: true }, output);
 
   input = '<? &amp; ?>&amp;<pre><? &amp; ?>&amp;</pre>';
-  test_minify(assert, input, input);
-  test_minify(assert, input, { collapseWhitespace: false, decodeEntities: false }, input);
-  test_minify(assert, input, { collapseWhitespace: true, decodeEntities: false }, input);
+  test_minify_sync(assert, input, input);
+  test_minify_sync(assert, input, { collapseWhitespace: false, decodeEntities: false }, input);
+  test_minify_sync(assert, input, { collapseWhitespace: true, decodeEntities: false }, input);
   output = '<? &amp; ?>&<pre><? &amp; ?>&</pre>';
-  test_minify(assert, input, { collapseWhitespace: false, decodeEntities: true }, output);
-  test_minify(assert, input, { collapseWhitespace: true, decodeEntities: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: false, decodeEntities: true }, output);
+  test_minify_sync(assert, input, { collapseWhitespace: true, decodeEntities: true }, output);
 });
 
 QUnit.test('tests from PHPTAL', function(assert) {
@@ -3454,7 +3484,7 @@ QUnit.test('tests from PHPTAL', function(assert) {
       'foo</body> </html>  <!-- bla -->'
     ]*/
   ].forEach(function(tokens) {
-    test_minify(assert, tokens[1], {
+    test_minify_sync(assert, tokens[1], {
       collapseBooleanAttributes: true,
       collapseWhitespace: true,
       removeAttributeQuotes: true,
@@ -3482,7 +3512,7 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   var input = '<div class="leaveAlone"><span> </span> foo  bar</div>';
   var output = '<div class="leaveAlone"><span> </span> foo  bar</div>';
 
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
@@ -3493,7 +3523,7 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   input = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
   output = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
 
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
@@ -3504,7 +3534,7 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   input = '<div class="leaveAlone"></div><div> foo  bar </div>';
   output = '<div class="leaveAlone"></div><div>foo bar</div>';
 
-  test_minify(assert, input, {
+  test_minify_sync(assert, input, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace

From bf469226af295e43a8ef13f6e19f1084c1091d19 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 13:27:43 +1200
Subject: [PATCH 33/66] Removed placeholders as they are not necessary when
 everything will be a placeholder.

---
 src/htmlminifier.js | 140 +++++++++++---------------------------------
 1 file changed, 33 insertions(+), 107 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 6f53a789..2522e84d 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -856,16 +856,6 @@ function minify(value, options, partialMarkup, cb) {
    */
   var asyncTasks = [];
 
-  /**
-   * A placeholder that can be inserted into the buffer in place of a string.
-   *
-   * Placeholder objects in the buffer will be removed by async tasks before
-   * completion of the `minify` function.
-   *
-   * @constructor
-   */
-  function Placeholder() {}
-
   /**
    * A group of AsyncTasks to execute in series.
    *
@@ -1024,28 +1014,20 @@ function minify(value, options, partialMarkup, cb) {
     return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);
   }
 
-  function removeStartTag(indexBound) {
-    if (typeof indexBound === 'undefined') {
-      indexBound = buffer.length;
-    }
-
-    var index = indexBound - 1;
+  function removeStartTag() {
+    var index = buffer.length - 1;
     while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
       index--;
     }
-    return buffer.splice(index, indexBound - index).length;
+    buffer.length = Math.max(0, index);
   }
 
-  function removeEndTag(indexBound) {
-    if (typeof indexBound === 'undefined') {
-      indexBound = buffer.length;
-    }
-
-    var index = indexBound - 1;
+  function removeEndTag() {
+    var index = buffer.length - 1;
     while (index > 0 && !/^<\//.test(buffer[index])) {
       index--;
     }
-    return buffer.splice(index, indexBound - index).length;
+    buffer.length = Math.max(0, index);
   }
 
   // look for trailing whitespaces, bypass any inline tags
@@ -1065,14 +1047,10 @@ function minify(value, options, partialMarkup, cb) {
   // look for trailing whitespaces from previously processed text
   // which may not be trimmed due to a following comment or an empty
   // element which has now been removed
-  function squashTrailingWhitespace(nextTag, indexBound) {
-    if (typeof indexBound === 'undefined') {
-      indexBound = buffer.length;
-    }
-
-    var charsIndex = indexBound - 1;
-    if (indexBound > 1) {
-      var item = buffer[indexBound - 1];
+  function squashTrailingWhitespace(nextTag) {
+    var charsIndex = buffer.length - 1;
+    if (buffer.length > 1) {
+      var item = buffer[buffer.length - 1];
       if (/^(?:<!|$)/.test(item) && item.indexOf(uidIgnore) === -1) {
         charsIndex--;
       }
@@ -1087,18 +1065,8 @@ function minify(value, options, partialMarkup, cb) {
         html5: options.html5,
 
         start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-          var placeholder = new Placeholder(); // Some unique reference.
-          buffer.push(placeholder);
-
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              var insertionIndex = buffer.indexOf(placeholder);
-
-              // Remove the placeholder.
-              buffer.splice(insertionIndex, 1);
-
               var lowerTag = data.tag.toLowerCase();
 
               if (lowerTag === 'svg') {
@@ -1126,12 +1094,12 @@ function minify(value, options, partialMarkup, cb) {
                 // <colgroup> may be omitted if first thing inside is <col>
                 // <tbody> may be omitted if first thing inside is <tr>
                 if (htmlTag && canRemoveParentTag(optionalStartTag, data.tag)) {
-                  insertionIndex -= removeStartTag(insertionIndex);
+                  removeStartTag();
                 }
                 optionalStartTag = '';
                 // end-data.tag-followed-by-start-data.tag omission rules
                 if (htmlTag && canRemovePrecedingTag(optionalEndTag, data.tag)) {
-                  insertionIndex -= removeEndTag(insertionIndex);
+                  removeEndTag();
                   // <colgroup> cannot be omitted if preceding </colgroup> is omitted
                   // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
                   optional = !isStartTagMandatory(optionalEndTag, data.tag);
@@ -1142,7 +1110,7 @@ function minify(value, options, partialMarkup, cb) {
               // set whitespace flags for nested tags (eg. <code> within a <pre>)
               if (options.collapseWhitespace) {
                 if (!stackNoTrimWhitespace.length) {
-                  squashTrailingWhitespace(data.tag, insertionIndex);
+                  squashTrailingWhitespace(data.tag);
                 }
                 if (!data.unary) {
                   if (!_canTrimWhitespace(data.tag, data.attrs) || stackNoTrimWhitespace.length) {
@@ -1157,7 +1125,7 @@ function minify(value, options, partialMarkup, cb) {
               var openTag = '<' + data.tag;
               var hasUnarySlash = data.unarySlash && options.keepClosingSlash;
 
-              buffer.splice(insertionIndex++, 0, openTag);
+              buffer.push(openTag);
 
               if (options.sortAttributes) {
                 options.sortAttributes(data.tag, data.attrs);
@@ -1190,20 +1158,18 @@ function minify(value, options, partialMarkup, cb) {
                 // All attributes are now normalize.
 
                 if (parts.length > 0) {
-                  buffer.splice.apply(buffer, [insertionIndex, 0, ' '].concat(parts));
-                  insertionIndex += 1 + parts.length;
+                  buffer.push(' ');
+                  buffer.push.apply(buffer, parts);
                 }
                 // start tag must never be omitted if it has any attributes
                 else if (optional && optionalStartTags(data.tag)) {
                   optionalStartTag = data.tag;
                 }
 
-                // Remove the last inserted element, modify it and put it back.
-                var lastElem = buffer.splice(--insertionIndex, 1)[0];
-                buffer.splice(insertionIndex++, 0, lastElem + (hasUnarySlash ? '/' : '') + '>');
+                buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
 
                 if (data.autoGenerated && !options.includeAutoGeneratedTags) {
-                  insertionIndex -= removeStartTag(insertionIndex);
+                  removeStartTag();
                   optionalStartTag = '';
                 }
 
@@ -1219,18 +1185,8 @@ function minify(value, options, partialMarkup, cb) {
           );
         },
         end: function(tag, attrs, autoGenerated) {
-          var placeholder = new Placeholder(); // Some unique reference.
-          buffer.push(placeholder);
-
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              var insertionIndex = buffer.indexOf(placeholder);
-
-              // Remove the placeholder.
-              buffer.splice(insertionIndex, 1);
-
               var lowerTag = data.tag.toLowerCase();
               if (lowerTag === 'svg') {
                 options = Object.getPrototypeOf(options);
@@ -1245,7 +1201,7 @@ function minify(value, options, partialMarkup, cb) {
                   }
                 }
                 else {
-                  squashTrailingWhitespace('/' + data.tag, insertionIndex);
+                  squashTrailingWhitespace('/' + data.tag);
                 }
                 if (stackNoCollapseWhitespace.length &&
                   data.tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
@@ -1262,7 +1218,7 @@ function minify(value, options, partialMarkup, cb) {
               if (options.removeOptionalTags) {
                 // <html>, <head> or <body> may be omitted if the element is empty
                 if (isElementEmpty && topLevelTags(optionalStartTag)) {
-                  insertionIndex -= removeStartTag(insertionIndex);
+                  removeStartTag();
                 }
                 optionalStartTag = '';
                 // </html> or </body> may be omitted if not followed by comment
@@ -1270,14 +1226,14 @@ function minify(value, options, partialMarkup, cb) {
                 // </p> may be omitted if no more content in non-</a> parent
                 // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
                 if (htmlTags(data.tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(data.tag))) {
-                  insertionIndex -= removeEndTag(insertionIndex);
+                  removeEndTag();
                 }
                 optionalEndTag = optionalEndTags(data.tag) ? data.tag : '';
               }
 
               if (options.removeEmptyElements && isElementEmpty && canRemoveElement(data.tag, data.attrs)) {
                 // remove last "element" from buffer
-                insertionIndex -= removeStartTag(insertionIndex);
+                removeStartTag();
                 optionalStartTag = '';
                 optionalEndTag = '';
               }
@@ -1286,7 +1242,7 @@ function minify(value, options, partialMarkup, cb) {
                   optionalEndTag = '';
                 }
                 else {
-                  buffer.splice(insertionIndex, 0, '</' + data.tag + '>');
+                  buffer.push('</' + data.tag + '>');
                 }
                 charsPrevTag = '/' + data.tag;
                 if (!inlineTags(data.tag)) {
@@ -1306,18 +1262,8 @@ function minify(value, options, partialMarkup, cb) {
           );
         },
         chars: function(text, prevTag, nextTag) {
-          var placeholder = new Placeholder(); // Some unique reference.
-          buffer.push(placeholder);
-
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              var insertionIndex = buffer.indexOf(placeholder);
-
-              // Remove the placeholder.
-              buffer.splice(insertionIndex, 1);
-
               var subtasks = [];
               data.prevTag = data.prevTag === '' ? 'comment' : data.prevTag;
               data.nextTag = data.nextTag === '' ? 'comment' : data.nextTag;
@@ -1327,13 +1273,13 @@ function minify(value, options, partialMarkup, cb) {
               if (options.collapseWhitespace) {
                 if (!stackNoTrimWhitespace.length) {
                   if (data.prevTag === 'comment') {
-                    var prevComment = buffer[insertionIndex - 1];
+                    var prevComment = buffer[buffer.length - 1];
                     if (prevComment.indexOf(uidIgnore) === -1) {
                       if (!prevComment) {
                         data.prevTag = charsPrevTag;
                       }
-                      if (insertionIndex > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
-                        var charsIndex = insertionIndex - 2;
+                      if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
+                        var charsIndex = buffer.length - 2;
                         buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
                           data.text = trailingSpaces + data.text;
                           return '';
@@ -1344,7 +1290,7 @@ function minify(value, options, partialMarkup, cb) {
                   if (data.prevTag) {
                     if (data.prevTag === '/nobr' || data.prevTag === 'wbr') {
                       if (/^\s/.test(data.text)) {
-                        var tagIndex = insertionIndex - 1;
+                        var tagIndex = buffer.length - 1;
                         while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + data.prevTag) !== 0) {
                           tagIndex--;
                         }
@@ -1362,7 +1308,7 @@ function minify(value, options, partialMarkup, cb) {
                     data.text = collapseWhitespace(data.text, options, true, true);
                   }
                   if (!data.text && /\s$/.test(currentChars) && data.prevTag && data.prevTag.charAt(0) === '/') {
-                    trimTrailingWhitespace(insertionIndex - 1, data.nextTag);
+                    trimTrailingWhitespace(buffer.length - 1, data.nextTag);
                   }
                 }
                 if (!stackNoCollapseWhitespace.length && data.nextTag !== 'html' && !(data.prevTag && data.nextTag)) {
@@ -1417,13 +1363,13 @@ function minify(value, options, partialMarkup, cb) {
                     // <html> may be omitted if first thing inside is not comment
                     // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
                     if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(data.text)) {
-                      insertionIndex -= removeStartTag(insertionIndex);
+                      removeStartTag();
                     }
                     optionalStartTag = '';
                     // </html> or </body> may be omitted if not followed by comment
                     // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
                     if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(data.text)) {
-                      insertionIndex -= removeEndTag(insertionIndex);
+                      removeEndTag();
                     }
                     optionalEndTag = '';
                   }
@@ -1443,7 +1389,7 @@ function minify(value, options, partialMarkup, cb) {
                     hasChars = true;
                   }
 
-                  buffer.splice(insertionIndex++, 0, data.text);
+                  buffer.push(data.text);
                   return cb(null, data);
                 })
               );
@@ -1458,18 +1404,8 @@ function minify(value, options, partialMarkup, cb) {
           );
         },
         comment: function(text, nonStandard) {
-          var placeholder = new Placeholder(); // Some unique reference.
-          buffer.push(placeholder);
-
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              var insertionIndex = buffer.indexOf(placeholder);
-
-              // Remove the placeholder.
-              buffer.splice(insertionIndex, 1);
-
               var subtasks = [];
               var prefix = data.nonStandard ? '<!' : '<!--';
               var suffix = data.nonStandard ? '>' : '-->';
@@ -1499,7 +1435,7 @@ function minify(value, options, partialMarkup, cb) {
                   optionalStartTag = '';
                   optionalEndTag = '';
                 }
-                buffer.splice(insertionIndex++, 0, data.text);
+                buffer.push(data.text);
                 cb(null, data);
               }));
 
@@ -1512,19 +1448,9 @@ function minify(value, options, partialMarkup, cb) {
           );
         },
         doctype: function(doctype) {
-          var placeholder = new Placeholder(); // Some unique reference.
-          buffer.push(placeholder);
-
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              // The index of the placeholder may not be the same as where it
-              // was originally inserted at; therefore we need to search for it.
-              var insertionIndex = buffer.indexOf(placeholder);
-
-              // Remove the placeholder.
-              buffer.splice(insertionIndex, 1);
-
-              buffer.splice(insertionIndex++, 0, options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(data.doctype));
+              buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(data.doctype));
               return cb(null, data);
             }, {
               doctype: doctype

From a1a5a667a51a1b9170b3dba23fbe28aeca1867bd Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 13:40:31 +1200
Subject: [PATCH 34/66] Removed unneeded data object wraps.

---
 src/htmlminifier.js | 197 ++++++++++++++++++++------------------------
 1 file changed, 89 insertions(+), 108 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 2522e84d..19c4700c 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1067,7 +1067,7 @@ function minify(value, options, partialMarkup, cb) {
         start: function(tag, attrs, unary, unarySlash, autoGenerated) {
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              var lowerTag = data.tag.toLowerCase();
+              var lowerTag = tag.toLowerCase();
 
               if (lowerTag === 'svg') {
                 options = Object.create(options);
@@ -1075,34 +1075,34 @@ function minify(value, options, partialMarkup, cb) {
                 options.caseSensitive = true;
               }
 
-              data.tag = options.caseSensitive ? data.tag : lowerTag;
+              tag = options.caseSensitive ? tag : lowerTag;
 
-              currentTag = data.tag;
-              charsPrevTag = data.tag;
-              if (!inlineTextTags(data.tag)) {
+              currentTag = tag;
+              charsPrevTag = tag;
+              if (!inlineTextTags(tag)) {
                 currentChars = '';
               }
               hasChars = false;
-              currentAttrs = data.attrs;
+              currentAttrs = attrs;
 
               var optional = options.removeOptionalTags;
               if (optional) {
-                var htmlTag = htmlTags(data.tag);
+                var htmlTag = htmlTags(tag);
                 // <html> may be omitted if first thing inside is not comment
                 // <head> may be omitted if first thing inside is an element
                 // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
                 // <colgroup> may be omitted if first thing inside is <col>
                 // <tbody> may be omitted if first thing inside is <tr>
-                if (htmlTag && canRemoveParentTag(optionalStartTag, data.tag)) {
+                if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
                   removeStartTag();
                 }
                 optionalStartTag = '';
-                // end-data.tag-followed-by-start-data.tag omission rules
-                if (htmlTag && canRemovePrecedingTag(optionalEndTag, data.tag)) {
+                // end-tag-followed-by-start-tag omission rules
+                if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
                   removeEndTag();
                   // <colgroup> cannot be omitted if preceding </colgroup> is omitted
                   // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
-                  optional = !isStartTagMandatory(optionalEndTag, data.tag);
+                  optional = !isStartTagMandatory(optionalEndTag, tag);
                 }
                 optionalEndTag = '';
               }
@@ -1110,25 +1110,25 @@ function minify(value, options, partialMarkup, cb) {
               // set whitespace flags for nested tags (eg. <code> within a <pre>)
               if (options.collapseWhitespace) {
                 if (!stackNoTrimWhitespace.length) {
-                  squashTrailingWhitespace(data.tag);
+                  squashTrailingWhitespace(tag);
                 }
-                if (!data.unary) {
-                  if (!_canTrimWhitespace(data.tag, data.attrs) || stackNoTrimWhitespace.length) {
-                    stackNoTrimWhitespace.push(data.tag);
+                if (!unary) {
+                  if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
+                    stackNoTrimWhitespace.push(tag);
                   }
-                  if (!_canCollapseWhitespace(data.tag, data.attrs) || stackNoCollapseWhitespace.length) {
-                    stackNoCollapseWhitespace.push(data.tag);
+                  if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
+                    stackNoCollapseWhitespace.push(tag);
                   }
                 }
               }
 
-              var openTag = '<' + data.tag;
-              var hasUnarySlash = data.unarySlash && options.keepClosingSlash;
+              var openTag = '<' + tag;
+              var hasUnarySlash = unarySlash && options.keepClosingSlash;
 
               buffer.push(openTag);
 
               if (options.sortAttributes) {
-                options.sortAttributes(data.tag, data.attrs);
+                options.sortAttributes(tag, attrs);
               }
 
               var parts = [];
@@ -1140,7 +1140,7 @@ function minify(value, options, partialMarkup, cb) {
                 if (--i >= 0) {
                   var innerLoopResult;
                   // Normalize all the attributes in series.
-                  normalizeAttr(data.attrs[i], data.attrs, data.tag, options, function(error, normalized) {
+                  normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
                     if (error) {
                       return cb(error);
                     }
@@ -1162,55 +1162,49 @@ function minify(value, options, partialMarkup, cb) {
                   buffer.push.apply(buffer, parts);
                 }
                 // start tag must never be omitted if it has any attributes
-                else if (optional && optionalStartTags(data.tag)) {
-                  optionalStartTag = data.tag;
+                else if (optional && optionalStartTags(tag)) {
+                  optionalStartTag = tag;
                 }
 
                 buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
 
-                if (data.autoGenerated && !options.includeAutoGeneratedTags) {
+                if (autoGenerated && !options.includeAutoGeneratedTags) {
                   removeStartTag();
                   optionalStartTag = '';
                 }
 
                 return cb(null, data);
-              })(data.attrs.length);
-            }, {
-              tag: tag,
-              attrs: attrs,
-              unary: unary,
-              unarySlash: unarySlash,
-              autoGenerated: autoGenerated
+              })(attrs.length);
             })
           );
         },
         end: function(tag, attrs, autoGenerated) {
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              var lowerTag = data.tag.toLowerCase();
+              var lowerTag = tag.toLowerCase();
               if (lowerTag === 'svg') {
                 options = Object.getPrototypeOf(options);
               }
-              data.tag = options.caseSensitive ? data.tag : lowerTag;
+              tag = options.caseSensitive ? tag : lowerTag;
 
               // check if current tag is in a whitespace stack
               if (options.collapseWhitespace) {
                 if (stackNoTrimWhitespace.length) {
-                  if (data.tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+                  if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
                     stackNoTrimWhitespace.pop();
                   }
                 }
                 else {
-                  squashTrailingWhitespace('/' + data.tag);
+                  squashTrailingWhitespace('/' + tag);
                 }
                 if (stackNoCollapseWhitespace.length &&
-                  data.tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+                  tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
                   stackNoCollapseWhitespace.pop();
                 }
               }
 
               var isElementEmpty = false;
-              if (data.tag === currentTag) {
+              if (tag === currentTag) {
                 currentTag = '';
                 isElementEmpty = !hasChars;
               }
@@ -1225,27 +1219,27 @@ function minify(value, options, partialMarkup, cb) {
                 // </head> may be omitted if not followed by space or comment
                 // </p> may be omitted if no more content in non-</a> parent
                 // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
-                if (htmlTags(data.tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(data.tag))) {
+                if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
                   removeEndTag();
                 }
-                optionalEndTag = optionalEndTags(data.tag) ? data.tag : '';
+                optionalEndTag = optionalEndTags(tag) ? tag : '';
               }
 
-              if (options.removeEmptyElements && isElementEmpty && canRemoveElement(data.tag, data.attrs)) {
+              if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
                 // remove last "element" from buffer
                 removeStartTag();
                 optionalStartTag = '';
                 optionalEndTag = '';
               }
               else {
-                if (data.autoGenerated && !options.includeAutoGeneratedTags) {
+                if (autoGenerated && !options.includeAutoGeneratedTags) {
                   optionalEndTag = '';
                 }
                 else {
-                  buffer.push('</' + data.tag + '>');
+                  buffer.push('</' + tag + '>');
                 }
-                charsPrevTag = '/' + data.tag;
-                if (!inlineTags(data.tag)) {
+                charsPrevTag = '/' + tag;
+                if (!inlineTags(tag)) {
                   currentChars = '';
                 }
                 else if (isElementEmpty) {
@@ -1254,10 +1248,6 @@ function minify(value, options, partialMarkup, cb) {
               }
 
               return cb(null, data);
-            }, {
-              tag: tag,
-              attrs: attrs,
-              autoGenerated: autoGenerated
             })
           );
         },
@@ -1265,67 +1255,67 @@ function minify(value, options, partialMarkup, cb) {
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
               var subtasks = [];
-              data.prevTag = data.prevTag === '' ? 'comment' : data.prevTag;
-              data.nextTag = data.nextTag === '' ? 'comment' : data.nextTag;
-              if (options.decodeEntities && data.text && !specialContentTags(currentTag)) {
-                data.text = decode(data.text);
+              prevTag = prevTag === '' ? 'comment' : prevTag;
+              nextTag = nextTag === '' ? 'comment' : nextTag;
+              if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+                text = decode(text);
               }
               if (options.collapseWhitespace) {
                 if (!stackNoTrimWhitespace.length) {
-                  if (data.prevTag === 'comment') {
+                  if (prevTag === 'comment') {
                     var prevComment = buffer[buffer.length - 1];
                     if (prevComment.indexOf(uidIgnore) === -1) {
                       if (!prevComment) {
-                        data.prevTag = charsPrevTag;
+                        prevTag = charsPrevTag;
                       }
                       if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
                         var charsIndex = buffer.length - 2;
                         buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
-                          data.text = trailingSpaces + data.text;
+                          text = trailingSpaces + text;
                           return '';
                         });
                       }
                     }
                   }
-                  if (data.prevTag) {
-                    if (data.prevTag === '/nobr' || data.prevTag === 'wbr') {
-                      if (/^\s/.test(data.text)) {
+                  if (prevTag) {
+                    if (prevTag === '/nobr' || prevTag === 'wbr') {
+                      if (/^\s/.test(text)) {
                         var tagIndex = buffer.length - 1;
-                        while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + data.prevTag) !== 0) {
+                        while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
                           tagIndex--;
                         }
                         trimTrailingWhitespace(tagIndex - 1, 'br');
                       }
                     }
-                    else if (inlineTextTags(data.prevTag.charAt(0) === '/' ? data.prevTag.slice(1) : data.prevTag)) {
-                      data.text = collapseWhitespace(data.text, options, /(?:^|\s)$/.test(currentChars));
+                    else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+                      text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
                     }
                   }
-                  if (data.prevTag || data.nextTag) {
-                    data.text = collapseWhitespaceSmart(data.text, data.prevTag, data.nextTag, options);
+                  if (prevTag || nextTag) {
+                    text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
                   }
                   else {
-                    data.text = collapseWhitespace(data.text, options, true, true);
+                    text = collapseWhitespace(text, options, true, true);
                   }
-                  if (!data.text && /\s$/.test(currentChars) && data.prevTag && data.prevTag.charAt(0) === '/') {
-                    trimTrailingWhitespace(buffer.length - 1, data.nextTag);
+                  if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
+                    trimTrailingWhitespace(buffer.length - 1, nextTag);
                   }
                 }
-                if (!stackNoCollapseWhitespace.length && data.nextTag !== 'html' && !(data.prevTag && data.nextTag)) {
-                  data.text = collapseWhitespace(data.text, options, false, false, true);
+                if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
+                  text = collapseWhitespace(text, options, false, false, true);
                 }
               }
               if (options.processScripts && specialContentTags(currentTag)) {
                 subtasks.push(new AsyncTask(function(data, cb) {
-                  processScript(data.text, options, currentAttrs, function(error, result) {
-                    data.text = result;
+                  processScript(text, options, currentAttrs, function(error, result) {
+                    text = result;
                     return cb(error, data);
                   });
                 }));
               }
               if (isExecutableScript(currentTag, currentAttrs)) {
                 subtasks.push(new AsyncTask(function(data, cb) {
-                  var result = options.minifyJS(data.text, null, minifyJS_cb);
+                  var result = options.minifyJS(text, null, minifyJS_cb);
                   if (typeof result !== 'undefined') {
                     return minifyJS_cb(null, result);
                   }
@@ -1334,7 +1324,7 @@ function minify(value, options, partialMarkup, cb) {
                   function minifyJS_cb(error, result) {
                     if (!callbackCalled) {
                       callbackCalled = true;
-                      data.text = result;
+                      text = result;
                       return cb(error, data);
                     }
                   }
@@ -1342,7 +1332,7 @@ function minify(value, options, partialMarkup, cb) {
               }
               if (isStyleSheet(currentTag, currentAttrs)) {
                 subtasks.push(new AsyncTask(function(data, cb) {
-                  var result = options.minifyCSS(data.text, null, minifyCSS_cb);
+                  var result = options.minifyCSS(text, null, minifyCSS_cb);
                   if (typeof result !== 'undefined') {
                     return minifyCSS_cb(null, result);
                   }
@@ -1351,7 +1341,7 @@ function minify(value, options, partialMarkup, cb) {
                   function minifyCSS_cb(error, result) {
                     if (!callbackCalled) {
                       callbackCalled = true;
-                      data.text = result;
+                      text = result;
                       return cb(error, data);
                     }
                   }
@@ -1359,47 +1349,43 @@ function minify(value, options, partialMarkup, cb) {
               }
               subtasks.push(
                 new AsyncTask(function(data, cb) {
-                  if (options.removeOptionalTags && data.text) {
+                  if (options.removeOptionalTags && text) {
                     // <html> may be omitted if first thing inside is not comment
                     // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-                    if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(data.text)) {
+                    if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
                       removeStartTag();
                     }
                     optionalStartTag = '';
                     // </html> or </body> may be omitted if not followed by comment
                     // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-                    if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(data.text)) {
+                    if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
                       removeEndTag();
                     }
                     optionalEndTag = '';
                   }
-                  charsPrevTag = /^\s*$/.test(data.text) ? data.prevTag : 'comment';
-                  if (options.decodeEntities && data.text && !specialContentTags(currentTag)) {
+                  charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+                  if (options.decodeEntities && text && !specialContentTags(currentTag)) {
                     // semi-colon can be omitted
                     // https://mathiasbynens.be/notes/ambiguous-ampersands
-                    data.text = data.text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+                    text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
                   }
                   if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-                    data.text = data.text.replace(uidPattern, function(match, prefix, index) {
+                    text = text.replace(uidPattern, function(match, prefix, index) {
                       return ignoredCustomMarkupChunks[+index][0];
                     });
                   }
-                  currentChars += data.text;
-                  if (data.text) {
+                  currentChars += text;
+                  if (text) {
                     hasChars = true;
                   }
 
-                  buffer.push(data.text);
+                  buffer.push(text);
                   return cb(null, data);
                 })
               );
 
               // Run the subtasks.
               new AsyncTaskGroup(subtasks, data).exec(cb);
-            }, {
-              text: text,
-              prevTag: prevTag,
-              nextTag: nextTag
             })
           );
         },
@@ -1407,53 +1393,48 @@ function minify(value, options, partialMarkup, cb) {
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
               var subtasks = [];
-              var prefix = data.nonStandard ? '<!' : '<!--';
-              var suffix = data.nonStandard ? '>' : '-->';
-              if (isConditionalComment(data.text)) {
+              var prefix = nonStandard ? '<!' : '<!--';
+              var suffix = nonStandard ? '>' : '-->';
+              if (isConditionalComment(text)) {
                 subtasks.push(new AsyncTask(function(data, cb) {
-                  cleanConditionalComment(data.text, options, function(error, result) {
-                    data.text = prefix + result + suffix;
+                  cleanConditionalComment(text, options, function(error, result) {
+                    text = prefix + result + suffix;
                     return cb(error, data);
                   });
                 }));
               }
               else if (options.removeComments) {
-                if (isIgnoredComment(data.text, options)) {
-                  data.text = '<!--' + data.text + '-->';
+                if (isIgnoredComment(text, options)) {
+                  text = '<!--' + text + '-->';
                 }
                 else {
-                  data.text = '';
+                  text = '';
                 }
               }
               else {
-                data.text = prefix + data.text + suffix;
+                text = prefix + text + suffix;
               }
 
               subtasks.push(new AsyncTask(function(data, cb) {
-                if (options.removeOptionalTags && data.text) {
+                if (options.removeOptionalTags && text) {
                   // preceding comments suppress tag omissions
                   optionalStartTag = '';
                   optionalEndTag = '';
                 }
-                buffer.push(data.text);
+                buffer.push(text);
                 cb(null, data);
               }));
 
               // Run the subtasks.
               new AsyncTaskGroup(subtasks, data).exec(cb);
-            }, {
-              text: text,
-              nonStandard: nonStandard
             })
           );
         },
         doctype: function(doctype) {
           asyncTasks.push(
             new AsyncTask(function(data, cb) {
-              buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(data.doctype));
+              buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
               return cb(null, data);
-            }, {
-              doctype: doctype
             })
           );
         },
@@ -1513,7 +1494,7 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  function callCallBack() {
+  function invokeCallBack() {
     try {
       return cb(null, finalize());
     }
@@ -1524,7 +1505,7 @@ function minify(value, options, partialMarkup, cb) {
 
   // No async tasks?
   if (asyncTasks.length === 0) {
-    return callCallBack();
+    return invokeCallBack();
   }
 
   new AsyncTaskGroup(asyncTasks)
@@ -1532,7 +1513,7 @@ function minify(value, options, partialMarkup, cb) {
       if (error) {
         return cb(error);
       }
-      return callCallBack();
+      return invokeCallBack();
     });
   return;
 }

From 35d3d264bd4c078039522d821b80e5154e7d84d1 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 14:15:30 +1200
Subject: [PATCH 35/66] Tasks no longer have data associated with them.

---
 src/htmlminifier.js | 162 ++++++++++++++++++++------------------------
 1 file changed, 73 insertions(+), 89 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 19c4700c..e90d1966 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -850,57 +850,60 @@ function minify(value, options, partialMarkup, cb) {
       uidPattern;
 
   /**
-   * Set of tasks to perform asynchronously.
+   * Set of tasks to perform.
    *
-   * @type {Array<AsyncTask|AsyncTaskGroup>}
+   * @type {Array<Task|TaskGroup>}
    */
-  var asyncTasks = [];
+  var tasks = [];
 
   /**
-   * A group of AsyncTasks to execute in series.
+   * A task.
    *
    * @constructor
    *
-   * @param {AsyncTask[]} [tasks]
-   * @param {*} [data]
-   * @param {Function<Error, *>} [cb]
+   * @param {Function<string, Function<Error>>} task
    */
-  function AsyncTaskGroup(tasks, data, cb) {
-    this.tasks = tasks ? tasks : [];
-    this.data = data;
-    this.cb = cb;
+  function Task(task) {
+    this.task = task;
   }
 
   /**
-   * Asynchronously runs all tasks in this group in series.
+   * Execute this task.
    *
-   * @param {Function<Error, *>} cb
+   * @param {Function<Error>} cb
    */
-  AsyncTaskGroup.prototype.exec = function(cb) {
-    function multiCb(error, result) {
-      if (typeof this.cb === 'function') {
-        this.cb(error, result);
-      }
-      if (typeof cb === 'function') {
-        cb(error, result);
-      }
-    }
+  Task.prototype.exec = function(cb) {
+    this.task(cb);
+  };
+
+  /**
+   * A group of Tasks to execute in series.
+   *
+   * @constructor
+   *
+   * @param {Task[]} [tasks]
+   */
+  function TaskGroup(tasks) {
+    this.tasks = tasks ? tasks : [];
+  }
 
+  /**
+   * Run all tasks in this group in series.
+   *
+   * @param {Function<Error>} cb
+   */
+  TaskGroup.prototype.exec = function(cb) {
     /**
      * Run the task at the given index, giving it a callback to run the next
      * task the same way.
      *
-     * @param {string} data
      * @param {number} index
      */
-    (function implementation(data, index) {
+    (function implementation(index) {
       if (index < this.tasks.length) {
         try {
-          if (typeof this.tasks[index].data === 'undefined') {
-            this.tasks[index].data = data;
-          }
           this.tasks[index].exec(
-            function(error, result) {
+            function(error) {
               if (error) {
                 throw error;
               }
@@ -910,40 +913,18 @@ function minify(value, options, partialMarkup, cb) {
               }
               this.tasks[index].cbExecuted = true;
 
-              implementation.call(this, result, index + 1);
+              implementation.call(this, index + 1);
             }.bind(this)
           );
         }
         catch (error) {
-          multiCb.call(this, error);
+          cb(error);
         }
       }
       else {
-        multiCb.call(this, null, data);
+        cb();
       }
-    }.bind(this))(this.data, 0);
-  };
-
-  /**
-   * An async task.
-   *
-   * @constructor
-   *
-   * @param {Function<string, Function<Error, *>>} task
-   * @param {*} [data]
-   */
-  function AsyncTask(task, data) {
-    this.task = task;
-    this.data = data;
-  }
-
-  /**
-   * Execute this task.
-   *
-   * @param {Function<Error, *>} cb
-   */
-  AsyncTask.prototype.exec = function(cb) {
-    this.task(this.data, cb);
+    }.bind(this))(0);
   };
 
   // temporarily replace ignored chunks with comments,
@@ -1001,7 +982,7 @@ function minify(value, options, partialMarkup, cb) {
 
   if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||
       options.sortClassName && typeof options.sortClassName !== 'function') {
-    asyncTasks.push(new AsyncTask(function(data, cb) {
+    tasks.push(new Task(function(cb) {
       createSortFns(value, options, uidIgnore, uidAttr, cb);
     }));
   }
@@ -1058,15 +1039,17 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
-  asyncTasks.push(new AsyncTask(function(data, cb) {
+  tasks.push(new Task(function(cb) {
     try {
+      var subtasks = [];
+
       new HTMLParser(value, {
         partialMarkup: partialMarkup,
         html5: options.html5,
 
         start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-          asyncTasks.push(
-            new AsyncTask(function(data, cb) {
+          subtasks.push(
+            new Task(function(cb) {
               var lowerTag = tag.toLowerCase();
 
               if (lowerTag === 'svg') {
@@ -1173,14 +1156,14 @@ function minify(value, options, partialMarkup, cb) {
                   optionalStartTag = '';
                 }
 
-                return cb(null, data);
+                return cb();
               })(attrs.length);
             })
           );
         },
         end: function(tag, attrs, autoGenerated) {
-          asyncTasks.push(
-            new AsyncTask(function(data, cb) {
+          subtasks.push(
+            new Task(function(cb) {
               var lowerTag = tag.toLowerCase();
               if (lowerTag === 'svg') {
                 options = Object.getPrototypeOf(options);
@@ -1247,13 +1230,13 @@ function minify(value, options, partialMarkup, cb) {
                 }
               }
 
-              return cb(null, data);
+              return cb();
             })
           );
         },
         chars: function(text, prevTag, nextTag) {
-          asyncTasks.push(
-            new AsyncTask(function(data, cb) {
+          subtasks.push(
+            new Task(function(cb) {
               var subtasks = [];
               prevTag = prevTag === '' ? 'comment' : prevTag;
               nextTag = nextTag === '' ? 'comment' : nextTag;
@@ -1306,15 +1289,15 @@ function minify(value, options, partialMarkup, cb) {
                 }
               }
               if (options.processScripts && specialContentTags(currentTag)) {
-                subtasks.push(new AsyncTask(function(data, cb) {
+                subtasks.push(new Task(function(cb) {
                   processScript(text, options, currentAttrs, function(error, result) {
                     text = result;
-                    return cb(error, data);
+                    return cb(error);
                   });
                 }));
               }
               if (isExecutableScript(currentTag, currentAttrs)) {
-                subtasks.push(new AsyncTask(function(data, cb) {
+                subtasks.push(new Task(function(cb) {
                   var result = options.minifyJS(text, null, minifyJS_cb);
                   if (typeof result !== 'undefined') {
                     return minifyJS_cb(null, result);
@@ -1325,13 +1308,13 @@ function minify(value, options, partialMarkup, cb) {
                     if (!callbackCalled) {
                       callbackCalled = true;
                       text = result;
-                      return cb(error, data);
+                      return cb(error);
                     }
                   }
                 }));
               }
               if (isStyleSheet(currentTag, currentAttrs)) {
-                subtasks.push(new AsyncTask(function(data, cb) {
+                subtasks.push(new Task(function(cb) {
                   var result = options.minifyCSS(text, null, minifyCSS_cb);
                   if (typeof result !== 'undefined') {
                     return minifyCSS_cb(null, result);
@@ -1342,13 +1325,13 @@ function minify(value, options, partialMarkup, cb) {
                     if (!callbackCalled) {
                       callbackCalled = true;
                       text = result;
-                      return cb(error, data);
+                      return cb(error);
                     }
                   }
                 }));
               }
               subtasks.push(
-                new AsyncTask(function(data, cb) {
+                new Task(function(cb) {
                   if (options.removeOptionalTags && text) {
                     // <html> may be omitted if first thing inside is not comment
                     // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
@@ -1380,26 +1363,26 @@ function minify(value, options, partialMarkup, cb) {
                   }
 
                   buffer.push(text);
-                  return cb(null, data);
+                  return cb(null);
                 })
               );
 
-              // Run the subtasks.
-              new AsyncTaskGroup(subtasks, data).exec(cb);
+              // Run this task's subtasks.
+              new TaskGroup(subtasks).exec(cb);
             })
           );
         },
         comment: function(text, nonStandard) {
-          asyncTasks.push(
-            new AsyncTask(function(data, cb) {
+          subtasks.push(
+            new Task(function(cb) {
               var subtasks = [];
               var prefix = nonStandard ? '<!' : '<!--';
               var suffix = nonStandard ? '>' : '-->';
               if (isConditionalComment(text)) {
-                subtasks.push(new AsyncTask(function(data, cb) {
+                subtasks.push(new Task(function(cb) {
                   cleanConditionalComment(text, options, function(error, result) {
                     text = prefix + result + suffix;
-                    return cb(error, data);
+                    return cb(error);
                   });
                 }));
               }
@@ -1415,26 +1398,26 @@ function minify(value, options, partialMarkup, cb) {
                 text = prefix + text + suffix;
               }
 
-              subtasks.push(new AsyncTask(function(data, cb) {
+              subtasks.push(new Task(function(cb) {
                 if (options.removeOptionalTags && text) {
                   // preceding comments suppress tag omissions
                   optionalStartTag = '';
                   optionalEndTag = '';
                 }
                 buffer.push(text);
-                cb(null, data);
+                cb();
               }));
 
-              // Run the subtasks.
-              new AsyncTaskGroup(subtasks, data).exec(cb);
+              // Run this task's subtasks.
+              new TaskGroup(subtasks).exec(cb);
             })
           );
         },
         doctype: function(doctype) {
-          asyncTasks.push(
-            new AsyncTask(function(data, cb) {
+          subtasks.push(
+            new Task(function(cb) {
               buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
-              return cb(null, data);
+              return cb();
             })
           );
         },
@@ -1442,7 +1425,8 @@ function minify(value, options, partialMarkup, cb) {
         customAttrSurround: options.customAttrSurround
       });
 
-      return cb();
+      // Run this task's subtasks.
+      new TaskGroup(subtasks).exec(cb);
     }
     catch (error) {
       return cb(error);
@@ -1503,12 +1487,12 @@ function minify(value, options, partialMarkup, cb) {
     }
   }
 
-  // No async tasks?
-  if (asyncTasks.length === 0) {
+  // No tasks?
+  if (tasks.length === 0) {
     return invokeCallBack();
   }
 
-  new AsyncTaskGroup(asyncTasks)
+  new TaskGroup(tasks)
     .exec(function(error) {
       if (error) {
         return cb(error);

From d8613ad98dd1bfa3ce8f759ce008ab46049bafa1 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 14:20:07 +1200
Subject: [PATCH 36/66] Moved 'isLast' into function loop to mimic original for
 loop scoping.

---
 src/htmlminifier.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index e90d1966..e169c202 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1115,10 +1115,9 @@ function minify(value, options, partialMarkup, cb) {
               }
 
               var parts = [];
-              var isLast = true;
 
               // Loop through all the attributes and normalize them.
-              (function normalizeAttrLoop(i) {
+              (function normalizeAttrLoop(i, isLast) {
                 // Attributes to normalize?
                 if (--i >= 0) {
                   var innerLoopResult;
@@ -1133,7 +1132,7 @@ function minify(value, options, partialMarkup, cb) {
                       isLast = false;
                     }
 
-                    innerLoopResult = normalizeAttrLoop(i);
+                    innerLoopResult = normalizeAttrLoop(i, isLast);
                   });
                   return innerLoopResult;
                 }
@@ -1157,7 +1156,7 @@ function minify(value, options, partialMarkup, cb) {
                 }
 
                 return cb();
-              })(attrs.length);
+              })(attrs.length, true);
             })
           );
         },

From bb191cf652aef9fa10152f57cec28de3f6d2d990 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 14:25:31 +1200
Subject: [PATCH 37/66] Slight code style improvements.

---
 src/htmlminifier.js | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index e169c202..e8aae832 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1478,19 +1478,17 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   function invokeCallBack() {
+    var result;
     try {
-      return cb(null, finalize());
+      result = finalize();
     }
     catch (error) {
       return cb(error);
     }
+    return cb(null, result);
   }
 
-  // No tasks?
-  if (tasks.length === 0) {
-    return invokeCallBack();
-  }
-
+  // Run the tasks.
   new TaskGroup(tasks)
     .exec(function(error) {
       if (error) {

From 29c71eab60b4d9c27ad3ad21a589ba843050d7fa Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 14:40:52 +1200
Subject: [PATCH 38/66] Added missing callbacks.

---
 src/htmlminifier.js | 56 +++++++++++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 20 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index e8aae832..7469e2e1 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -257,10 +257,14 @@ function isSrcset(attrName, tag) {
   return attrName === 'srcset' && srcsetTags(tag);
 }
 
-function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
+function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
   if (attrValue && isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
-    return options.minifyJS(attrValue, true); // TODO: add callback
+    attrValue = options.minifyJS(attrValue, true, cb);
+    if (typeof attrValue !== 'undefined') {
+      return cb(null, attrValue);
+    }
+    return;
   }
   else if (attrName === 'class') {
     attrValue = trimWhitespace(attrValue);
@@ -270,14 +274,14 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
     else {
       attrValue = collapseWhitespaceAll(attrValue);
     }
-    return attrValue;
+    return cb(null, attrValue);
   }
   else if (isUriTypeAttribute(attrName, tag)) {
     attrValue = trimWhitespace(attrValue);
-    return isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue);
+    return cb(null, isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue));
   }
   else if (isNumberTypeAttribute(attrName, tag)) {
-    return trimWhitespace(attrValue);
+    return cb(null, trimWhitespace(attrValue));
   }
   else if (attrName === 'style') {
     attrValue = trimWhitespace(attrValue);
@@ -285,9 +289,13 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
       if (/;$/.test(attrValue) && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
         attrValue = attrValue.replace(/\s*;$/, ';');
       }
-      attrValue = options.minifyCSS(attrValue, 'inline'); // TODO: add callback
+      attrValue = options.minifyCSS(attrValue, 'inline', cb);
+      if (typeof attrValue !== 'undefined') {
+        return cb(null, attrValue);
+      }
+      return;
     }
-    return attrValue;
+    return cb(null, attrValue);
   }
   else if (isSrcset(attrName, tag)) {
     // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
@@ -322,9 +330,13 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   }
   else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
-    return options.minifyCSS(attrValue, 'media'); // TODO: add callback
+    attrValue = options.minifyCSS(attrValue, 'media', cb);
+    if (typeof attrValue !== 'undefined') {
+      return cb(null, attrValue);
+    }
+    return;
   }
-  return attrValue;
+  return cb(null, attrValue);
 }
 
 function isMetaViewport(tag, attrs) {
@@ -540,21 +552,25 @@ function normalizeAttr(attr, attrs, tag, options, cb) {
     return cb();
   }
 
-  attrValue = cleanAttributeValue(tag, attrName, attrValue, options, attrs);
+  cleanAttributeValue(tag, attrName, attrValue, options, attrs, function(error, attrValue) {
+    if (error) {
+      return cb(error);
+    }
 
-  if (options.removeEmptyAttributes &&
+    if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
-    return cb();
-  }
+      return cb();
+    }
 
-  if (options.decodeEntities && attrValue) {
-    attrValue = attrValue.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp;$1');
-  }
+    if (options.decodeEntities && attrValue) {
+      attrValue = attrValue.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp;$1');
+    }
 
-  return cb(null, {
-    attr: attr,
-    name: attrName,
-    value: attrValue
+    return cb(null, {
+      attr: attr,
+      name: attrName,
+      value: attrValue
+    });
   });
 }
 

From d6b2bf31c5d2f699dfb397711f15c62312f55324 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 15:22:58 +1200
Subject: [PATCH 39/66] Fixed bad implementation of cleanConditionalComment
 callback support.

---
 src/htmlminifier.js | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 7469e2e1..d4e4380b 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -371,11 +371,15 @@ function unwrapMediaQuery(text) {
 }
 
 function cleanConditionalComment(comment, options, cb) {
-  return options.processConditionalComments ? comment.replace(/^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, function(match, prefix, text, suffix) {
-    return minify(text, options, true, function(error, result) {
-      return cb(error, prefix + result + suffix);
-    });
-  }) : cb(null, comment);
+  if (options.processConditionalComments) {
+    var replaceDetails = comment.match(/^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/);
+    if (replaceDetails) {
+      return minify(replaceDetails[2], options, true, function(error, result) {
+        return cb(error, replaceDetails[1] + result + replaceDetails[3]);
+      });
+    }
+  }
+  return cb(null, comment);
 }
 
 function processScript(text, options, currentAttrs, cb) {

From 0316fb91b2f48eff667cb7863f1055d0418eac41 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 17:37:38 +1200
Subject: [PATCH 40/66] Removed already fixed fixme.

---
 tests/minifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index fa50f2b5..d4d73d87 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -597,7 +597,7 @@ QUnit.test('ignoring comments', function(assert) {
   input = '<p rel="<!-- comment in attribute -->" title="<!--! ignored comment in attribute -->">foo</p>';
   test_minify_sync(assert, input, { removeComments: true }, input);
 });
-// FIXME:
+
 QUnit.test('conditional comments', function(assert) {
   var input, output;
 

From 818f20a6a039e613f54b209c74b305679285e9d8 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 17:39:36 +1200
Subject: [PATCH 41/66] Fixed issue with minifyCSS and minifyJS functions
 taking an error in their callback.

---
 src/htmlminifier.js | 36 ++++++++++++++++--------------------
 tests/minifier.js   |  4 ++--
 2 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index d4e4380b..56c5a321 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -262,7 +262,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     attrValue = options.minifyJS(attrValue, true, cb);
     if (typeof attrValue !== 'undefined') {
-      return cb(null, attrValue);
+      return cb(attrValue);
     }
     return;
   }
@@ -274,14 +274,14 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
     else {
       attrValue = collapseWhitespaceAll(attrValue);
     }
-    return cb(null, attrValue);
+    return cb(attrValue);
   }
   else if (isUriTypeAttribute(attrName, tag)) {
     attrValue = trimWhitespace(attrValue);
-    return cb(null, isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue));
+    return cb(isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue));
   }
   else if (isNumberTypeAttribute(attrName, tag)) {
-    return cb(null, trimWhitespace(attrValue));
+    return cb(trimWhitespace(attrValue));
   }
   else if (attrName === 'style') {
     attrValue = trimWhitespace(attrValue);
@@ -291,11 +291,11 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
       }
       attrValue = options.minifyCSS(attrValue, 'inline', cb);
       if (typeof attrValue !== 'undefined') {
-        return cb(null, attrValue);
+        return cb(attrValue);
       }
       return;
     }
-    return cb(null, attrValue);
+    return cb(attrValue);
   }
   else if (isSrcset(attrName, tag)) {
     // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
@@ -332,11 +332,11 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
     attrValue = trimWhitespace(attrValue);
     attrValue = options.minifyCSS(attrValue, 'media', cb);
     if (typeof attrValue !== 'undefined') {
-      return cb(null, attrValue);
+      return cb(attrValue);
     }
     return;
   }
-  return cb(null, attrValue);
+  return cb(attrValue);
 }
 
 function isMetaViewport(tag, attrs) {
@@ -556,11 +556,7 @@ function normalizeAttr(attr, attrs, tag, options, cb) {
     return cb();
   }
 
-  cleanAttributeValue(tag, attrName, attrValue, options, attrs, function(error, attrValue) {
-    if (error) {
-      return cb(error);
-    }
-
+  cleanAttributeValue(tag, attrName, attrValue, options, attrs, function(attrValue) {
     if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
       return cb();
@@ -1319,15 +1315,15 @@ function minify(value, options, partialMarkup, cb) {
                 subtasks.push(new Task(function(cb) {
                   var result = options.minifyJS(text, null, minifyJS_cb);
                   if (typeof result !== 'undefined') {
-                    return minifyJS_cb(null, result);
+                    return minifyJS_cb(result);
                   }
 
                   var callbackCalled = false;
-                  function minifyJS_cb(error, result) {
+                  function minifyJS_cb(result) {
                     if (!callbackCalled) {
                       callbackCalled = true;
                       text = result;
-                      return cb(error);
+                      return cb();
                     }
                   }
                 }));
@@ -1336,15 +1332,15 @@ function minify(value, options, partialMarkup, cb) {
                 subtasks.push(new Task(function(cb) {
                   var result = options.minifyCSS(text, null, minifyCSS_cb);
                   if (typeof result !== 'undefined') {
-                    return minifyCSS_cb(null, result);
+                    return minifyCSS_cb(result);
                   }
 
                   var callbackCalled = false;
-                  function minifyCSS_cb(error, result) {
+                  function minifyCSS_cb(result) {
                     if (!callbackCalled) {
                       callbackCalled = true;
                       text = result;
-                      return cb(error);
+                      return cb();
                     }
                   }
                 }));
@@ -1382,7 +1378,7 @@ function minify(value, options, partialMarkup, cb) {
                   }
 
                   buffer.push(text);
-                  return cb(null);
+                  return cb();
                 })
               );
 
diff --git a/tests/minifier.js b/tests/minifier.js
index d4d73d87..0200b610 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -39,14 +39,14 @@ function test_minify_sync(assert, input, options, output, description) {
     if (typeof options.minifyJS === 'function') {
       var minifyJS = options.minifyJS;
       options.minifyJS = function(text, inline, callback) {
-        callback(null, minifyJS(text, inline));
+        callback(minifyJS(text, inline));
       };
     }
     // Convert `minifyCSS` to use a callback.
     if (typeof options.minifyCSS === 'function') {
       var minifyCSS = options.minifyCSS;
       options.minifyCSS = function(text, type, callback) {
-        callback(null, minifyCSS(text, type));
+        callback(minifyCSS(text, type));
       };
     }
   }

From 58d6d4294baff8d8c090efda24b5e94b2caddeeb Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 17:40:24 +1200
Subject: [PATCH 42/66] Added async tests.

---
 tests/minifier.js | 144 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)

diff --git a/tests/minifier.js b/tests/minifier.js
index 0200b610..54b981ab 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -137,6 +137,87 @@ function test_minify_sync_error(assert, input, options, errorMatcher, descriptio
   }
 }
 
+/**
+ * Test the minify function asynchronously.
+ *
+ * @param {QUnit.assert} assert
+ * @param {string} input
+ * @param {Object} [options]
+ * @param {string} output
+ * @param {string} [description]
+ */
+function test_minify_async(assert, input, options, output, description) {
+  // Remove optional options parameter if it is not given.
+  if (typeof options === 'string') {
+    description = output;
+    output = options;
+    options = null;
+  }
+
+  // Set default description as input.
+  if (typeof description === 'undefined') {
+    description = input;
+  }
+
+  assert.timeout(100);
+  var descriptionPrefix = 'Asynchronous Test: ';
+  var done = assert.async();
+
+  assert.notOk(minify(input, options, function(error, result) {
+    // Error should be null
+    if (error !== null) {
+      if (error instanceof Error) {
+        assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
+      }
+      else {
+        assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
+      }
+    }
+    assert.equal(result, output, descriptionPrefix + description);
+    done();
+  }));
+}
+
+/**
+ * Test the minify function asynchronously for an expected error.
+ *
+ * @param {QUnit.assert} assert
+ * @param {string} input
+ * @param {Object} options
+ * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
+ * @param {string} [description]
+ */
+function test_minify_async_error(assert, input, options, errorMatcher, description) {
+  // Remove optional errorMatcher parameter if it is not given.
+  if (typeof errorMatcher === 'string') {
+    description = errorMatcher;
+    errorMatcher = null;
+  }
+
+  // Set default description as input.
+  if (typeof description === 'undefined') {
+    description = input;
+  }
+
+  assert.timeout(100);
+  var descriptionPrefix = 'Asynchronous Test: ';
+  var done = assert.async();
+
+  assert.notOk(minify(input, options, function(error, result) {
+    if (error === null) {
+      assert.ok(false, descriptionPrefix + 'An error should have occurred.');
+    }
+    else if (error instanceof Error) {
+      assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
+    }
+    else {
+      assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
+    }
+    assert.notOk(result);
+    done();
+  }));
+}
+
 QUnit.test('`minifiy` exists', function(assert) {
   assert.ok(minify);
 });
@@ -3540,3 +3621,66 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
     canCollapseWhitespace: canCollapseAndTrimWhitespace
   }, output);
 });
+
+QUnit.test('Async execution', function(assert) {
+  var input, output;
+
+  function cssSync(text, type) {
+    return (type || 'Normal') + ' CSS';
+  }
+
+  function jsSync(text, inline) {
+    return inline ? 'Inline JS' : 'Normal JS';
+  }
+
+  function cssAsync(text, type, cb) {
+    setTimeout(function() {
+      cb(cssSync(text, type));
+    }, 0);
+  }
+
+  function jsAsync(text, inline, cb) {
+    setTimeout(function() {
+      cb(jsSync(text, inline));
+    }, 0);
+  }
+
+  var styleInput = '<style>div#foo { background-color: red; color: white }</style>';
+  var scriptInput = '<script>(function(  ){  console.log("Hello" + " World"); })()</script>';
+  input = styleInput + scriptInput;
+
+  var styleOutput = '<style>Normal CSS</style>';
+  var scriptOutput = '<script>Normal JS</script>';
+
+  test_minify_async(assert, input, {}, input);
+
+  output = styleOutput + scriptInput;
+  test_minify_async(assert, input, { minifyCSS: cssAsync }, output);
+  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: false }, output);
+
+  output = styleInput + scriptOutput;
+  test_minify_async(assert, input, { minifyJS: jsAsync }, output);
+  test_minify_async(assert, input, { minifyCSS: false, minifyJS: jsAsync }, output);
+
+  output = styleOutput + scriptOutput;
+  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: jsAsync }, output);
+  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: jsSync }, output);
+  test_minify_async(assert, input, { minifyCSS: cssSync, minifyJS: jsAsync }, output);
+});
+
+QUnit.test('minify error with callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><$unicorn>';
+
+  test_minify_async_error(assert, input, {}, 'Invalid tag name');
+});
+
+QUnit.test('error in callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style>';
+  var error = new Error();
+
+  function css() {
+    throw error;
+  }
+
+  test_minify_async_error(assert, input, { minifyCSS: css }, error);
+});

From 58ca98ec47a71e84d02c1a12fc1852771f920af6 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 18:35:20 +1200
Subject: [PATCH 43/66] Fixed up tests.

---
 tests/minifier.js | 137 ++++++++++++++++++++++------------------------
 1 file changed, 66 insertions(+), 71 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 54b981ab..c5b13087 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -6,6 +6,33 @@ if (typeof minify === 'undefined') {
   self.minify = require('html-minifier').minify;
 }
 
+QUnit.test('`minifiy` exists', function(assert) {
+  assert.ok(minify);
+});
+
+/**
+ * Converts the options in the given object to use sync callbacks where possible.
+ *
+ * @param {Object} options
+ */
+function convertOptionsSyncCallbacks(options) {
+  if (options) {
+    if (typeof options.minifyJS === 'function') {
+      var minifyJS = options.minifyJS;
+      options.minifyJS = function(text, inline, callback) {
+        callback(minifyJS(text, inline));
+      };
+    }
+    if (typeof options.minifyCSS === 'function') {
+      var minifyCSS = options.minifyCSS;
+      options.minifyCSS = function(text, type, callback) {
+        callback(minifyCSS(text, type));
+      };
+    }
+  }
+  return options;
+}
+
 /**
  * Test the minify function synchronously, both with a callback and without.
  *
@@ -33,40 +60,15 @@ function test_minify_sync(assert, input, options, output, description) {
   // Standard test.
   assert.equal(minify(input, options), output, descriptionPrefix + description);
 
-  // Callback setup.
-  if (options) {
-    // Convert `minifyJS` to use a callback.
-    if (typeof options.minifyJS === 'function') {
-      var minifyJS = options.minifyJS;
-      options.minifyJS = function(text, inline, callback) {
-        callback(minifyJS(text, inline));
-      };
-    }
-    // Convert `minifyCSS` to use a callback.
-    if (typeof options.minifyCSS === 'function') {
-      var minifyCSS = options.minifyCSS;
-      options.minifyCSS = function(text, type, callback) {
-        callback(minifyCSS(text, type));
-      };
-    }
-  }
-
   descriptionPrefix = 'Synchronous Callback Test: ';
   var done = assert.async();
   var callbackTestFinished = false;
 
   // Callback test.
-  assert.notOk(minify(input, options, function(error, result) {
+  assert.notOk(minify(input, convertOptionsSyncCallbacks(options), function(error, result) {
     if (!callbackTestFinished) {
-      // Error should be null
-      if (error !== null) {
-        if (error instanceof Error) {
-          assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
-        }
-        else {
-          assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
-        }
-      }
+      assert.notOk(error, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
+
       assert.equal(result, output, descriptionPrefix + description);
       callbackTestFinished = true;
       done();
@@ -86,11 +88,17 @@ function test_minify_sync(assert, input, options, output, description) {
  *
  * @param {QUnit.assert} assert
  * @param {string} input
- * @param {Object} options
+ * @param {Object} [options]
  * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
  * @param {string} [description]
  */
 function test_minify_sync_error(assert, input, options, errorMatcher, description) {
+  // Remove optional options parameter if it is not given.
+  if (typeof options === 'string') {
+    description = errorMatcher;
+    errorMatcher = options;
+    options = null;
+  }
   // Remove optional errorMatcher parameter if it is not given.
   if (typeof errorMatcher === 'string') {
     description = errorMatcher;
@@ -105,24 +113,24 @@ function test_minify_sync_error(assert, input, options, errorMatcher, descriptio
   var descriptionPrefix = 'Synchronous Standard Test: ';
 
   // Standard test.
-  assert.throws(function() { minify(input, options); }, errorMatcher, descriptionPrefix + description);
+  assert.throws(
+    function() {
+      minify(input, options);
+    },
+    errorMatcher,
+    descriptionPrefix + description
+  );
 
   descriptionPrefix = 'Synchronous Callback Test: ';
   var done = assert.async();
   var callbackTestFinished = false;
 
   // Callback test.
-  assert.notOk(minify(input, options, function(error, result) {
+  assert.notOk(minify(input, convertOptionsSyncCallbacks(options), function(error, result) {
     if (!callbackTestFinished) {
-      if (error === null) {
-        assert.ok(false, descriptionPrefix + 'An error should have occurred.');
-      }
-      else if (error instanceof Error) {
-        assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
-      }
-      else {
-        assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
-      }
+      assert.ok(error, descriptionPrefix + 'An error should have occurred.');
+      assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
+      assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
       assert.notOk(result);
       callbackTestFinished = true;
       done();
@@ -159,7 +167,7 @@ function test_minify_async(assert, input, options, output, description) {
     description = input;
   }
 
-  assert.timeout(100);
+  assert.timeout(10);
   var descriptionPrefix = 'Asynchronous Test: ';
   var done = assert.async();
 
@@ -199,7 +207,7 @@ function test_minify_async_error(assert, input, options, errorMatcher, descripti
     description = input;
   }
 
-  assert.timeout(100);
+  assert.timeout(10);
   var descriptionPrefix = 'Asynchronous Test: ';
   var done = assert.async();
 
@@ -218,10 +226,6 @@ function test_minify_async_error(assert, input, options, errorMatcher, descripti
   }));
 }
 
-QUnit.test('`minifiy` exists', function(assert) {
-  assert.ok(minify);
-});
-
 QUnit.test('parsing non-trivial markup', function(assert) {
   var input, output;
 
@@ -273,7 +277,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   test_minify_sync(assert, input, input);
 
   input = '<$unicorn>';
-  test_minify_sync_error(assert, input, {}, 'Invalid tag name');
+  test_minify_sync_error(assert, input, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
   test_minify_sync(assert, input, input);
@@ -303,12 +307,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
   test_minify_sync(assert, input, input);
-  test_minify_sync_error(
-    assert,
-    '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>',
-    {},
-    'invalid attribute name'
-  );
+  test_minify_sync_error(assert, '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>', 'invalid attribute name');
 
   // https://github.com/kangax/html-minifier/issues/512
   input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
@@ -319,19 +318,15 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
   test_minify_sync(assert, input, input);
-  test_minify_sync_error(
-    assert,
-    '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
-      ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
-      ' placeholder="YYYY-MM-DD"' +
-      ' date-range-picker' +
-      ' data-ng-model="vm.value"' +
-      ' data-ng-model-options="{ debounce: 1000 }"' +
-      ' data-ng-pattern="vm.options.format"' +
-      ' data-options="vm.datepickerOptions">',
-    {},
-    'HTML comment inside tag'
-  );
+  input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
+          ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
+          ' placeholder="YYYY-MM-DD"' +
+          ' date-range-picker' +
+          ' data-ng-model="vm.value"' +
+          ' data-ng-model-options="{ debounce: 1000 }"' +
+          ' data-ng-pattern="vm.options.format"' +
+          ' data-options="vm.datepickerOptions">';
+  test_minify_sync_error(assert, input, 'HTML comment inside tag');
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';
@@ -3071,14 +3066,14 @@ QUnit.test('custom attribute collapse', function(assert) {
 
   input = '<div data-bind="\n' +
             'css: {\n' +
-              'fadeIn: selected(,\n' +
+              'fadeIn: selected(),\n' +
               'fadeOut: !selected()\n' +
             '},\n' +
             'visible: function () {\n' +
               'return pageWeAreOn() == \'home\';\n' +
             '}\n' +
           '">foo</div>';
-  output = '<div data-bind="css: {fadeIn: selected(,fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
+  output = '<div data-bind="css: {fadeIn: selected(),fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
 
   test_minify_sync(assert, input, input);
   test_minify_sync(assert, input, { customAttrCollapse: /data-bind/ }, output);
@@ -3636,13 +3631,13 @@ QUnit.test('Async execution', function(assert) {
   function cssAsync(text, type, cb) {
     setTimeout(function() {
       cb(cssSync(text, type));
-    }, 0);
+    }, 1);
   }
 
   function jsAsync(text, inline, cb) {
     setTimeout(function() {
       cb(jsSync(text, inline));
-    }, 0);
+    }, 1);
   }
 
   var styleInput = '<style>div#foo { background-color: red; color: white }</style>';
@@ -3671,7 +3666,7 @@ QUnit.test('Async execution', function(assert) {
 QUnit.test('minify error with callback', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><$unicorn>';
 
-  test_minify_async_error(assert, input, {}, 'Invalid tag name');
+  test_minify_async_error(assert, input, 'Invalid tag name');
 });
 
 QUnit.test('error in callback', function(assert) {

From 8e4351d7eb450b6fa2f8e8fcdc5d25b78e4e4a22 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 20 Apr 2018 18:36:03 +1200
Subject: [PATCH 44/66] Added 'callback called multiple times' tests.

---
 tests/minifier.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/minifier.js b/tests/minifier.js
index c5b13087..a3982aa3 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3679,3 +3679,30 @@ QUnit.test('error in callback', function(assert) {
 
   test_minify_async_error(assert, input, { minifyCSS: css }, error);
 });
+
+QUnit.test('callback called multiple times', function(assert) {
+  var input, done;
+
+  function bad(cb) {
+    try {
+      cb('');
+      cb('');
+      assert.ok(false, 'An error should be thrown.');
+    }
+    catch (error) {
+      assert.equal(error.message, 'Async completion has already occurred.');
+    }
+    finally {
+      done();
+    }
+  }
+
+  done = assert.async();
+  test_minify_async_error(assert, input, { minifyCSS: bad });
+
+  done = assert.async();
+  test_minify_async_error(assert, input, { minifyJS: bad });
+
+  done = assert.async();
+  test_minify_async_error(assert, input, { minifyCSS: bad, minifyJS: bad });
+});

From 5961a660e584fb7038cfe2dcfe132099a6eeb223 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 16:37:28 +1200
Subject: [PATCH 45/66] Fixed bad test 'callback called multiple times' and got
 it passing.

---
 src/htmlminifier.js | 10 ++++++++--
 tests/minifier.js   | 12 +++++++-----
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 56c5a321..2a5fcee6 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1320,7 +1320,10 @@ function minify(value, options, partialMarkup, cb) {
 
                   var callbackCalled = false;
                   function minifyJS_cb(result) {
-                    if (!callbackCalled) {
+                    if (callbackCalled) {
+                      throw new Error('Async completion has already occurred.');
+                    }
+                    else {
                       callbackCalled = true;
                       text = result;
                       return cb();
@@ -1337,7 +1340,10 @@ function minify(value, options, partialMarkup, cb) {
 
                   var callbackCalled = false;
                   function minifyCSS_cb(result) {
-                    if (!callbackCalled) {
+                    if (callbackCalled) {
+                      throw new Error('Async completion has already occurred.');
+                    }
+                    else {
                       callbackCalled = true;
                       text = result;
                       return cb();
diff --git a/tests/minifier.js b/tests/minifier.js
index a3982aa3..2288da00 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3683,7 +3683,7 @@ QUnit.test('error in callback', function(assert) {
 QUnit.test('callback called multiple times', function(assert) {
   var input, done;
 
-  function bad(cb) {
+  function bad(_, __, cb) {
     try {
       cb('');
       cb('');
@@ -3697,12 +3697,14 @@ QUnit.test('callback called multiple times', function(assert) {
     }
   }
 
-  done = assert.async();
-  test_minify_async_error(assert, input, { minifyCSS: bad });
+  input = '<style>div#foo { background-color: red; color: white }</style><script>(function(  ){  console.log("Hello" + " World"); })()</script>';
 
   done = assert.async();
-  test_minify_async_error(assert, input, { minifyJS: bad });
+  minify(input, { minifyCSS: bad });
 
   done = assert.async();
-  test_minify_async_error(assert, input, { minifyCSS: bad, minifyJS: bad });
+  minify(input, { minifyJS: bad });
+
+  done = assert.async(2);
+  minify(input, { minifyCSS: bad, minifyJS: bad });
 });

From adad66503ecd2f97327a9f80bd9d5d470ad6dd96 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 17:20:23 +1200
Subject: [PATCH 46/66] Fixed bug in tests causing them to throw errors.

---
 tests/minifier.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 2288da00..32765534 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -67,9 +67,14 @@ function test_minify_sync(assert, input, options, output, description) {
   // Callback test.
   assert.notOk(minify(input, convertOptionsSyncCallbacks(options), function(error, result) {
     if (!callbackTestFinished) {
-      assert.notOk(error, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
+      var stackTrace = '';
+      if (error && error instanceof Error) {
+        stackTrace = error.stack;
+      }
 
+      assert.notOk(error, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
       assert.equal(result, output, descriptionPrefix + description);
+
       callbackTestFinished = true;
       done();
     }

From f57abf3af7e4c783128cdf3e26697776814929c4 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 17:26:03 +1200
Subject: [PATCH 47/66] Fixed up tests.

---
 tests/minifier.js | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 32765534..b2bf4f85 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -72,7 +72,7 @@ function test_minify_sync(assert, input, options, output, description) {
         stackTrace = error.stack;
       }
 
-      assert.notOk(error, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
+      assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
       assert.equal(result, output, descriptionPrefix + description);
 
       callbackTestFinished = true;
@@ -177,16 +177,14 @@ function test_minify_async(assert, input, options, output, description) {
   var done = assert.async();
 
   assert.notOk(minify(input, options, function(error, result) {
-    // Error should be null
-    if (error !== null) {
-      if (error instanceof Error) {
-        assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + error.stack);
-      }
-      else {
-        assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
-      }
+    var stackTrace = '';
+    if (error && error instanceof Error) {
+      stackTrace = error.stack;
     }
+
+    assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
     assert.equal(result, output, descriptionPrefix + description);
+
     done();
   }));
 }
@@ -217,15 +215,9 @@ function test_minify_async_error(assert, input, options, errorMatcher, descripti
   var done = assert.async();
 
   assert.notOk(minify(input, options, function(error, result) {
-    if (error === null) {
-      assert.ok(false, descriptionPrefix + 'An error should have occurred.');
-    }
-    else if (error instanceof Error) {
-      assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
-    }
-    else {
-      assert.ok(false, descriptionPrefix + '"' + error + '" was returned as an error.');
-    }
+    assert.ok(error, descriptionPrefix + 'An error should have occurred.');
+    assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
+    assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
     assert.notOk(result);
     done();
   }));

From 587da3848ceaf002b63e968dc55620d9eb310eae Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 17:27:44 +1200
Subject: [PATCH 48/66] Fixed up jsdoc.

---
 src/htmlminifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 2a5fcee6..5afa1230 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -877,7 +877,7 @@ function minify(value, options, partialMarkup, cb) {
    *
    * @constructor
    *
-   * @param {Function<string, Function<Error>>} task
+   * @param {Function<Function<Error>>} task
    */
   function Task(task) {
     this.task = task;

From 9addaf62bab54b8960e0bdad74676f940f95cfbf Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 17:34:17 +1200
Subject: [PATCH 49/66] Increased timout.

---
 tests/minifier.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index b2bf4f85..18113010 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -172,7 +172,7 @@ function test_minify_async(assert, input, options, output, description) {
     description = input;
   }
 
-  assert.timeout(10);
+  assert.timeout(100);
   var descriptionPrefix = 'Asynchronous Test: ';
   var done = assert.async();
 
@@ -210,7 +210,7 @@ function test_minify_async_error(assert, input, options, errorMatcher, descripti
     description = input;
   }
 
-  assert.timeout(10);
+  assert.timeout(100);
   var descriptionPrefix = 'Asynchronous Test: ';
   var done = assert.async();
 

From 99d8546500dcefe275efa762ba45afb0d0c22420 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 22:15:48 +1200
Subject: [PATCH 50/66] Made the test_minify_async_error consistent with
 test_minify_sync_error

---
 tests/minifier.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 18113010..6f7634be 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -104,6 +104,7 @@ function test_minify_sync_error(assert, input, options, errorMatcher, descriptio
     errorMatcher = options;
     options = null;
   }
+
   // Remove optional errorMatcher parameter if it is not given.
   if (typeof errorMatcher === 'string') {
     description = errorMatcher;
@@ -194,11 +195,18 @@ function test_minify_async(assert, input, options, output, description) {
  *
  * @param {QUnit.assert} assert
  * @param {string} input
- * @param {Object} options
+ * @param {Object} [options]
  * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
  * @param {string} [description]
  */
 function test_minify_async_error(assert, input, options, errorMatcher, description) {
+  // Remove optional options parameter if it is not given.
+  if (typeof options === 'string') {
+    description = errorMatcher;
+    errorMatcher = options;
+    options = null;
+  }
+
   // Remove optional errorMatcher parameter if it is not given.
   if (typeof errorMatcher === 'string') {
     description = errorMatcher;

From 3552c4e3e2ed3e95b6107406c7ac1bbd34a63bc3 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Mon, 23 Apr 2018 23:10:33 +1200
Subject: [PATCH 51/66] Fixed up jsdoc types.

---
 src/htmlminifier.js | 13 +++++++++----
 tests/minifier.js   | 12 ++++++------
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 5afa1230..42ab0ae0 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1,5 +1,10 @@
 'use strict';
 
+/**
+ * A callback that tasks an error and a result.
+ * @typedef {function([?Error], [string]):void} Callback
+ */
+
 var CleanCSS = require('clean-css');
 var decode = require('he').decode;
 var HTMLParser = require('./htmlparser').HTMLParser;
@@ -842,7 +847,7 @@ function createSortFns(value, options, uidIgnore, uidAttr, cb) {
  * @param {string} value
  * @param {Object} options
  * @param {boolean} partialMarkup
- * @param {Function<Error, string>} cb
+ * @param {Callback} cb
  */
 function minify(value, options, partialMarkup, cb) {
   if (options.collapseWhitespace) {
@@ -877,7 +882,7 @@ function minify(value, options, partialMarkup, cb) {
    *
    * @constructor
    *
-   * @param {Function<Function<Error>>} task
+   * @param {function(Callback)} task
    */
   function Task(task) {
     this.task = task;
@@ -886,7 +891,7 @@ function minify(value, options, partialMarkup, cb) {
   /**
    * Execute this task.
    *
-   * @param {Function<Error>} cb
+   * @param {Callback} cb
    */
   Task.prototype.exec = function(cb) {
     this.task(cb);
@@ -906,7 +911,7 @@ function minify(value, options, partialMarkup, cb) {
   /**
    * Run all tasks in this group in series.
    *
-   * @param {Function<Error>} cb
+   * @param {Callback} cb
    */
   TaskGroup.prototype.exec = function(cb) {
     /**
diff --git a/tests/minifier.js b/tests/minifier.js
index 6f7634be..bbe26ba6 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -36,7 +36,7 @@ function convertOptionsSyncCallbacks(options) {
 /**
  * Test the minify function synchronously, both with a callback and without.
  *
- * @param {QUnit.assert} assert
+ * @param {Assert} assert
  * @param {string} input
  * @param {Object} [options]
  * @param {string} output
@@ -91,10 +91,10 @@ function test_minify_sync(assert, input, options, output, description) {
 /**
  * Test the minify function synchronously for an expected error, both with a callback and without.
  *
- * @param {QUnit.assert} assert
+ * @param {Assert} assert
  * @param {string} input
  * @param {Object} [options]
- * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
+ * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
  * @param {string} [description]
  */
 function test_minify_sync_error(assert, input, options, errorMatcher, description) {
@@ -154,7 +154,7 @@ function test_minify_sync_error(assert, input, options, errorMatcher, descriptio
 /**
  * Test the minify function asynchronously.
  *
- * @param {QUnit.assert} assert
+ * @param {Assert} assert
  * @param {string} input
  * @param {Object} [options]
  * @param {string} output
@@ -193,10 +193,10 @@ function test_minify_async(assert, input, options, output, description) {
 /**
  * Test the minify function asynchronously for an expected error.
  *
- * @param {QUnit.assert} assert
+ * @param {Assert} assert
  * @param {string} input
  * @param {Object} [options]
- * @param {Error|Class<Error>|RegExp|Function<boolean>} [errorMatcher]
+ * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
  * @param {string} [description]
  */
 function test_minify_async_error(assert, input, options, errorMatcher, description) {

From 31edf01dbb1bc19a711861eafa253923d3e39a9e Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Tue, 24 Apr 2018 16:53:02 +1200
Subject: [PATCH 52/66] Merged async and sync test functions togetehr.

---
 tests/minifier.js | 2353 ++++++++++++++++++++++-----------------------
 1 file changed, 1174 insertions(+), 1179 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index bbe26ba6..dcdad2d2 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -1,318 +1,317 @@
 /* global minify */
 'use strict';
 
-QUnit.config.autostart = false;
-if (typeof minify === 'undefined') {
-  self.minify = require('html-minifier').minify;
-}
-
-QUnit.test('`minifiy` exists', function(assert) {
-  assert.ok(minify);
-});
-
 /**
- * Converts the options in the given object to use sync callbacks where possible.
+ * Converts the options in the given object to use callbacks where possible.
  *
- * @param {Object} options
+ * @param {?Object} options
+ * @param {boolean} [async=false]
+ * @returns {Object}
  */
-function convertOptionsSyncCallbacks(options) {
+function convertOptionsCallbacks(options, async) {
+  var convertedOptions = {};
+
   if (options) {
+    for (var i in options) {
+      convertedOptions[i] = options[i];
+    }
+
     if (typeof options.minifyJS === 'function') {
-      var minifyJS = options.minifyJS;
-      options.minifyJS = function(text, inline, callback) {
-        callback(minifyJS(text, inline));
+      convertedOptions.minifyJS = function(text, inline, cb) {
+        function runMinifyJS() {
+          var result = options.minifyJS(text, inline, cb);
+          if (typeof result !== 'undefined') {
+            cb(result);
+          }
+        }
+
+        if (async) {
+          setTimeout(function() {
+            runMinifyJS();
+          }, 1);
+        }
+        else {
+          runMinifyJS();
+        }
       };
     }
     if (typeof options.minifyCSS === 'function') {
-      var minifyCSS = options.minifyCSS;
-      options.minifyCSS = function(text, type, callback) {
-        callback(minifyCSS(text, type));
+      convertedOptions.minifyCSS = function(text, type, cb) {
+        function runMinifyCSS() {
+          var result = options.minifyCSS(text, type, cb);
+          if (typeof result !== 'undefined') {
+            cb(result);
+          }
+        }
+
+        if (async) {
+          setTimeout(function() {
+            runMinifyCSS();
+          }, 1);
+        }
+        else {
+          runMinifyCSS();
+        }
       };
     }
   }
-  return options;
+
+  return convertedOptions;
 }
 
 /**
- * Test the minify function synchronously, both with a callback and without.
+ * Test the minify function.
  *
  * @param {Assert} assert
  * @param {string} input
- * @param {Object} [options]
  * @param {string} output
- * @param {string} [description]
+ * @param {Object} [inputOptions]
+ * @param {string} [description=input]
+ * @param {boolean} [asyncOnly=false]
  */
-function test_minify_sync(assert, input, options, output, description) {
-  // Remove optional options parameter if it is not given.
-  if (typeof options === 'string') {
-    description = output;
-    output = options;
-    options = null;
-  }
-
-  // Set default description as input.
-  if (typeof description === 'undefined') {
+function test_minify(assert, input, output, inputOptions, description, asyncOnly) {
+  // Set default description.
+  if (description === null || typeof description === 'undefined') {
     description = input;
   }
 
-  var descriptionPrefix = 'Synchronous Standard Test: ';
+  // Set default asyncOnly.
+  if (asyncOnly === null || typeof asyncOnly === 'undefined') {
+    asyncOnly = false;
+  }
 
   // Standard test.
-  assert.equal(minify(input, options), output, descriptionPrefix + description);
+  if (!asyncOnly) {
+    var descriptionPrefix = 'Standard Test: ';
+    assert.equal(minify(input, inputOptions), output, descriptionPrefix + description);
+  }
 
-  descriptionPrefix = 'Synchronous Callback Test: ';
-  var done = assert.async();
-  var callbackTestFinished = false;
+  // Callback tests.
+  var callbackTests = [];
+
+  if (!asyncOnly) {
+    // Sync callback test.
+    callbackTests.push({
+      options: convertOptionsCallbacks(inputOptions, false),
+      async: false,
+      done: assert.async(),
+      descriptionPrefix: 'Synchronous Callback Test: '
+    });
+  }
 
-  // Callback test.
-  assert.notOk(minify(input, convertOptionsSyncCallbacks(options), function(error, result) {
-    if (!callbackTestFinished) {
-      var stackTrace = '';
-      if (error && error instanceof Error) {
-        stackTrace = error.stack;
-      }
+  // Async callback test.
+  callbackTests.push({
+    options: asyncOnly ? inputOptions : convertOptionsCallbacks(inputOptions, true),
+    async: true,
+    done: assert.async(),
+    descriptionPrefix: 'Asynchronous Callback Test: '
+  });
 
-      assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
-      assert.equal(result, output, descriptionPrefix + description);
+  // Run callback tests.
+  assert.timeout(100);
+  callbackTests.forEach(function(test) {
+    var callbackTestFinished = false;
+    assert.notOk(minify(input, test.options, function(error, result) {
+      if (!callbackTestFinished) {
+        var stackTrace = '';
+        if (error && error instanceof Error) {
+          stackTrace = error.stack;
+        }
+
+        assert.equal(error, null, test.descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
+        assert.equal(result, output, test.descriptionPrefix + description);
+
+        callbackTestFinished = true;
+        test.done();
+      }
+    }));
 
+    // If callback test didn't finish synchronously.
+    if (!callbackTestFinished && !test.async) {
+      assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
       callbackTestFinished = true;
-      done();
+      test.done();
     }
-  }));
-
-  // If callback test didn't finish synchronously.
-  if (!callbackTestFinished) {
-    assert.ok(false, descriptionPrefix + 'Didn\'t finish synchronously.');
-    callbackTestFinished = true;
-    done();
-  }
+  });
 }
 
 /**
- * Test the minify function synchronously for an expected error, both with a callback and without.
+ * Test the minify function for an expected error.
  *
  * @param {Assert} assert
  * @param {string} input
  * @param {Object} [options]
  * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
- * @param {string} [description]
+ * @param {string} [description=input]
+ * @param {boolean} [asyncOnly=false]
  */
-function test_minify_sync_error(assert, input, options, errorMatcher, description) {
-  // Remove optional options parameter if it is not given.
-  if (typeof options === 'string') {
-    description = errorMatcher;
-    errorMatcher = options;
-    options = null;
-  }
-
-  // Remove optional errorMatcher parameter if it is not given.
-  if (typeof errorMatcher === 'string') {
-    description = errorMatcher;
-    errorMatcher = null;
-  }
-
-  // Set default description as input.
-  if (typeof description === 'undefined') {
+function test_minify_error(assert, input, inputOptions, errorMatcher, description, asyncOnly) {
+  // Set default description.
+  if (description === null || typeof description === 'undefined') {
     description = input;
   }
 
-  var descriptionPrefix = 'Synchronous Standard Test: ';
+  // Set default asyncOnly.
+  if (asyncOnly === null || typeof asyncOnly === 'undefined') {
+    asyncOnly = false;
+  }
 
   // Standard test.
+  var descriptionPrefix = 'Standard Test: ';
   assert.throws(
     function() {
-      minify(input, options);
+      minify(input, inputOptions);
     },
     errorMatcher,
     descriptionPrefix + description
   );
 
-  descriptionPrefix = 'Synchronous Callback Test: ';
-  var done = assert.async();
-  var callbackTestFinished = false;
-
-  // Callback test.
-  assert.notOk(minify(input, convertOptionsSyncCallbacks(options), function(error, result) {
-    if (!callbackTestFinished) {
-      assert.ok(error, descriptionPrefix + 'An error should have occurred.');
-      assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
-      assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
-      assert.notOk(result);
-      callbackTestFinished = true;
-      done();
-    }
-  }));
-
-  // If callback test didn't finish synchronously.
-  if (!callbackTestFinished) {
-    assert.ok(false, descriptionPrefix + 'Didn\'t finish synchronously.');
-    callbackTestFinished = true;
-    done();
-  }
-}
-
-/**
- * Test the minify function asynchronously.
- *
- * @param {Assert} assert
- * @param {string} input
- * @param {Object} [options]
- * @param {string} output
- * @param {string} [description]
- */
-function test_minify_async(assert, input, options, output, description) {
-  // Remove optional options parameter if it is not given.
-  if (typeof options === 'string') {
-    description = output;
-    output = options;
-    options = null;
+  // Callback tests.
+  var callbackTests = [];
+
+  if (!asyncOnly) {
+    // Sync callback test.
+    callbackTests.push({
+      options: convertOptionsCallbacks(inputOptions, false),
+      async: false,
+      done: assert.async(),
+      descriptionPrefix: 'Synchronous Callback Test: '
+    });
   }
 
-  // Set default description as input.
-  if (typeof description === 'undefined') {
-    description = input;
-  }
-
-  assert.timeout(100);
-  var descriptionPrefix = 'Asynchronous Test: ';
-  var done = assert.async();
+  // Async callback test.
+  callbackTests.push({
+    options: asyncOnly ? inputOptions : convertOptionsCallbacks(inputOptions, true),
+    async: true,
+    done: assert.async(),
+    descriptionPrefix: 'Asynchronous Callback Test: '
+  });
 
-  assert.notOk(minify(input, options, function(error, result) {
-    var stackTrace = '';
-    if (error && error instanceof Error) {
-      stackTrace = error.stack;
+  // Run callback tests.
+  callbackTests.forEach(function(test) {
+    var callbackTestFinished = false;
+    try {
+      assert.timeout(100);
+      assert.notOk(minify(input, test.options, function(error, result) {
+        if (!callbackTestFinished) {
+          assert.ok(error, descriptionPrefix + 'An error should have occurred.');
+          assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
+          assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
+          assert.notOk(result);
+
+          callbackTestFinished = true;
+          test.done();
+        }
+      }));
+
+      // If callback test didn't finish synchronously.
+      if (!callbackTestFinished && !test.async) {
+        assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
+        callbackTestFinished = true;
+        test.done();
+      }
     }
-
-    assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
-    assert.equal(result, output, descriptionPrefix + description);
-
-    done();
-  }));
+    catch (error) {
+      callbackTestFinished = true;
+      if (error && error instanceof Error) {
+        assert.ok(false, test.descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
+      }
+      else {
+        assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
+      }
+    }
+  });
 }
 
-/**
- * Test the minify function asynchronously for an expected error.
- *
- * @param {Assert} assert
- * @param {string} input
- * @param {Object} [options]
- * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
- * @param {string} [description]
- */
-function test_minify_async_error(assert, input, options, errorMatcher, description) {
-  // Remove optional options parameter if it is not given.
-  if (typeof options === 'string') {
-    description = errorMatcher;
-    errorMatcher = options;
-    options = null;
-  }
-
-  // Remove optional errorMatcher parameter if it is not given.
-  if (typeof errorMatcher === 'string') {
-    description = errorMatcher;
-    errorMatcher = null;
-  }
-
-  // Set default description as input.
-  if (typeof description === 'undefined') {
-    description = input;
-  }
-
-  assert.timeout(100);
-  var descriptionPrefix = 'Asynchronous Test: ';
-  var done = assert.async();
-
-  assert.notOk(minify(input, options, function(error, result) {
-    assert.ok(error, descriptionPrefix + 'An error should have occurred.');
-    assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
-    assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
-    assert.notOk(result);
-    done();
-  }));
+QUnit.config.autostart = false;
+if (typeof minify === 'undefined') {
+  self.minify = require('html-minifier').minify;
 }
 
+QUnit.test('`minifiy` exists', function(assert) {
+  assert.ok(minify);
+});
+
 QUnit.test('parsing non-trivial markup', function(assert) {
   var input, output;
 
-  test_minify_sync(assert, '</td>', '');
-  test_minify_sync(assert, '</p>', '<p></p>');
-  test_minify_sync(assert, '</br>', '<br>');
-  test_minify_sync(assert, '<br>x</br>', '<br>x<br>');
-  test_minify_sync(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
-  test_minify_sync(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
-  test_minify_sync(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  test_minify_sync(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
-  test_minify_sync(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
-  test_minify_sync(assert, '<p foo.bar=baz>xxx</p>', '<p foo.bar="baz">xxx</p>');
+  test_minify(assert, '</td>', '');
+  test_minify(assert, '</p>', '<p></p>');
+  test_minify(assert, '</br>', '<br>');
+  test_minify(assert, '<br>x</br>', '<br>x<br>');
+  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
+  test_minify(assert, '<p foo.bar=baz>xxx</p>', '<p foo.bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
 
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
-  test_minify_sync(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')</script>');
-  test_minify_sync(assert, '<script>alert(\'<!-- foo -->\')</script>', '<script>alert(\'<!-- foo -->\')</script>');
-  test_minify_sync(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')</script>');
+  test_minify(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')</script>');
+  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', '<script>alert(\'<!-- foo -->\')</script>');
+  test_minify(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')</script>');
 
-  test_minify_sync(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
-  test_minify_sync(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
-  test_minify_sync(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  test_minify_sync(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
-  test_minify_sync(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
-  test_minify_sync(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>',
-    '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>'
-  );
+  test_minify(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
+  test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
+  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
+  test_minify(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
+  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>');
 
-  test_minify_sync(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x"></ng-include>');
-  test_minify_sync(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x"></ng:include>');
-  test_minify_sync(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>',
-    '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>'
-  );
+  test_minify(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x"></ng-include>');
+  test_minify(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x"></ng:include>');
+  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>');
 
   // will cause test to time-out if fail
   input = '<p>For more information, read <a href=https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685>this Stack Overflow answer</a>.</p>';
   output = '<p>For more information, read <a href="https://stackoverflow.com/questions/17408815/fieldset-resizes-wrong-appears-to-have-unremovable-min-width-min-content/17863685#17863685">this Stack Overflow answer</a>.</p>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<html ⚡></html>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   input = '<h:ællæ></h:ællæ>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   input = '<$unicorn>';
-  test_minify_sync_error(assert, input, 'Invalid tag name');
+  assert.throws(function() {
+    minify(input);
+  }, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   // https://github.com/kangax/html-minifier/issues/41
-  test_minify_sync(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>',
-    '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>'
-  );
+  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>');
 
   // https://github.com/kangax/html-minifier/issues/40
-  test_minify_sync(assert, '[\']["]', '[\']["]');
+  test_minify(assert, '[\']["]', '[\']["]');
 
   // https://github.com/kangax/html-minifier/issues/21
-  test_minify_sync(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html"><div>hey</div></a>');
+  test_minify(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html"><div>hey</div></a>');
 
   // https://github.com/kangax/html-minifier/issues/17
-  test_minify_sync(assert, ':) <a href="http://example.com">link</a>', ':) <a href="http://example.com">link</a>');
+  test_minify(assert, ':) <a href="http://example.com">link</a>', ':) <a href="http://example.com">link</a>');
 
   // https://github.com/kangax/html-minifier/issues/169
-  test_minify_sync(assert, '<a href>ok</a>', '<a href>ok</a>');
+  test_minify(assert, '<a href>ok</a>', '<a href>ok</a>');
 
-  test_minify_sync(assert, '<a onclick></a>', '<a onclick></a>');
+  test_minify(assert, '<a onclick></a>', '<a onclick></a>');
 
   // https://github.com/kangax/html-minifier/issues/229
-  test_minify_sync(assert, '<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>', '<custom-tag></custom-tag><div>Hello :)</div>');
+  test_minify(assert, '<CUSTOM-TAG></CUSTOM-TAG><div>Hello :)</div>', '<custom-tag></custom-tag><div>Hello :)</div>');
 
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync_error(assert, '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>', 'invalid attribute name');
+  test_minify(assert, input, input);
+  assert.throws(function() {
+    minify('<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>');
+  }, 'invalid attribute name');
 
   // https://github.com/kangax/html-minifier/issues/512
   input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
@@ -322,125 +321,128 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-model-options="{ debounce: 1000 }"' +
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
-  test_minify_sync(assert, input, input);
-  input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
-          ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
-          ' placeholder="YYYY-MM-DD"' +
-          ' date-range-picker' +
-          ' data-ng-model="vm.value"' +
-          ' data-ng-model-options="{ debounce: 1000 }"' +
-          ' data-ng-pattern="vm.options.format"' +
-          ' data-options="vm.datepickerOptions">';
-  test_minify_sync_error(assert, input, 'HTML comment inside tag');
+  test_minify(assert, input, input);
+  assert.throws(function() {
+    minify(
+      '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
+      ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
+      ' placeholder="YYYY-MM-DD"' +
+      ' date-range-picker' +
+      ' data-ng-model="vm.value"' +
+      ' data-ng-model-options="{ debounce: 1000 }"' +
+      ' data-ng-pattern="vm.options.format"' +
+      ' data-options="vm.datepickerOptions">'
+    );
+  }, 'HTML comment inside tag');
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
   output = '<br a="\u00A0"b="\u00A0"c="\u00A0">';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     decodeEntities: true,
     removeTagWhitespace: true,
-  }, output);
+  });
   output = '<br a=\u00A0 b=\u00A0 c=\u00A0>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     decodeEntities: true,
     removeAttributeQuotes: true
-  }, output);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, output, {
     decodeEntities: true,
     removeAttributeQuotes: true,
     removeTagWhitespace: true,
-  }, output);
+  });
 });
 
 QUnit.test('options', function(assert) {
   var input = '<p>blah<span>blah 2<span>blah 3</span></span></p>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {}, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {});
 });
 
 QUnit.test('case normalization', function(assert) {
-  test_minify_sync(assert, '<P>foo</p>', '<p>foo</p>');
-  test_minify_sync(assert, '<DIV>boo</DIV>', '<div>boo</div>');
-  test_minify_sync(assert, '<DIV title="moo">boo</DiV>', '<div title="moo">boo</div>');
-  test_minify_sync(assert, '<DIV TITLE="blah">boo</DIV>', '<div title="blah">boo</div>');
-  test_minify_sync(assert, '<DIV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
-  test_minify_sync(assert, '<DiV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify(assert, '<P>foo</p>', '<p>foo</p>');
+  test_minify(assert, '<DIV>boo</DIV>', '<div>boo</div>');
+  test_minify(assert, '<DIV title="moo">boo</DiV>', '<div title="moo">boo</div>');
+  test_minify(assert, '<DIV TITLE="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify(assert, '<DIV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
+  test_minify(assert, '<DiV tItLe="blah">boo</DIV>', '<div title="blah">boo</div>');
 });
 
 QUnit.test('space normalization between attributes', function(assert) {
-  test_minify_sync(assert, '<p title="bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify_sync(assert, '<img src="test"/>', '<img src="test">');
-  test_minify_sync(assert, '<p title = "bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify_sync(assert, '<p title\n\n\t  =\n     "bar">foo</p>', '<p title="bar">foo</p>');
-  test_minify_sync(assert, '<img src="test" \n\t />', '<img src="test">');
-  test_minify_sync(assert, '<input title="bar"       id="boo"    value="hello world">', '<input title="bar" id="boo" value="hello world">');
+  test_minify(assert, '<p title="bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<img src="test"/>', '<img src="test">');
+  test_minify(assert, '<p title = "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<p title\n\n\t  =\n     "bar">foo</p>', '<p title="bar">foo</p>');
+  test_minify(assert, '<img src="test" \n\t />', '<img src="test">');
+  test_minify(assert, '<input title="bar"       id="boo"    value="hello world">', '<input title="bar" id="boo" value="hello world">');
 });
 
 QUnit.test('space normalization around text', function(assert) {
   var input, output;
   input = '   <p>blah</p>\n\n\n   ';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<p>blah</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   output = ' <p>blah</p> ';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
   output = '<p>blah</p>\n';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
   output = ' <p>blah</p>\n';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }, output);
+  });
   [
     'a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd',
     'mark', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup',
     'time', 'tt', 'u', 'var'
   ].forEach(function(el) {
-    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
-    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
-    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz </' + el + '>bar');
-    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '> baz </' + el + '>bar');
-    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz </' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '> baz </' + el + '>bar</div>');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', 'foo <' + el + '>baz </' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', 'foo <' + el + '>baz </' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', '<div>foo <' + el + '>baz </' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', '<div>foo <' + el + '>baz </' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true });
   });
   // Don't trim whitespace around element, but do trim within
   [
     'bdi', 'bdo', 'button', 'cite', 'code', 'dfn', 'math', 'q', 'rt', 'rtc', 'ruby', 'svg'
   ].forEach(function(el) {
-    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo <' + el + '> baz </' + el + '>bar', { collapseWhitespace: true }, 'foo <' + el + '>baz</' + el + '>bar');
-    test_minify_sync(assert, 'foo<' + el + '> baz </' + el + '> bar', { collapseWhitespace: true }, 'foo<' + el + '>baz</' + el + '> bar');
-    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '> bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', { collapseWhitespace: true }, '<div>foo <' + el + '>baz</' + el + '>bar</div>');
-    test_minify_sync(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', { collapseWhitespace: true }, '<div>foo<' + el + '>baz</' + el + '> bar</div>');
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '> bar', 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '>bar', 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '>baz</' + el + '>bar', 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '>baz</' + el + '> bar', 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '> bar', 'foo <' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '>bar', 'foo<' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo <' + el + '> baz </' + el + '>bar', 'foo <' + el + '>baz</' + el + '>bar', { collapseWhitespace: true });
+    test_minify(assert, 'foo<' + el + '> baz </' + el + '> bar', 'foo<' + el + '>baz</' + el + '> bar', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '> bar</div>', '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '>bar</div>', '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '>baz</' + el + '>bar</div>', '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '>baz</' + el + '> bar</div>', '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '> bar</div>', '<div>foo <' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '>bar</div>', '<div>foo<' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo <' + el + '> baz </' + el + '>bar</div>', '<div>foo <' + el + '>baz</' + el + '>bar</div>', { collapseWhitespace: true });
+    test_minify(assert, '<div>foo<' + el + '> baz </' + el + '> bar</div>', '<div>foo<' + el + '>baz</' + el + '> bar</div>', { collapseWhitespace: true });
   });
   [
     ['<span> foo </span>', '<span>foo</span>'],
@@ -466,39 +468,39 @@ QUnit.test('space normalization around text', function(assert) {
     ['a <nobr> b</nobr> c', 'a <nobr>b</nobr> c'],
     ['a <nobr> b </nobr> c', 'a <nobr>b</nobr> c']
   ].forEach(function(inputs) {
-    test_minify_sync(assert, inputs[0], {
+    test_minify(assert, inputs[0], inputs[0], {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }, inputs[0], inputs[0]);
-    test_minify_sync(assert, inputs[0], { collapseWhitespace: true }, inputs[1], inputs[0]);
+    }, inputs[0]);
+    test_minify(assert, inputs[0], inputs[1], { collapseWhitespace: true }, inputs[0]);
     var input = '<div>' + inputs[0] + '</div>';
-    test_minify_sync(assert, input, {
+    test_minify(assert, input, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }, input, input);
+    }, input);
     var output = '<div>' + inputs[1] + '</div>';
-    test_minify_sync(assert, input, { collapseWhitespace: true }, output, input);
-  });
-  test_minify_sync(assert, '<p>foo <img> bar</p>', { collapseWhitespace: true }, '<p>foo <img> bar</p>');
-  test_minify_sync(assert, '<p>foo<img>bar</p>', { collapseWhitespace: true }, '<p>foo<img>bar</p>');
-  test_minify_sync(assert, '<p>foo <img>bar</p>', { collapseWhitespace: true }, '<p>foo <img>bar</p>');
-  test_minify_sync(assert, '<p>foo<img> bar</p>', { collapseWhitespace: true }, '<p>foo<img> bar</p>');
-  test_minify_sync(assert, '<p>foo <wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
-  test_minify_sync(assert, '<p>foo<wbr>bar</p>', { collapseWhitespace: true }, '<p>foo<wbr>bar</p>');
-  test_minify_sync(assert, '<p>foo <wbr>bar</p>', { collapseWhitespace: true }, '<p>foo <wbr>bar</p>');
-  test_minify_sync(assert, '<p>foo<wbr> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr> bar</p>');
-  test_minify_sync(assert, '<p>foo <wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
-  test_minify_sync(assert, '<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo="">bar</p>');
-  test_minify_sync(assert, '<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true }, '<p>foo <wbr baz moo="">bar</p>');
-  test_minify_sync(assert, '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true }, '<p>foo<wbr baz moo=""> bar</p>');
-  test_minify_sync(assert, '<p>  <a href="#">  <code>foo</code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify_sync(assert, '<p><a href="#"><code>foo  </code></a> bar</p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify_sync(assert, '<p>  <a href="#">  <code>   foo</code></a> bar   </p>', { collapseWhitespace: true }, '<p><a href="#"><code>foo</code></a> bar</p>');
-  test_minify_sync(assert, '<div> Empty <!-- or --> not </div>', { collapseWhitespace: true }, '<div>Empty<!-- or --> not</div>');
-  test_minify_sync(assert, '<div> a <input><!-- b --> c </div>', {
+    test_minify(assert, input, output, { collapseWhitespace: true }, input);
+  });
+  test_minify(assert, '<p>foo <img> bar</p>', '<p>foo <img> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<img>bar</p>', '<p>foo<img>bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo <img>bar</p>', '<p>foo <img>bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<img> bar</p>', '<p>foo<img> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo <wbr> bar</p>', '<p>foo<wbr> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<wbr>bar</p>', '<p>foo<wbr>bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo <wbr>bar</p>', '<p>foo <wbr>bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<wbr> bar</p>', '<p>foo<wbr> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo <wbr baz moo=""> bar</p>', '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<wbr baz moo="">bar</p>', '<p>foo<wbr baz moo="">bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo <wbr baz moo="">bar</p>', '<p>foo <wbr baz moo="">bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>foo<wbr baz moo=""> bar</p>', '<p>foo<wbr baz moo=""> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>  <a href="#">  <code>foo</code></a> bar</p>', '<p><a href="#"><code>foo</code></a> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p><a href="#"><code>foo  </code></a> bar</p>', '<p><a href="#"><code>foo</code></a> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<p>  <a href="#">  <code>   foo</code></a> bar   </p>', '<p><a href="#"><code>foo</code></a> bar</p>', { collapseWhitespace: true });
+  test_minify(assert, '<div> Empty <!-- or --> not </div>', '<div>Empty<!-- or --> not</div>', { collapseWhitespace: true });
+  test_minify(assert, '<div> a <input><!-- b --> c </div>', '<div>a <input> c</div>', {
     collapseWhitespace: true,
     removeComments: true
-  }, '<div>a <input> c</div>');
+  });
   [
     ' a <? b ?> c ',
     '<!-- d --> a <? b ?> c ',
@@ -510,64 +512,64 @@ QUnit.test('space normalization around text', function(assert) {
     ' a <? b ?> c<!-- d --> ',
     ' a <? b ?> c <!-- d -->'
   ].forEach(function(input) {
-    test_minify_sync(assert, input, {
+    test_minify(assert, input, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }, input, input);
-    test_minify_sync(assert, input, {
+    }, input);
+    test_minify(assert, input, 'a <? b ?> c', {
       collapseWhitespace: true,
       removeComments: true
-    }, 'a <? b ?> c', input);
-    test_minify_sync(assert, input, {
+    }, input);
+    test_minify(assert, input, ' a <? b ?> c ', {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
-    }, ' a <? b ?> c ', input);
+    }, input);
     input = '<p>' + input + '</p>';
-    test_minify_sync(assert, input, {
+    test_minify(assert, input, input, {
       collapseWhitespace: true,
       conservativeCollapse: true
-    }, input, input);
-    test_minify_sync(assert, input, {
+    }, input);
+    test_minify(assert, input, '<p>a <? b ?> c</p>', {
       collapseWhitespace: true,
       removeComments: true
-    }, '<p>a <? b ?> c</p>', input);
-    test_minify_sync(assert, input, {
+    }, input);
+    test_minify(assert, input, '<p> a <? b ?> c </p>', {
       collapseWhitespace: true,
       conservativeCollapse: true,
       removeComments: true
-    }, '<p> a <? b ?> c </p>', input);
+    }, input);
   });
   input = '<li><i></i> <b></b> foo</li>';
   output = '<li><i></i> <b></b> foo</li>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<li><i> </i> <b></b> foo</li>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<li> <i></i> <b></b> foo</li>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<li><i></i> <b> </b> foo</li>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<li> <i> </i> <b> </b> foo</li>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<div> <a href="#"> <span> <b> foo </b> <i> bar </i> </span> </a> </div>';
   output = '<div><a href="#"><span><b>foo </b><i>bar</i></span></a></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<head> <!-- a --> <!-- b --><link> </head>';
   output = '<head><!-- a --><!-- b --><link></head>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<head> <!-- a --> <!-- b --> <!-- c --><link> </head>';
   output = '<head><!-- a --><!-- b --><!-- c --><link></head>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<p> foo\u00A0bar\nbaz  \u00A0\nmoo\t</p>';
   output = '<p>foo\u00A0bar baz \u00A0 moo</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<label> foo </label>\n' +
           '<input>\n' +
           '<object> bar </object>\n' +
           '<select> baz </select>\n' +
           '<textarea> moo </textarea>\n';
   output = '<label>foo</label> <input> <object>bar</object> <select>baz</select> <textarea> moo </textarea>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   input = '<pre>\n' +
           'foo\n' +
           '<br>\n' +
@@ -575,130 +577,130 @@ QUnit.test('space normalization around text', function(assert) {
           '</pre>\n' +
           'baz\n';
   output = '<pre>\nfoo\n<br>\nbar\n</pre>baz';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 });
 
 QUnit.test('types of whitespace that should always be preserved', function(assert) {
   // Hair space:
   var input = '<div>\u200afo\u200ao\u200a</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
+  test_minify(assert, input, input, { collapseWhitespace: true });
 
   // Hair space passed as HTML entity:
   var inputWithEntities = '<div>&#8202;fo&#8202;o&#8202;</div>';
-  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
+  test_minify(assert, inputWithEntities, inputWithEntities, { collapseWhitespace: true });
 
   // Hair space passed as HTML entity, in decodeEntities:true mode:
-  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
+  test_minify(assert, inputWithEntities, input, { collapseWhitespace: true, decodeEntities: true });
 
 
   // Non-breaking space:
   input = '<div>\xa0fo\xa0o\xa0</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
+  test_minify(assert, input, input, { collapseWhitespace: true });
 
   // Non-breaking space passed as HTML entity:
   inputWithEntities = '<div>&nbsp;fo&nbsp;o&nbsp;</div>';
-  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true }, inputWithEntities);
+  test_minify(assert, inputWithEntities, inputWithEntities, { collapseWhitespace: true });
 
   // Non-breaking space passed as HTML entity, in decodeEntities:true mode:
-  test_minify_sync(assert, inputWithEntities, { collapseWhitespace: true, decodeEntities: true }, input);
+  test_minify(assert, inputWithEntities, input, { collapseWhitespace: true, decodeEntities: true });
 
   // Do not remove hair space when preserving line breaks between tags:
   input = '<p></p>\u200a\n<p></p>\n';
-  test_minify_sync(assert, input, { collapseWhitespace: true, preserveLineBreaks: true }, input);
+  test_minify(assert, input, input, { collapseWhitespace: true, preserveLineBreaks: true });
 
   // Preserve hair space in attributes:
   input = '<p class="foo\u200abar"></p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
+  test_minify(assert, input, input, { collapseWhitespace: true });
 
   // Preserve hair space in class names when deduplicating and reordering:
   input = '<a class="0 1\u200a3 2 3"></a>';
-  test_minify_sync(assert, input, { sortClassName: false }, input);
-  test_minify_sync(assert, input, { sortClassName: true }, input);
+  test_minify(assert, input, input, { sortClassName: false });
+  test_minify(assert, input, input, { sortClassName: true });
 });
 
 QUnit.test('doctype normalization', function(assert) {
   var input;
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"\n    "http://www.w3.org/TR/html4/strict.dtd">';
-  test_minify_sync(assert, input, { useShortDoctype: true }, '<!DOCTYPE html>');
+  test_minify(assert, input, '<!DOCTYPE html>', { useShortDoctype: true });
 
   input = '<!DOCTYPE html>';
-  test_minify_sync(assert, input, { useShortDoctype: true }, input);
+  test_minify(assert, input, input, { useShortDoctype: true });
 
   input = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">';
-  test_minify_sync(assert, input, { useShortDoctype: false }, input);
+  test_minify(assert, input, input, { useShortDoctype: false });
 });
 
 QUnit.test('removing comments', function(assert) {
   var input;
 
   input = '<!-- test -->';
-  test_minify_sync(assert, input, { removeComments: true }, '');
+  test_minify(assert, input, '', { removeComments: true });
 
   input = '<!-- foo --><div>baz</div><!-- bar\n\n moo -->';
-  test_minify_sync(assert, input, { removeComments: true }, '<div>baz</div>');
-  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, '<div>baz</div>', { removeComments: true });
+  test_minify(assert, input, input, { removeComments: false });
 
   input = '<p title="<!-- comment in attribute -->">foo</p>';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<script><!-- alert(1) --></script>';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<STYLE><!-- alert(1) --></STYLE>';
-  test_minify_sync(assert, input, { removeComments: true }, '<style><!-- alert(1) --></style>');
+  test_minify(assert, input, '<style><!-- alert(1) --></style>', { removeComments: true });
 });
 
 QUnit.test('ignoring comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, input, { removeComments: false });
 
   input = '<!--! foo --><div>baz</div><!--! bar\n\n moo -->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, input, { removeComments: false });
 
   input = '<!--! foo --><div>baz</div><!-- bar\n\n moo -->';
-  test_minify_sync(assert, input, { removeComments: true }, '<!--! foo --><div>baz</div>');
-  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, '<!--! foo --><div>baz</div>', { removeComments: true });
+  test_minify(assert, input, input, { removeComments: false });
 
   input = '<!-- ! test -->';
-  test_minify_sync(assert, input, { removeComments: true }, '');
-  test_minify_sync(assert, input, { removeComments: false }, input);
+  test_minify(assert, input, '', { removeComments: true });
+  test_minify(assert, input, input, { removeComments: false });
 
   input = '<div>\n\n   \t<div><div>\n\n<p>\n\n<!--!      \t\n\nbar\n\n moo         -->      \n\n</p>\n\n        </div>  </div></div>';
   output = '<div><div><div><p><!--!      \t\n\nbar\n\n moo         --></p></div></div></div>';
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, { removeComments: false }, input);
-  test_minify_sync(assert, input, { removeComments: false, collapseWhitespace: true }, output);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, output, { removeComments: true, collapseWhitespace: true });
+  test_minify(assert, input, input, { removeComments: false });
+  test_minify(assert, input, output, { removeComments: false, collapseWhitespace: true });
 
   input = '<p rel="<!-- comment in attribute -->" title="<!--! ignored comment in attribute -->">foo</p>';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 });
 
 QUnit.test('conditional comments', function(assert) {
   var input, output;
 
   input = '<![if IE 5]>test<![endif]>';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<!--[if IE 6]>test<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<!--[if IE 7]>-->test<!--<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<!--[if IE 8]><!-->test<!--<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<!--[if lt IE 5.5]>test<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<!--[if (gt IE 5)&(lt IE 7)]>test<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
 
   input = '<html>\n' +
           '  <head>\n' +
@@ -716,22 +718,22 @@ QUnit.test('conditional comments', function(assert) {
            '        alert("ie8!");\n' +
            '      </script>\n' +
            '    <![endif]-->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
     removeOptionalTags: true,
     removeScriptTypeAttributes: true
-  }, output);
+  });
   output = '<head><!--[if lte IE 8]><script>alert("ie8!")</script><![endif]-->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyJS: true,
     removeComments: true,
     collapseWhitespace: true,
     removeOptionalTags: true,
     removeScriptTypeAttributes: true,
     processConditionalComments: true
-  }, output);
+  });
 
   input = '<!DOCTYPE html>\n' +
           '<html lang="en">\n' +
@@ -759,15 +761,15 @@ QUnit.test('conditional comments', function(assert) {
            '<!--[if IE 8]><html class="no-js ie8"><![endif]-->' +
            '<!--[if gt IE 8]><!--><html class="no-js"><!--<![endif]-->' +
            '<title>Document</title></head><body></body></html>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true
-  }, output);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }, output);
+  });
 });
 
 QUnit.test('collapsing space in conditional comments', function(assert) {
@@ -776,215 +778,215 @@ QUnit.test('collapsing space in conditional comments', function(assert) {
   input = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
             '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css" />\n\t' +
           '<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, input, { removeComments: true, collapseWhitespace: true });
   output = '<!--[if IE 7]>\n\n   \t\n   \t\t ' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">\n\t' +
            '<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true, processConditionalComments: true }, output);
+  test_minify(assert, input, output, { removeComments: true, processConditionalComments: true });
   output = '<!--[if IE 7]>' +
              '<link rel="stylesheet" href="/css/ie7-fixes.css" type="text/css">' +
            '<![endif]-->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }, output);
+  });
 
   input = '<!--[if lte IE 6]>\n    \n   \n\n\n\t' +
             '<p title=" sigificant     whitespace   ">blah blah</p>' +
           '<![endif]-->';
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, input);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, input, { removeComments: true, collapseWhitespace: true });
   output = '<!--[if lte IE 6]>' +
              '<p title=" sigificant     whitespace   ">blah blah</p>' +
            '<![endif]-->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     processConditionalComments: true
-  }, output);
+  });
 });
 
 QUnit.test('remove comments from scripts', function(assert) {
   var input, output;
 
   input = '<script><!--\nalert(1);\n--></script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script><!--alert(2);--></script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script><!--alert(3);\n--></script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script><!--\nalert(4);--></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><!--alert(5);\nalert(6);\nalert(7);--></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><!--alert(8)</script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->"); -->\n\n   </script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script type="text/javascript"> \n <!--\nalert("-->");\n -->\n\n   </script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script type="text/javascript">alert("--\\x3e")</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script> //   <!--   \n  alert(1)   //  --> </script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/html">\n<div>\n</div>\n<!-- aa -->\n</script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 });
 
 QUnit.test('remove comments from styles', function(assert) {
   var input, output;
 
   input = '<style><!--\np.a{background:red}\n--></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.a{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><!--p.b{background:red}--></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.b{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><!--p.c{background:red}\n--></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.c{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><!--\np.d{background:red}--></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.d{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><!--p.e{background:red}\np.f{background:red}\np.g{background:red}--></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.e{background:red}p.f{background:red}p.g{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style>p.h{background:red}<!--\np.i{background:red}\n-->p.j{background:red}</style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.h{background:red}p.i{background:red}p.j{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style type="text/css"><!-- p { color: red } --></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style type="text/css">p{color:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style type="text/css">p::before { content: "<!--" }</style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style type="text/css">p::before{content:"<!--"}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style type="text/html">\n<div>\n</div>\n<!-- aa -->\n</style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: true });
 });
 
 QUnit.test('remove CDATA sections from scripts/styles', function(assert) {
   var input, output;
 
   input = '<script><![CDATA[\nalert(1)\n]]></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><![CDATA[alert(2)]]></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><![CDATA[alert(3)\n]]></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><![CDATA[\nalert(4)]]></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script><![CDATA[alert(5)\nalert(6)\nalert(7)]]></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script>/*<![CDATA[*/alert(8)/*]]>*/</script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script>alert(8)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script>//<![CDATA[\nalert(9)\n//]]></script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script>alert(9)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/javascript"> /* \n\t  <![CDATA[  */ alert(10) /*  ]]>  */ \n </script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script type="text/javascript">alert(10)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script>\n\n//<![CDATA[\nalert(11)//]]></script>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<script>alert(11)</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<style><![CDATA[\np.a{background:red}\n]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><![CDATA[p.b{background:red}]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><![CDATA[p.c{background:red}\n]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><![CDATA[\np.d{background:red}]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style></style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style><![CDATA[p.e{background:red}\np.f{background:red}\np.g{background:red}]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.f{background:red}p.g{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style>p.h{background:red}<![CDATA[\np.i{background:red}\n]]>p.j{background:red}</style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p.h{background:red}]]>p.j{background:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style>/* <![CDATA[ */p { color: red } // ]]></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p{color:red}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style type="text/html">\n<div>\n</div>\n<![CDATA[ aa ]]>\n</style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: true });
 });
 
 QUnit.test('custom processors', function(assert) {
@@ -995,125 +997,125 @@ QUnit.test('custom processors', function(assert) {
   }
 
   input = '<style>\n.foo { font: 12pt "bar" } </style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: null }, input);
-  test_minify_sync(assert, input, { minifyCSS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: null });
+  test_minify(assert, input, input, { minifyCSS: false });
   output = '<style>Normal CSS</style>';
-  test_minify_sync(assert, input, { minifyCSS: css }, output);
+  test_minify(assert, input, output, { minifyCSS: css });
 
   input = '<p style="font: 12pt \'bar\'"></p>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: null }, input);
-  test_minify_sync(assert, input, { minifyCSS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: null });
+  test_minify(assert, input, input, { minifyCSS: false });
   output = '<p style="inline CSS"></p>';
-  test_minify_sync(assert, input, { minifyCSS: css }, output);
+  test_minify(assert, input, output, { minifyCSS: css });
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: null }, input);
-  test_minify_sync(assert, input, { minifyCSS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: null });
+  test_minify(assert, input, input, { minifyCSS: false });
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="media CSS">';
-  test_minify_sync(assert, input, { minifyCSS: css }, output);
+  test_minify(assert, input, output, { minifyCSS: css });
 
   input = '<style media="(max-width: 737px)"></style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: null }, input);
-  test_minify_sync(assert, input, { minifyCSS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyCSS: null });
+  test_minify(assert, input, input, { minifyCSS: false });
   output = '<style media="media CSS">Normal CSS</style>';
-  test_minify_sync(assert, input, { minifyCSS: css }, output);
+  test_minify(assert, input, output, { minifyCSS: css });
 
   function js(text, inline) {
     return inline ? 'Inline JS' : 'Normal JS';
   }
 
   input = '<script>\nalert(1); </script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: null }, input);
-  test_minify_sync(assert, input, { minifyJS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: null });
+  test_minify(assert, input, input, { minifyJS: false });
   output = '<script>Normal JS</script>';
-  test_minify_sync(assert, input, { minifyJS: js }, output);
+  test_minify(assert, input, output, { minifyJS: js });
 
   input = '<p onload="alert(1);"></p>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyJS: null }, input);
-  test_minify_sync(assert, input, { minifyJS: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyJS: null });
+  test_minify(assert, input, input, { minifyJS: false });
   output = '<p onload="Inline JS"></p>';
-  test_minify_sync(assert, input, { minifyJS: js }, output);
+  test_minify(assert, input, output, { minifyJS: js });
 
   function url() {
     return 'URL';
   }
 
   input = '<a href="http://site.com/foo">bar</a>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyURLs: null }, input);
-  test_minify_sync(assert, input, { minifyURLs: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyURLs: null });
+  test_minify(assert, input, input, { minifyURLs: false });
   output = '<a href="URL">bar</a>';
-  test_minify_sync(assert, input, { minifyURLs: url }, output);
+  test_minify(assert, input, output, { minifyURLs: url });
 
   input = '<style>\n.foo { background: url("http://site.com/foo") } </style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyURLs: null }, input);
-  test_minify_sync(assert, input, { minifyURLs: false }, input);
-  test_minify_sync(assert, input, { minifyURLs: url }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { minifyURLs: null });
+  test_minify(assert, input, input, { minifyURLs: false });
+  test_minify(assert, input, input, { minifyURLs: url });
   output = '<style>.foo{background:url(URL)}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true, minifyURLs: url }, output);
+  test_minify(assert, input, output, { minifyCSS: true, minifyURLs: url });
 });
 
 QUnit.test('empty attributes', function(assert) {
   var input;
 
   input = '<p id="" class="" STYLE=" " title="\n" lang="" dir="">x</p>';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
+  test_minify(assert, input, '<p>x</p>', { removeEmptyAttributes: true });
 
   input = '<p onclick=""   ondblclick=" " onmousedown="" ONMOUSEUP="" onmouseover=" " onmousemove="" onmouseout="" ' +
           'onkeypress=\n\n  "\n     " onkeydown=\n"" onkeyup\n="">x</p>';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<p>x</p>');
+  test_minify(assert, input, '<p>x</p>', { removeEmptyAttributes: true });
 
   input = '<input onfocus="" onblur="" onchange=" " value=" boo ">';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<input value=" boo ">');
+  test_minify(assert, input, '<input value=" boo ">', { removeEmptyAttributes: true });
 
   input = '<input value="" name="foo">';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<input name="foo">');
+  test_minify(assert, input, '<input name="foo">', { removeEmptyAttributes: true });
 
   input = '<img src="" alt="">';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<img src="" alt="">');
+  test_minify(assert, input, '<img src="" alt="">', { removeEmptyAttributes: true });
 
   // preserve unrecognized attribute
   // remove recognized attrs with unspecified values
   input = '<div data-foo class id style title lang dir onfocus onblur onchange onclick ondblclick onmousedown onmouseup onmouseover onmousemove onmouseout onkeypress onkeydown onkeyup></div>';
-  test_minify_sync(assert, input, { removeEmptyAttributes: true }, '<div data-foo></div>');
+  test_minify(assert, input, '<div data-foo></div>', { removeEmptyAttributes: true });
 
   // additional remove attributes
   input = '<img src="" alt="">';
-  test_minify_sync(assert, input, { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } }, '<img alt="">');
+  test_minify(assert, input, '<img alt="">', { removeEmptyAttributes: function(attrName, tag) { return tag === 'img' && attrName === 'src'; } });
 });
 
 QUnit.test('cleaning class/style attributes', function(assert) {
   var input, output;
 
   input = '<p class=" foo bar  ">foo bar baz</p>';
-  test_minify_sync(assert, input, '<p class="foo bar">foo bar baz</p>');
+  test_minify(assert, input, '<p class="foo bar">foo bar baz</p>');
 
   input = '<p class=" foo      ">foo bar baz</p>';
-  test_minify_sync(assert, input, '<p class="foo">foo bar baz</p>');
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p class=foo>foo bar baz</p>');
+  test_minify(assert, input, '<p class="foo">foo bar baz</p>');
+  test_minify(assert, input, '<p class=foo>foo bar baz</p>', { removeAttributeQuotes: true });
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n   ">foo bar baz</p>';
   output = '<p class="foo">foo bar baz</p>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<p class="\n  \n foo   \n\n\t  \t\n  class1 class-23 ">foo bar baz</p>';
   output = '<p class="foo class1 class-23">foo bar baz</p>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<p style="    color: red; background-color: rgb(100, 75, 200);  "></p>';
   output = '<p style="color: red; background-color: rgb(100, 75, 200);"></p>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<p style="font-weight: bold  ; "></p>';
   output = '<p style="font-weight: bold;"></p>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('cleaning URI-based attributes', function(assert) {
@@ -1121,41 +1123,41 @@ QUnit.test('cleaning URI-based attributes', function(assert) {
 
   input = '<a href="   http://example.com  ">x</a>';
   output = '<a href="http://example.com">x</a>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<a href="  \t\t  \n \t  ">x</a>';
   output = '<a href="">x</a>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<img src="   http://example.com  " title="bleh   " longdesc="  http://example.com/longdesc \n\n   \t ">';
   output = '<img src="http://example.com" title="bleh   " longdesc="http://example.com/longdesc">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<img src="" usemap="   http://example.com  ">';
   output = '<img src="" usemap="http://example.com">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<form action="  somePath/someSubPath/someAction?foo=bar&baz=qux     "></form>';
   output = '<form action="somePath/someSubPath/someAction?foo=bar&baz=qux"></form>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<BLOCKQUOTE cite=" \n\n\n http://www.mycom.com/tolkien/twotowers.html     "><P>foobar</P></BLOCKQUOTE>';
   output = '<blockquote cite="http://www.mycom.com/tolkien/twotowers.html"><p>foobar</p></blockquote>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<head profile="       http://gmpg.org/xfn/11    "></head>';
   output = '<head profile="http://gmpg.org/xfn/11"></head>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<object codebase="   http://example.com  "></object>';
   output = '<object codebase="http://example.com"></object>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<span profile="   1, 2, 3  ">foo</span>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   input = '<div action="  foo-bar-baz ">blah</div>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('cleaning Number-based attributes', function(assert) {
@@ -1163,27 +1165,27 @@ QUnit.test('cleaning Number-based attributes', function(assert) {
 
   input = '<a href="#" tabindex="   1  ">x</a><button tabindex="   2  ">y</button>';
   output = '<a href="#" tabindex="1">x</a><button tabindex="2">y</button>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<input value="" maxlength="     5 ">';
   output = '<input value="" maxlength="5">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<select size="  10   \t\t "><option>x</option></select>';
   output = '<select size="10"><option>x</option></select>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<textarea rows="   20  " cols="  30      "></textarea>';
   output = '<textarea rows="20" cols="30"></textarea>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<COLGROUP span="   40  "><COL span="  39 "></COLGROUP>';
   output = '<colgroup span="40"><col span="39"></colgroup>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<tr><td colspan="    2   ">x</td><td rowspan="   3 "></td></tr>';
   output = '<tr><td colspan="2">x</td><td rowspan="3"></td></tr>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('cleaning other attributes', function(assert) {
@@ -1191,50 +1193,50 @@ QUnit.test('cleaning other attributes', function(assert) {
 
   input = '<a href="#" onclick="  window.prompt(\'boo\'); " onmouseover=" \n\n alert(123)  \t \n\t  ">blah</a>';
   output = '<a href="#" onclick="window.prompt(\'boo\');" onmouseover="alert(123)">blah</a>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</p></body>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('removing redundant attributes (&lt;form method="get" ...>)', function(assert) {
   var input;
 
   input = '<form method="get">hello world</form>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<form>hello world</form>');
+  test_minify(assert, input, '<form>hello world</form>', { removeRedundantAttributes: true });
 
   input = '<form method="post">hello world</form>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<form method="post">hello world</form>');
+  test_minify(assert, input, '<form method="post">hello world</form>', { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;input type="text" ...>)', function(assert) {
   var input;
 
   input = '<input type="text">';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input>');
+  test_minify(assert, input, '<input>', { removeRedundantAttributes: true });
 
   input = '<input type="  TEXT  " value="foo">';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input value="foo">');
+  test_minify(assert, input, '<input value="foo">', { removeRedundantAttributes: true });
 
   input = '<input type="checkbox">';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<input type="checkbox">');
+  test_minify(assert, input, '<input type="checkbox">', { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;a name="..." id="..." ...>)', function(assert) {
   var input;
 
   input = '<a id="foo" name="foo">blah</a>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<a id="foo">blah</a>');
+  test_minify(assert, input, '<a id="foo">blah</a>', { removeRedundantAttributes: true });
 
   input = '<input id="foo" name="foo">';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify(assert, input, input, { removeRedundantAttributes: true });
 
   input = '<a name="foo">blah</a>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify(assert, input, input, { removeRedundantAttributes: true });
 
   input = '<a href="..." name="  bar  " id="bar" >blah</a>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<a href="..." id="bar">blah</a>');
+  test_minify(assert, input, '<a href="..." id="bar">blah</a>', { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)', function(assert) {
@@ -1242,125 +1244,125 @@ QUnit.test('removing redundant attributes (&lt;script src="..." charset="...">)'
 
   input = '<script type="text/javascript" charset="UTF-8">alert(222);</script>';
   output = '<script type="text/javascript">alert(222);</script>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify(assert, input, output, { removeRedundantAttributes: true });
 
   input = '<script type="text/javascript" src="http://example.com" charset="UTF-8">alert(222);</script>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, input);
+  test_minify(assert, input, input, { removeRedundantAttributes: true });
 
   input = '<script CHARSET=" ... ">alert(222);</script>';
   output = '<script>alert(222);</script>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify(assert, input, output, { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;... language="javascript" ...>)', function(assert) {
   var input;
 
   input = '<script language="Javascript">x=2,y=4</script>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
+  test_minify(assert, input, '<script>x=2,y=4</script>', { removeRedundantAttributes: true });
 
   input = '<script LANGUAGE = "  javaScript  ">x=2,y=4</script>';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, '<script>x=2,y=4</script>');
+  test_minify(assert, input, '<script>x=2,y=4</script>', { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;area shape="rect" ...>)', function(assert) {
   var input = '<area shape="rect" coords="696,25,958,47" href="#" title="foo">';
   var output = '<area coords="696,25,958,47" href="#" title="foo">';
-  test_minify_sync(assert, input, { removeRedundantAttributes: true }, output);
+  test_minify(assert, input, output, { removeRedundantAttributes: true });
 });
 
 QUnit.test('removing redundant attributes (&lt;... = "javascript: ..." ...>)', function(assert) {
   var input;
 
   input = '<p onclick="javascript:alert(1)">x</p>';
-  test_minify_sync(assert, input, '<p onclick="alert(1)">x</p>');
+  test_minify(assert, input, '<p onclick="alert(1)">x</p>');
 
   input = '<p onclick="javascript:x">x</p>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p onclick=x>x</p>');
+  test_minify(assert, input, '<p onclick=x>x</p>', { removeAttributeQuotes: true });
 
   input = '<p onclick=" JavaScript: x">x</p>';
-  test_minify_sync(assert, input, '<p onclick="x">x</p>');
+  test_minify(assert, input, '<p onclick="x">x</p>');
 
   input = '<p title="javascript:(function() { /* some stuff here */ })()">x</p>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('removing javascript type attributes', function(assert) {
   var input, output;
 
   input = '<script type="">alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: false }, input);
+  test_minify(assert, input, input, { removeScriptTypeAttributes: false });
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeScriptTypeAttributes: true });
 
   input = '<script type="text/javascript">alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: false }, input);
+  test_minify(assert, input, input, { removeScriptTypeAttributes: false });
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeScriptTypeAttributes: true });
 
   input = '<SCRIPT TYPE="  text/javascript ">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeScriptTypeAttributes: true });
 
   input = '<script type="application/javascript;version=1.8">alert(1)</script>';
   output = '<script>alert(1)</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeScriptTypeAttributes: true });
 
   input = '<script type="text/vbscript">MsgBox("foo bar")</script>';
   output = '<script type="text/vbscript">MsgBox("foo bar")</script>';
-  test_minify_sync(assert, input, { removeScriptTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeScriptTypeAttributes: true });
 });
 
 QUnit.test('removing type="text/css" attributes', function(assert) {
   var input, output;
 
   input = '<style type="">.foo { color: red }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: false }, input);
+  test_minify(assert, input, input, { removeStyleLinkTypeAttributes: false });
   output = '<style>.foo { color: red }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeStyleLinkTypeAttributes: true });
 
   input = '<style type="text/css">.foo { color: red }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: false }, input);
+  test_minify(assert, input, input, { removeStyleLinkTypeAttributes: false });
   output = '<style>.foo { color: red }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeStyleLinkTypeAttributes: true });
 
   input = '<STYLE TYPE = "  text/CSS ">body { font-size: 1.75em }</style>';
   output = '<style>body { font-size: 1.75em }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeStyleLinkTypeAttributes: true });
 
   input = '<style type="text/plain">.foo { background: green }</style>';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, input);
+  test_minify(assert, input, input, { removeStyleLinkTypeAttributes: true });
 
   input = '<link rel="stylesheet" type="text/css" href="http://example.com">';
   output = '<link rel="stylesheet" href="http://example.com">';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, output);
+  test_minify(assert, input, output, { removeStyleLinkTypeAttributes: true });
 
   input = '<link rel="alternate" type="application/atom+xml" href="data.xml">';
-  test_minify_sync(assert, input, { removeStyleLinkTypeAttributes: true }, input);
+  test_minify(assert, input, input, { removeStyleLinkTypeAttributes: true });
 });
 
 QUnit.test('removing attribute quotes', function(assert) {
   var input;
 
   input = '<p title="blah" class="a23B-foo.bar_baz:qux" id="moo">foo</p>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>');
+  test_minify(assert, input, '<p title=blah class=a23B-foo.bar_baz:qux id=moo>foo</p>', { removeAttributeQuotes: true });
 
   input = '<input value="hello world">';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<input value="hello world">');
+  test_minify(assert, input, '<input value="hello world">', { removeAttributeQuotes: true });
 
   input = '<a href="#" title="foo#bar">x</a>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a href=# title=foo#bar>x</a>');
+  test_minify(assert, input, '<a href=# title=foo#bar>x</a>', { removeAttributeQuotes: true });
 
   input = '<a href="http://example.com/" title="blah">\nfoo\n\n</a>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a href=http://example.com/ title=blah>\nfoo\n\n</a>');
+  test_minify(assert, input, '<a href=http://example.com/ title=blah>\nfoo\n\n</a>', { removeAttributeQuotes: true });
 
   input = '<a title="blah" href="http://example.com/">\nfoo\n\n</a>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<a title=blah href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify(assert, input, '<a title=blah href=http://example.com/ >\nfoo\n\n</a>', { removeAttributeQuotes: true });
 
   input = '<a href="http://example.com/" title="">\nfoo\n\n</a>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true, removeEmptyAttributes: true }, '<a href=http://example.com/ >\nfoo\n\n</a>');
+  test_minify(assert, input, '<a href=http://example.com/ >\nfoo\n\n</a>', { removeAttributeQuotes: true, removeEmptyAttributes: true });
 
   input = '<p class=foo|bar:baz></p>';
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, '<p class=foo|bar:baz></p>');
+  test_minify(assert, input, '<p class=foo|bar:baz></p>', { removeAttributeQuotes: true });
 });
 
 QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
@@ -1372,10 +1374,10 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   input = '<input checked="checked">';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   // With multiple rules
   customAttrOptions = {
@@ -1386,16 +1388,16 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   input = '<input {{#unless value}}checked="checked"{{/unless}}>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   input = '<input {{#if value1}}data-attr="example" {{/if}}{{#unless value2}}checked="checked"{{/unless}}>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   input = '<input checked="checked">';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 
   // With multiple rules and richer options
   customAttrOptions = {
@@ -1408,13 +1410,13 @@ QUnit.test('preserving custom attribute-wrapping markup', function(assert) {
   };
 
   input = '<input {{#if value}}checked="checked"{{/if}}>';
-  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value}}checked{{/if}}>');
+  test_minify(assert, input, '<input {{#if value}}checked{{/if}}>', customAttrOptions);
 
   input = '<input {{#if value1}}checked="checked"{{/if}} {{#if value2}}data-attr="foo"{{/if}}/>';
-  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>');
+  test_minify(assert, input, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo{{/if}}>', customAttrOptions);
 
   customAttrOptions.keepClosingSlash = true;
-  test_minify_sync(assert, input, customAttrOptions, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>');
+  test_minify(assert, input, '<input {{#if value1}}checked {{/if}}{{#if value2}}data-attr=foo {{/if}}/>', customAttrOptions);
 });
 
 QUnit.test('preserving custom attribute-joining markup', function(assert) {
@@ -1424,9 +1426,9 @@ QUnit.test('preserving custom attribute-joining markup', function(assert) {
     customAttrAssign: [polymerConditionalAttributeJoin]
   };
   input = '<div flex?="{{mode != cover}}"></div>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
   input = '<div flex?="{{mode != cover}}" class="foo"></div>';
-  test_minify_sync(assert, input, customAttrOptions, input);
+  test_minify(assert, input, input, customAttrOptions);
 });
 
 QUnit.test('collapsing whitespace', function(assert) {
@@ -1434,37 +1436,37 @@ QUnit.test('collapsing whitespace', function(assert) {
 
   input = '<script type="text/javascript">  \n\t   alert(1) \n\n\n  \t </script>';
   output = '<script type="text/javascript">alert(1)</script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<p>foo</p>    <p> bar</p>\n\n   \n\t\t  <div title="quz">baz  </div>';
   output = '<p>foo</p><p>bar</p><div title="quz">baz</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<p> foo    bar</p>';
   output = '<p>foo bar</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<p>foo\nbar</p>';
   output = '<p>foo bar</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<p> foo    <span>  blah     <i>   22</i>    </span> bar <img src=""></p>';
   output = '<p>foo <span>blah <i>22</i> </span>bar <img src=""></p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
   output = '<textarea> foo bar     baz \n\n   x \t    y </textarea>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<div><textarea></textarea>    </div>';
   output = '<div><textarea></textarea></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<div><pRe> $foo = "baz"; </pRe>    </div>';
   output = '<div><pre> $foo = "baz"; </pre></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
   output = '<div><pRe>$foo = "baz";</pRe></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, caseSensitive: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, caseSensitive: true });
 
   input = '<script type="text/javascript">var = "hello";</script>\r\n\r\n\r\n' +
           '<style type="text/css">#foo { color: red;        }          </style>\r\n\r\n\r\n' +
@@ -1482,153 +1484,153 @@ QUnit.test('collapsing whitespace', function(assert) {
            '</div></div></div></div></div></div>' +
            '<pre>       \r\nxxxx</pre><span>x</span> <span>Hello</span> <b>billy</b> ' +
            '<input type="text"> <textarea></textarea><pre></pre>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<pre title="some title...">   hello     world </pre>';
   output = '<pre title="some title...">   hello     world </pre>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<pre title="some title..."><code>   hello     world </code></pre>';
   output = '<pre title="some title..."><code>   hello     world </code></pre>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<script>alert("foo     bar")    </script>';
   output = '<script>alert("foo     bar")</script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<style>alert("foo     bar")    </style>';
   output = '<style>alert("foo     bar")</style>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 });
 
 QUnit.test('removing empty elements', function(assert) {
   var input, output;
 
-  test_minify_sync(assert, '<p>x</p>', { removeEmptyElements: true }, '<p>x</p>');
-  test_minify_sync(assert, '<p></p>', { removeEmptyElements: true }, '');
+  test_minify(assert, '<p>x</p>', '<p>x</p>', { removeEmptyElements: true });
+  test_minify(assert, '<p></p>', '', { removeEmptyElements: true });
 
   input = '<p>foo<span>bar</span><span></span></p>';
   output = '<p>foo<span>bar</span></p>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<a href="http://example/com" title="hello world"></a>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<iframe></iframe>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<iframe src="page.html"></iframe>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<iframe srcdoc="<h1>Foo</h1>"></iframe>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<video></video>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<video src="preview.ogg"></video>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<audio autoplay></audio>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<audio src="startup.mp3" autoplay></audio>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<object type="application/x-shockwave-flash"></object>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<object data="game.swf" type="application/x-shockwave-flash"></object>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<applet archive="game.zip" width="250" height="150"></applet>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<applet code="game.class" archive="game.zip" width="250" height="150"></applet>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<textarea cols="10" rows="10"></textarea>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<div>hello<span>world</span></div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<p>x<span title="<" class="blah-moo"></span></p>';
   output = '<p>x</p>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<div>x<div>y <div>blah</div><div></div>foo</div>z</div>';
   output = '<div>x<div>y <div>blah</div>foo</div>z</div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<img src="">';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
 
   input = '<p><!-- x --></p>';
   output = '';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
 
   input = '<script src="foo.js"></script>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
   input = '<script></script>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, '');
+  test_minify(assert, input, '', { removeEmptyElements: true });
 
   input = '<div>after<span></span> </div>';
   output = '<div>after </div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
   output = '<div>after</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeEmptyElements: true });
 
   input = '<div>before <span></span></div>';
   output = '<div>before </div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
   output = '<div>before</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeEmptyElements: true });
 
   input = '<div>both <span></span> </div>';
   output = '<div>both  </div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
   output = '<div>both</div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeEmptyElements: true });
 
   input = '<div>unary <span></span><link></div>';
   output = '<div>unary <link></div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeEmptyElements: true });
   output = '<div>unary<link></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeEmptyElements: true });
 
   input = '<div>Empty <!-- NOT --> </div>';
-  test_minify_sync(assert, input, { removeEmptyElements: true }, input);
+  test_minify(assert, input, input, { removeEmptyElements: true });
   output = '<div>Empty<!-- NOT --></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeEmptyElements: true });
 });
 
 QUnit.test('collapsing boolean attributes', function(assert) {
   var input, output;
 
   input = '<input disabled="disabled">';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input disabled>');
+  test_minify(assert, input, '<input disabled>', { collapseBooleanAttributes: true });
 
   input = '<input CHECKED = "checked" readonly="readonly">';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input checked readonly>');
+  test_minify(assert, input, '<input checked readonly>', { collapseBooleanAttributes: true });
 
   input = '<option name="blah" selected="selected">moo</option>';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<option name="blah" selected>moo</option>');
+  test_minify(assert, input, '<option name="blah" selected>moo</option>', { collapseBooleanAttributes: true });
 
   input = '<input autofocus="autofocus">';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input autofocus>');
+  test_minify(assert, input, '<input autofocus>', { collapseBooleanAttributes: true });
 
   input = '<input required="required">';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input required>');
+  test_minify(assert, input, '<input required>', { collapseBooleanAttributes: true });
 
   input = '<input multiple="multiple">';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, '<input multiple>');
+  test_minify(assert, input, '<input multiple>', { collapseBooleanAttributes: true });
 
   input = '<div Allowfullscreen=foo Async=foo Autofocus=foo Autoplay=foo Checked=foo Compact=foo Controls=foo ' +
     'Declare=foo Default=foo Defaultchecked=foo Defaultmuted=foo Defaultselected=foo Defer=foo Disabled=foo ' +
@@ -1640,129 +1642,129 @@ QUnit.test('collapsing boolean attributes', function(assert) {
     'defaultmuted defaultselected defer disabled enabled formnovalidate hidden indeterminate inert ' +
     'ismap itemscope loop multiple muted nohref noresize noshade novalidate nowrap open pauseonexit readonly ' +
     'required reversed scoped seamless selected sortable truespeed typemustmatch visible></div>';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true }, output);
+  test_minify(assert, input, output, { collapseBooleanAttributes: true });
   output = '<div Allowfullscreen Async Autofocus Autoplay Checked Compact Controls Declare Default Defaultchecked ' +
     'Defaultmuted Defaultselected Defer Disabled Enabled Formnovalidate Hidden Indeterminate Inert ' +
     'Ismap Itemscope Loop Multiple Muted Nohref Noresize Noshade Novalidate Nowrap Open Pauseonexit Readonly ' +
     'Required Reversed Scoped Seamless Selected Sortable Truespeed Typemustmatch Visible></div>';
-  test_minify_sync(assert, input, { collapseBooleanAttributes: true, caseSensitive: true }, output);
+  test_minify(assert, input, output, { collapseBooleanAttributes: true, caseSensitive: true });
 });
 
 QUnit.test('collapsing enumerated attributes', function(assert) {
-  test_minify_sync(assert, '<div draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
-  test_minify_sync(assert, '<div draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
-  test_minify_sync(assert, '<div draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div Draggable="auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div Draggable="true"></div>', { collapseBooleanAttributes: true }, '<div draggable="true"></div>');
-  test_minify_sync(assert, '<div Draggable="false"></div>', { collapseBooleanAttributes: true }, '<div draggable="false"></div>');
-  test_minify_sync(assert, '<div Draggable="foo"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div Draggable></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
-  test_minify_sync(assert, '<div draggable="Auto"></div>', { collapseBooleanAttributes: true }, '<div draggable></div>');
+  test_minify(assert, '<div draggable="auto"></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div draggable="true"></div>', '<div draggable="true"></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div draggable="false"></div>', '<div draggable="false"></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div draggable="foo"></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div draggable></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div Draggable="auto"></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div Draggable="true"></div>', '<div draggable="true"></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div Draggable="false"></div>', '<div draggable="false"></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div Draggable="foo"></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div Draggable></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
+  test_minify(assert, '<div draggable="Auto"></div>', '<div draggable></div>', { collapseBooleanAttributes: true });
 });
 
 QUnit.test('keeping trailing slashes in tags', function(assert) {
-  test_minify_sync(assert, '<img src="test"/>', { keepClosingSlash: true }, '<img src="test"/>');
+  test_minify(assert, '<img src="test"/>', '<img src="test"/>', { keepClosingSlash: true });
   // https://github.com/kangax/html-minifier/issues/233
-  test_minify_sync(assert, '<img src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img src=test />');
-  test_minify_sync(assert, '<img src="test" id=""/>', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true }, '<img src=test />');
-  test_minify_sync(assert, '<img title="foo" src="test"/>', { keepClosingSlash: true, removeAttributeQuotes: true }, '<img title=foo src=test />');
+  test_minify(assert, '<img src="test"/>', '<img src=test />', { keepClosingSlash: true, removeAttributeQuotes: true });
+  test_minify(assert, '<img src="test" id=""/>', '<img src=test />', { keepClosingSlash: true, removeAttributeQuotes: true, removeEmptyAttributes: true });
+  test_minify(assert, '<img title="foo" src="test"/>', '<img title=foo src=test />', { keepClosingSlash: true, removeAttributeQuotes: true });
 });
 
 QUnit.test('removing optional tags', function(assert) {
   var input, output;
 
   input = '<p>foo';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
+  test_minify(assert, input, input, { removeOptionalTags: true });
 
   input = '</p>';
   output = '<p>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<body></body>';
   output = '';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
-  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
+  test_minify(assert, input, output, { removeOptionalTags: true, removeEmptyElements: true });
 
   input = '<html><head></head><body></body></html>';
   output = '';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
-  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
+  test_minify(assert, input, output, { removeOptionalTags: true, removeEmptyElements: true });
 
   input = ' <html></html>';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html> </html>';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html></html> ';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = ' <html><body></body></html>';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html> <body></body></html>';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html><body> </body></html>';
   output = '<body> ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html><body></body> </html>';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html><body></body></html> ';
   output = ' ';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<html><head><title>hello</title></head><body><p>foo<span>bar</span></p></body></html>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<title>hello</title><p>foo<span>bar</span>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<html lang=""><head><title>hello</title></head><body style=""><p>foo<span>bar</span></p></body></html>';
   output = '<html lang=""><title>hello</title><body style=""><p>foo<span>bar</span>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
   output = '<title>hello</title><p>foo<span>bar</span>';
-  test_minify_sync(assert, input, { removeOptionalTags: true, removeEmptyAttributes: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true, removeEmptyAttributes: true });
 
   input = '<html><head><title>a</title><link href="b.css" rel="stylesheet"/></head><body><a href="c.html"></a><div class="d"><input value="e"/></div></body></html>';
   output = '<title>a</title><link href="b.css" rel="stylesheet"><a href="c.html"></a><div class="d"><input value="e"></div>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><div><p>This is some text in a div</p><details>Followed by some details</details></div><div><p>This is some more text in a div</p></div></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><div><p>This is some text in a div<details>Followed by some details</details></div><div><p>This is some more text in a div</div>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<!DOCTYPE html><html><head><title>Blah</title></head><body><noscript><p>This is some text in a noscript</p><details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript></body></html>';
   output = '<!DOCTYPE html><title>Blah</title><body><noscript><p>This is some text in a noscript<details>Followed by some details</details></noscript><noscript><p>This is some more text in a noscript</p></noscript>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<md-list-item ui-sref=".app-config"><md-icon md-font-icon="mdi-settings"></md-icon><p translate>Configure</p></md-list-item>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
+  test_minify(assert, input, input, { removeOptionalTags: true });
 });
 
 QUnit.test('removing optional tags in tables', function(assert) {
@@ -1773,22 +1775,22 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<tbody><tr><td>boo</td><td>moo</td><td>loo</td></tr> </tbody>' +
             '<tfoot><tr><th>baz</th> <th>qux</th><td>boo</td></tr></tfoot>' +
           '</table>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar</th> <th>baz</thead> ' +
              '<tr><td>boo<td>moo<td>loo</tr> ' +
              '<tfoot><tr><th>baz</th> <th>qux<td>boo' +
            '</table>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   output = '<table>' +
              '<thead><tr><th>foo<th>bar<th>baz' +
              '<tbody><tr><td>boo<td>moo<td>loo' +
              '<tfoot><tr><th>baz<th>qux<td>boo' +
            '</table>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeOptionalTags: true }, output);
-  test_minify_sync(assert, output, { collapseWhitespace: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeOptionalTags: true });
+  test_minify(assert, output, output, { collapseWhitespace: true, removeOptionalTags: true });
 
   input = '<table>' +
             '<caption>foo</caption>' +
@@ -1797,7 +1799,7 @@ QUnit.test('removing optional tags in tables', function(assert) {
             '<!-- blah -->' +
             '<tbody><tr><th>bar</th><td>baz</td><th>qux</th></tr></tbody>' +
           '</table>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   output = '<table>' +
              '<caption>foo</caption>' +
@@ -1806,23 +1808,23 @@ QUnit.test('removing optional tags in tables', function(assert) {
              '<!-- blah -->' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
-  test_minify_sync(assert, output, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
+  test_minify(assert, output, output, { removeOptionalTags: true });
 
   output = '<table>' +
              '<caption>foo' +
              '<col span="2"><col>' +
              '<tr><th>bar<td>baz<th>qux' +
            '</table>';
-  test_minify_sync(assert, input, { removeComments: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeComments: true, removeOptionalTags: true });
 
   input = '<table>' +
             '<tbody></tbody>' +
           '</table>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
   output = '<table><tbody></table>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 });
 
 QUnit.test('removing optional tags in options', function(assert) {
@@ -1830,17 +1832,17 @@ QUnit.test('removing optional tags in options', function(assert) {
 
   input = '<select><option>foo</option><option>bar</option></select>';
   output = '<select><option>foo<option>bar</select>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 
   input = '<select>\n' +
           '  <option>foo</option>\n' +
           '  <option>bar</option>\n' +
           '</select>';
-  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
+  test_minify(assert, input, input, { removeOptionalTags: true });
   output = '<select><option>foo<option>bar</select>';
-  test_minify_sync(assert, input, { removeOptionalTags: true, collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true, collapseWhitespace: true });
   output = '<select> <option>foo</option> <option>bar</option> </select>';
-  test_minify_sync(assert, input, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true, collapseWhitespace: true, conservativeCollapse: true });
 
   // example from htmldog.com
   input = '<select name="catsndogs">' +
@@ -1859,40 +1861,40 @@ QUnit.test('removing optional tags in options', function(assert) {
                '<option>Grey Wolf<option>Red Fox<option>Fennec' +
            '</select>';
 
-  test_minify_sync(assert, input, { removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { removeOptionalTags: true });
 });
 
 QUnit.test('custom components', function(assert) {
   var input = '<custom-component>Oh, my.</custom-component>';
   var output = '<custom-component>Oh, my.</custom-component>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('HTML4: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  test_minify_sync(assert, input, { html5: false }, input);
+  test_minify(assert, input, input, { html5: false });
 });
 
 QUnit.test('HTML5: anchor with inline elements', function(assert) {
   var input = '<a href="#"><span>Well, look at me! I\'m a span!</span></a>';
-  test_minify_sync(assert, input, { html5: true }, input);
+  test_minify(assert, input, input, { html5: true });
 });
 
 QUnit.test('HTML4: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"></a><div>Well, look at me! I\'m a div!</div>';
-  test_minify_sync(assert, input, { html5: false }, output);
+  test_minify(assert, input, output, { html5: false });
 });
 
 QUnit.test('HTML5: anchor with block elements', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   var output = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  test_minify_sync(assert, input, { html5: true }, output);
+  test_minify(assert, input, output, { html5: true });
 });
 
 QUnit.test('HTML5: enabled by default', function(assert) {
   var input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
-  test_minify_sync(assert, input, { html5: true }, minify(input));
+  test_minify(assert, input, minify(input), { html5: true });
 });
 
 QUnit.test('phrasing content', function(assert) {
@@ -1900,12 +1902,12 @@ QUnit.test('phrasing content', function(assert) {
 
   input = '<p>a<div>b</div>';
   output = '<p>a</p><div>b</div>';
-  test_minify_sync(assert, input, { html5: true }, output);
+  test_minify(assert, input, output, { html5: true });
   output = '<p>a<div>b</div></p>';
-  test_minify_sync(assert, input, { html5: false }, output);
+  test_minify(assert, input, output, { html5: false });
 
   input = '<label>a<div>b</div>c</label>';
-  test_minify_sync(assert, input, { html5: true }, input);
+  test_minify(assert, input, input, { html5: true });
 });
 
 // https://github.com/kangax/html-minifier/issues/888
@@ -1914,29 +1916,29 @@ QUnit.test('ul/ol should be phrasing content', function(assert) {
 
   input = '<p>a<ul><li>item</li></ul>';
   output = '<p>a</p><ul><li>item</li></ul>';
-  test_minify_sync(assert, input, { html5: true }, output);
+  test_minify(assert, input, output, { html5: true });
 
   output = '<p>a<ul><li>item</ul>';
-  test_minify_sync(assert, input, { html5: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { html5: true, removeOptionalTags: true });
 
   output = '<p>a<ul><li>item</li></ul></p>';
-  test_minify_sync(assert, input, { html5: false }, output);
+  test_minify(assert, input, output, { html5: false });
 
   input = '<p>a<ol><li>item</li></ol></p>';
   output = '<p>a</p><ol><li>item</li></ol><p></p>';
-  test_minify_sync(assert, input, { html5: true }, output);
+  test_minify(assert, input, output, { html5: true });
 
   output = '<p>a<ol><li>item</ol><p>';
-  test_minify_sync(assert, input, { html5: true, removeOptionalTags: true }, output);
+  test_minify(assert, input, output, { html5: true, removeOptionalTags: true });
 
   output = '<p>a</p><ol><li>item</li></ol>';
-  test_minify_sync(assert, input, { html5: true, removeEmptyElements: true }, output);
+  test_minify(assert, input, output, { html5: true, removeEmptyElements: true });
 });
 
 QUnit.test('phrasing content with Web Components', function(assert) {
   var input = '<span><phrasing-element></phrasing-element></span>';
   var output = '<span><phrasing-element></phrasing-element></span>';
-  test_minify_sync(assert, input, { html5: true }, output);
+  test_minify(assert, input, output, { html5: true });
 });
 
 // https://github.com/kangax/html-minifier/issues/10
@@ -1946,52 +1948,52 @@ QUnit.test('Ignore custom fragments', function(assert) {
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n{{ ... }}\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %> <%= ... %> <? ... ?> No comment, but middle. {{ ... }} <?php ... ?> <?xml ... ?> Hello, this is the end!';
-  test_minify_sync(assert, input, {}, input);
-  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {});
+  test_minify(assert, input, output, { removeComments: true, collapseWhitespace: true });
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     ignoreCustomFragments: reFragments
-  }, output);
+  });
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle. {{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n{{ ... }}\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true,
     ignoreCustomFragments: reFragments
-  }, output);
+  });
 
   input = '{{ if foo? }}\r\n  <div class="bar">\r\n    ...\r\n  </div>\r\n{{ end \n}}';
   output = '{{ if foo? }}<div class="bar">...</div>{{ end }}';
-  test_minify_sync(assert, input, {}, input);
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, { collapseWhitespace: true, ignoreCustomFragments: [] }, output);
+  test_minify(assert, input, input, {});
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, { collapseWhitespace: true, ignoreCustomFragments: [] });
 
   output = '{{ if foo? }} <div class="bar">...</div> {{ end \n}}';
-  test_minify_sync(assert, input, { collapseWhitespace: true, ignoreCustomFragments: reFragments }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, ignoreCustomFragments: reFragments });
 
   output = '{{ if foo? }}\n<div class="bar">\n...\n</div>\n{{ end \n}}';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true,
     ignoreCustomFragments: reFragments
-  }, output);
+  });
 
   input = '<a class="<% if foo? %>bar<% end %> {{ ... }}"></a>';
-  test_minify_sync(assert, input, {}, input);
-  test_minify_sync(assert, input, { ignoreCustomFragments: reFragments }, input);
+  test_minify(assert, input, input, {});
+  test_minify(assert, input, input, { ignoreCustomFragments: reFragments });
 
   input = '<img src="{% static "images/logo.png" %}">';
   output = '<img src="{% static "images/logo.png" %}">';
-  test_minify_sync(assert, input, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] }, output);
+  test_minify(assert, input, output, { ignoreCustomFragments: [/\{%[^%]*?%\}/g] });
 
   input = '<p{% if form.name.errors %}class=\'error\'{% endif %}>' +
             '{{ form.name.label_tag }}' +
@@ -2003,13 +2005,13 @@ QUnit.test('Ignore custom fragments', function(assert) {
             '{% endfor %}' +
             '{% endif %}' +
           '</p>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
     ],
     quoteCharacter: '\''
-  }, input);
+  });
   output = '<p {% if form.name.errors %} class=\'error\' {% endif %}>' +
              '{{ form.name.label_tag }}' +
              '{{ form.name }}' +
@@ -2020,151 +2022,151 @@ QUnit.test('Ignore custom fragments', function(assert) {
              '{% endfor %}' +
              '{% endif %}' +
            '</p>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     ignoreCustomFragments: [
       /\{%[\s\S]*?%\}/g,
       /\{\{[\s\S]*?\}\}/g
     ],
     quoteCharacter: '\'',
     collapseWhitespace: true
-  }, output);
+  });
 
   input = '<a href="/legal.htm"<?php echo e(Request::path() == \'/\' ? \' rel="nofollow"\':\'\'); ?>>Legal Notices</a>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /<\?php[\s\S]*?\?>/g
     ]
-  }, input);
+  });
 
   input = '<input type="checkbox"<%= (model.isChecked ? \'checked="checked"\' : \'\') %>>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /<%=[\s\S]*?%>/g
     ]
-  }, input);
+  });
 
   input = '<div' +
             '{{IF text}}' +
             'data-yashareDescription="{{shorted(text, 300)}}"' +
             '{{END IF}}></div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /\{\{[\s\S]*?\}\}/g
     ],
     caseSensitive: true
-  }, input);
+  });
 
   input = '<img class="{% foo %} {% bar %}">';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ]
-  }, input);
+  });
   // trimCustomFragments withOUT collapseWhitespace, does
   // not break the "{% foo %} {% bar %}" test
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
     trimCustomFragments: true
-  }, input);
+  });
   // trimCustomFragments WITH collapseWhitespace, changes output
   output = '<img class="{% foo %}{% bar %}">';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     ignoreCustomFragments: [
       /\{%[^%]*?%\}/g
     ],
     collapseWhitespace: true,
     trimCustomFragments: true
-  }, output);
+  });
 
   input = '<img class="titi.<%=tsItem_[0]%>">';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
 
   input = '<table id="<?php echo $this->escapeHtmlAttr($this->table_id); ?>"></table>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
 
   input = '<!--{{comment}}-->{{if a}}<div>b</div>{{/if}}';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '{{if a}}<div>b</div>{{/if}}';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     ignoreCustomFragments: [
       /\{\{.*?\}\}/g
     ]
-  }, output);
+  });
 
   // https://github.com/kangax/html-minifier/issues/722
   input = '<? echo "foo"; ?> <span>bar</span>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
   output = '<? echo "foo"; ?><span>bar</span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }, output);
+  });
 
   input = ' <? echo "foo"; ?> bar';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<? echo "foo"; ?> bar';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true
-  }, output);
+  });
   output = '<? echo "foo"; ?>bar';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }, output);
+  });
 
   input = '<span>foo</span> <? echo "bar"; ?> baz';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
   output = '<span>foo</span><? echo "bar"; ?>baz';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }, output);
+  });
 
   input = '<span>foo</span> <? echo "bar"; ?> <? echo "baz"; ?> <span>foo</span>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
   output = '<span>foo</span><? echo "bar"; ?><? echo "baz"; ?><span>foo</span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     trimCustomFragments: true
-  }, output);
+  });
 
   input = 'foo <WC@bar> baz moo </WC@bar> loo';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [
       /<(WC@[\s\S]*?)>(.*?)<\/\1>/
     ]
-  }, input);
+  });
   output = 'foo<wc @bar>baz moo</wc>loo';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true
-  }, output);
+  });
 
   input = '<link href="<?php echo \'http://foo/\' ?>">';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { removeAttributeQuotes: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { removeAttributeQuotes: true });
 
   input = '<pre>\nfoo\n<? bar ?>\nbaz\n</pre>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { collapseWhitespace: true });
 });
 
 QUnit.test('bootstrap\'s span > button > span', function(assert) {
@@ -2174,15 +2176,15 @@ QUnit.test('bootstrap\'s span > button > span', function(assert) {
                 '\n  </button>' +
               '</span>';
   var output = '<span class=input-group-btn><button class="btn btn-default" type=button><span class="glyphicon glyphicon-search"></span></button></span>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, removeAttributeQuotes: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, removeAttributeQuotes: true });
 });
 
 QUnit.test('caseSensitive', function(assert) {
   var input = '<div mixedCaseAttribute="value"></div>';
   var caseSensitiveOutput = '<div mixedCaseAttribute="value"></div>';
   var caseInSensitiveOutput = '<div mixedcaseattribute="value"></div>';
-  test_minify_sync(assert, input, caseInSensitiveOutput);
-  test_minify_sync(assert, input, { caseSensitive: true }, caseSensitiveOutput);
+  test_minify(assert, input, caseInSensitiveOutput);
+  test_minify(assert, input, caseSensitiveOutput, { caseSensitive: true });
 });
 
 QUnit.test('source & track', function(assert) {
@@ -2192,8 +2194,8 @@ QUnit.test('source & track', function(assert) {
                 '<source src="foobar.wav">' +
                 '<track kind="captions" src="sampleCaptions.vtt" srclang="en">' +
               '</audio>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { removeOptionalTags: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { removeOptionalTags: true });
 });
 
 QUnit.test('mixed html and svg', function(assert) {
@@ -2218,18 +2220,18 @@ QUnit.test('mixed html and svg', function(assert) {
     '</svg>' +
     '</body></html>';
   // Should preserve case-sensitivity and closing slashes within svg tags
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 });
 
 QUnit.test('nested quotes', function(assert) {
   var input, output;
 
   input = '<div data=\'{"test":"\\"test\\""}\'></div>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { quoteCharacter: '\'' }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { quoteCharacter: '\'' });
 
   output = '<div data="{&#34;test&#34;:&#34;\\&#34;test\\&#34;&#34;}"></div>';
-  test_minify_sync(assert, input, { quoteCharacter: '"' }, output);
+  test_minify(assert, input, output, { quoteCharacter: '"' });
 });
 
 QUnit.test('script minification', function(assert) {
@@ -2237,32 +2239,32 @@ QUnit.test('script minification', function(assert) {
 
   input = '<script></script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()';
 
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script>(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script>alert("1 2")</script>';
 
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/JavaScript">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="text/JavaScript">alert("1 2")</script>';
 
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="application/javascript;version=1.8">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;version=1.8">alert("1 2")</script>';
 
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type=" application/javascript  ; charset=utf-8 ">(function(){ var foo = 1; var bar = 2; alert(foo + " " + bar); })()</script>';
   output = '<script type="application/javascript;charset=utf-8">alert("1 2")</script>';
 
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({\'gtm.start\':new Date().getTime(),event:\'gtm.js\'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!=\'dataLayer\'?\'&l=\'+l:\'\';j.async=true;j.src=\'//www.googletagmanager.com/gtm.js?id=\'+i+dl;f.parentNode.insertBefore(j,f);})(window,document,\'script\',\'dataLayer\',\'GTM-67NT\');</script>';
   output = '<script>!function(w,d,s,l,i){w[l]=w[l]||[],w[l].push({"gtm.start":(new Date).getTime(),event:"gtm.js"});var f=d.getElementsByTagName(s)[0],j=d.createElement(s);j.async=!0,j.src="//www.googletagmanager.com/gtm.js?id=GTM-67NT",f.parentNode.insertBefore(j,f)}(window,document,"script","dataLayer")</script>';
 
-  test_minify_sync(assert, input, { minifyJS: { mangle: false } }, output);
+  test_minify(assert, input, output, { minifyJS: { mangle: false } });
 
   input = '<script>\n' +
           '  <!--\n' +
@@ -2275,7 +2277,7 @@ QUnit.test('script minification', function(assert) {
           '</script>';
   output = '<script>Platform.Mobile.Bootstrap.init(function(){Platform.Mobile.Core.Navigation.go("Login",{error:""})})</script>';
 
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 });
 
 QUnit.test('minification of scripts with different mimetypes', function(assert) {
@@ -2283,268 +2285,268 @@ QUnit.test('minification of scripts with different mimetypes', function(assert)
 
   input = '<script type="">function f(){  return 1  }</script>';
   output = '<script type="">function f(){return 1}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/javascript">function f(){  return 1  }</script>';
   output = '<script type="text/javascript">function f(){return 1}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script foo="bar">function f(){  return 1  }</script>';
   output = '<script foo="bar">function f(){return 1}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="text/ecmascript">function f(){  return 1  }</script>';
   output = '<script type="text/ecmascript">function f(){return 1}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="application/javascript">function f(){  return 1  }</script>';
   output = '<script type="application/javascript">function f(){return 1}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<script type="boo">function f(){  return 1  }</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<script type="text/html"><!-- ko if: true -->\n\n\n<div></div>\n\n\n<!-- /ko --></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
 });
 
 QUnit.test('minification of scripts with custom fragments', function(assert) {
   var input, output;
 
   input = '<script><?php ?></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, { minifyJS: true });
+  test_minify(assert, input, input, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, input);
+  });
 
   input = '<script>\n<?php ?></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
   output = '<script> <?php ?></script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, input);
+  });
 
   input = '<script><?php ?>\n</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
   output = '<script><?php ?> </script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, input);
+  });
 
   input = '<script>\n<?php ?>\n</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
   output = '<script> <?php ?> </script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, input);
+  });
 
   input = '<script>// <% ... %></script>';
   output = '<script></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyJS: true });
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<script>// \n<% ... %></script>';
   output = '<script> \n<% ... %></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
   output = '<script> <% ... %></script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
   output = '<script>\n<% ... %></script>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<script>// <% ... %>\n</script>';
   output = '<script></script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyJS: true });
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<script>// \n<% ... %>\n</script>';
   output = '<script> \n<% ... %>\n</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
   output = '<script> <% ... %> </script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
   output = '<script>\n<% ... %>\n</script>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyJS: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<script>function f(){  return <?php ?>  }</script>';
   output = '<script>function f(){return <?php ?>  }</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
   output = '<script>function f(){return <?php ?> }</script>';
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
 
   input = '<script>function f(){  return "<?php ?>"  }</script>';
   output = '<script>function f(){return"<?php ?>"}</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
-  test_minify_sync(assert, input, { collapseWhitespace: true, minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
+  test_minify(assert, input, output, { collapseWhitespace: true, minifyJS: true });
 });
 
 QUnit.test('event minification', function(assert) {
   var input, output;
 
   input = '<div only="alert(a + b)" one=";return false;"></div>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<div onclick="alert(a + b)"></div>';
   output = '<div onclick="alert(a+b)"></div>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<a href="/" onclick="this.href = getUpdatedURL (this.href);return true;">test</a>';
   output = '<a href="/" onclick="return this.href=getUpdatedURL(this.href),!0">test</a>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick=\'try{dcsMultiTrack("DCS.dcsuri","USPS","WT.ti")}catch(e){}\'> foobar</a>';
-  test_minify_sync(assert, input, { minifyJS: { mangle: false } }, output);
-  test_minify_sync(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '\'' }, output);
+  test_minify(assert, input, output, { minifyJS: { mangle: false } });
+  test_minify(assert, input, output, { minifyJS: { mangle: false }, quoteCharacter: '\'' });
 
   input = '<a onclick="try{ dcsMultiTrack(\'DCS.dcsuri\',\'USPS\',\'WT.ti\') }catch(e){}"> foobar</a>';
   output = '<a onclick="try{dcsMultiTrack(&#34;DCS.dcsuri&#34;,&#34;USPS&#34;,&#34;WT.ti&#34;)}catch(e){}"> foobar</a>';
-  test_minify_sync(assert, input, { minifyJS: { mangle: false }, quoteCharacter: '"' }, output);
+  test_minify(assert, input, output, { minifyJS: { mangle: false }, quoteCharacter: '"' });
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick=\'_gaq.push(["_trackEvent","FGF","banner_click"])\'></a>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
-  test_minify_sync(assert, input, { minifyJS: true, quoteCharacter: '\'' }, output);
+  test_minify(assert, input, output, { minifyJS: true });
+  test_minify(assert, input, output, { minifyJS: true, quoteCharacter: '\'' });
 
   input = '<a onClick="_gaq.push([\'_trackEvent\', \'FGF\', \'banner_click\']);"></a>';
   output = '<a onclick="_gaq.push([&#34;_trackEvent&#34;,&#34;FGF&#34;,&#34;banner_click&#34;])"></a>';
-  test_minify_sync(assert, input, { minifyJS: true, quoteCharacter: '"' }, output);
+  test_minify(assert, input, output, { minifyJS: true, quoteCharacter: '"' });
 
   input = '<button type="button" onclick=";return false;" id="appbar-guide-button"></button>';
   output = '<button type="button" onclick="return!1" id="appbar-guide-button"></button>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<button type="button" onclick=";return false;" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
   output = '<button type="button" onclick="return!1" ng-click="a(1 + 2)" data-click="a(1 + 2)"></button>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
-  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [] }, input);
+  test_minify(assert, input, output, { minifyJS: true });
+  test_minify(assert, input, input, { minifyJS: true, customEventAttributes: [] });
   output = '<button type="button" onclick=";return false;" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [/^ng-/] }, output);
+  test_minify(assert, input, output, { minifyJS: true, customEventAttributes: [/^ng-/] });
   output = '<button type="button" onclick="return!1" ng-click="a(3)" data-click="a(1 + 2)"></button>';
-  test_minify_sync(assert, input, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] }, output);
+  test_minify(assert, input, output, { minifyJS: true, customEventAttributes: [/^on/, /^ng-/] });
 
   input = '<div onclick="<?= b ?>"></div>';
-  test_minify_sync(assert, input, { minifyJS: true }, input);
+  test_minify(assert, input, input, { minifyJS: true });
 
   input = '<div onclick="alert(a + <?= b ?>)"></div>';
   output = '<div onclick="alert(a+ <?= b ?>)"></div>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 
   input = '<div onclick="alert(a + \'<?= b ?>\')"></div>';
   output = '<div onclick=\'alert(a+"<?= b ?>")\'></div>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 });
 
 QUnit.test('escaping closing script tag', function(assert) {
   var input = '<script>window.jQuery || document.write(\'<script src="jquery.js"><\\/script>\')</script>';
   var output = '<script>window.jQuery||document.write(\'<script src="jquery.js"><\\/script>\')</script>';
-  test_minify_sync(assert, input, { minifyJS: true }, output);
+  test_minify(assert, input, output, { minifyJS: true });
 });
 
 QUnit.test('style minification', function(assert) {
   var input, output;
 
   input = '<style></style>div#foo { background-color: red; color: white }';
-  test_minify_sync(assert, input, { minifyCSS: true }, input);
+  test_minify(assert, input, input, { minifyCSS: true });
 
   input = '<style>div#foo { background-color: red; color: white }</style>';
   output = '<style>div#foo{background-color:red;color:#fff}</style>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, input);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<style>div > p.foo + span { border: 10px solid black }</style>';
   output = '<style>div>p.foo+span{border:10px solid #000}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 
   input = '<div style="background: url(images/<% image %>);"></div>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyCSS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyCSS: true
-  }, output);
+  });
 
   input = '<div style="background: url(\'images/<% image %>\')"></div>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<div style="background:url(images/<% image %>)"></div>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyCSS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyCSS: true
-  }, output);
+  });
 
   input = '<style>\np {\n  background: url(images/<% image %>);\n}\n</style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyCSS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyCSS: true
-  }, output);
+  });
 
   input = '<style>p { background: url("images/<% image %>") }</style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style>p{background:url(images/<% image %>)}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { minifyCSS: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     minifyCSS: true
-  }, output);
+  });
 
   input = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width: 737px)">';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<link rel="stylesheet" href="css/style-mobile.css" media="(max-width:737px)">';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
   output = '<link rel=stylesheet href=css/style-mobile.css media=(max-width:737px)>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     removeAttributeQuotes: true
-  }, output);
+  });
 
   input = '<style media="(max-width: 737px)"></style>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
   output = '<style media="(max-width:737px)"></style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
   output = '<style media=(max-width:737px)></style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     removeAttributeQuotes: true
-  }, output);
+  });
 });
 
 QUnit.test('style attribute minification', function(assert) {
   var input = '<div style="color: red; background-color: yellow; font-family: Verdana, Arial, sans-serif;"></div>';
   var output = '<div style="color:red;background-color:#ff0;font-family:Verdana,Arial,sans-serif"></div>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
 });
 
 QUnit.test('url attribute minification', function(assert) {
@@ -2552,61 +2554,61 @@ QUnit.test('url attribute minification', function(assert) {
 
   input = '<link rel="stylesheet" href="http://website.com/style.css"><form action="http://website.com/folder/folder2/index.html"><a href="http://website.com/folder/file.html">link</a></form>';
   output = '<link rel="stylesheet" href="/style.css"><form action="folder2/"><a href="file.html">link</a></form>';
-  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/folder/' }, output);
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/folder/' } }, output);
+  test_minify(assert, input, output, { minifyURLs: 'http://website.com/folder/' });
+  test_minify(assert, input, output, { minifyURLs: { site: 'http://website.com/folder/' } });
 
   input = '<link rel="canonical" href="http://website.com/">';
-  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/' }, input);
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify(assert, input, input, { minifyURLs: 'http://website.com/' });
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/' } });
 
   input = '<style>body { background: url(\'http://website.com/bg.png\') }</style>';
-  test_minify_sync(assert, input, { minifyURLs: 'http://website.com/' }, input);
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
+  test_minify(assert, input, input, { minifyURLs: 'http://website.com/' });
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/' } });
   output = '<style>body{background:url(http://website.com/bg.png)}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: 'http://website.com/'
-  }, output);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
-  }, output);
+  });
 
   input = '<style>body { background: url("http://website.com/foo bar/bg.png") }</style>';
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo bar/' } }, input);
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/foo bar/' } });
   output = '<style>body{background:url("http://website.com/foo bar/bg.png")}</style>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo bar/' }
-  }, output);
+  });
 
   input = '<style>body { background: url("http://website.com/foo bar/(baz)/bg.png") }</style>';
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/' } }, input);
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } }, input);
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } }, input);
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/' } });
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/foo%20bar/' } });
+  test_minify(assert, input, input, { minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' } });
   output = '<style>body{background:url("foo%20bar/(baz)/bg.png")}</style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/' }
-  }, output);
+  });
   output = '<style>body{background:url("(baz)/bg.png")}</style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/' }
-  }, output);
+  });
   output = '<style>body{background:url(bg.png)}</style>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     minifyCSS: true,
     minifyURLs: { site: 'http://website.com/foo%20bar/(baz)/' }
-  }, output);
+  });
 
   input = '<img src="http://cdn.site.com/foo.png">';
   output = '<img src="//cdn.site.com/foo.png">';
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
+  test_minify(assert, input, output, { minifyURLs: { site: 'http://site.com/' } });
 });
 
 QUnit.test('srcset attribute minification', function(assert) {
@@ -2614,20 +2616,20 @@ QUnit.test('srcset attribute minification', function(assert) {
   input = '<source srcset="http://site.com/foo.gif ,http://site.com/bar.jpg 1x, baz moo 42w,' +
           '\n\n\n\n\n\t    http://site.com/zo om.png 1.00x">';
   output = '<source srcset="http://site.com/foo.gif, http://site.com/bar.jpg, baz moo 42w, http://site.com/zo om.png">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
   output = '<source srcset="foo.gif, bar.jpg, baz%20moo 42w, zo%20om.png">';
-  test_minify_sync(assert, input, { minifyURLs: { site: 'http://site.com/' } }, output);
+  test_minify(assert, input, output, { minifyURLs: { site: 'http://site.com/' } });
 });
 
 QUnit.test('valueless attributes', function(assert) {
   var input = '<br foo>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 });
 
 QUnit.test('newlines becoming whitespaces', function(assert) {
   var input = 'test\n\n<input>\n\ntest';
   var output = 'test <input> test';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 });
 
 QUnit.test('conservative collapse', function(assert) {
@@ -2635,115 +2637,115 @@ QUnit.test('conservative collapse', function(assert) {
 
   input = '<b>   foo \n\n</b>';
   output = '<b> foo </b>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<html>\n\n<!--test-->\n\n</html>';
   output = '<html> </html>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, { collapseWhitespace: true });
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, input);
+  });
 
   input = '<p> \u00A0</p>';
   output = '<p>\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>\u00A0 </p>';
   output = '<p>\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p> \u00A0 </p>';
   output = '<p>\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>\u00A0\u00A0 \u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  </p>';
   output = '<p>foo \u00A0\u00A0 \u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>\u00A0\u00A0 \u00A0 bar</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p>foo  \u00A0\u00A0  \u00A0  bar</p>';
   output = '<p>foo \u00A0\u00A0 \u00A0 bar</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p> \u00A0foo\u00A0\t</p>';
   output = '<p>\u00A0foo\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
 
   input = '<p> \u00A0\nfoo\u00A0\t</p>';
   output = '<p>\u00A0 foo\u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
 
   input = '<p> \u00A0foo \u00A0\t</p>';
   output = '<p>\u00A0foo \u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 
   input = '<p> \u00A0\nfoo \u00A0\t</p>';
   output = '<p>\u00A0 foo \u00A0</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, { collapseWhitespace: true });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true
-  }, output);
+  });
 });
 
 QUnit.test('collapse preseving a line break', function(assert) {
@@ -2773,15 +2775,15 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }, output);
+  });
   output = '\n<!DOCTYPE html>\n<html lang="en" class="no-js">\n' +
            '<head>\n<meta charset="utf-8">\n<meta http-equiv="X-UA-Compatible" content="IE=edge">\n' +
            '<title>Carbon</title>\n<meta name="title" content="Carbon">\n' +
@@ -2793,140 +2795,140 @@ QUnit.test('collapse preseving a line break', function(assert) {
            '<script src="scripts/application.js"></script>\n' +
            '<link href="images/icn-32x32.png" rel="shortcut icon">\n' +
            '<link href="images/icn-152x152.png" rel="apple-touch-icon">\n</head>\n<body><p>\ntest test test\n</p></body>\n</html>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true,
     removeComments: true
-  }, output);
+  });
 
   input = '<div> text <span>\n text</span> \n</div>';
   output = '<div>text <span>\ntext</span>\n</div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<div>  text \n </div>';
   output = '<div>text\n</div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
   output = '<div> text\n</div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = '<div>\ntext  </div>';
   output = '<div>\ntext</div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
   output = '<div>\ntext </div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true
-  }, output);
+  });
 
   input = 'This is the start. <% ... %>\r\n<%= ... %>\r\n<? ... ?>\r\n<!-- This is the middle, and a comment. -->\r\nNo comment, but middle.\r\n<?= ... ?>\r\n<?php ... ?>\r\n<?xml ... ?>\r\nHello, this is the end!';
   output = 'This is the start. <% ... %>\n<%= ... %>\n<? ... ?>\nNo comment, but middle.\n<?= ... ?>\n<?php ... ?>\n<?xml ... ?>\nHello, this is the end!';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeComments: true,
     collapseWhitespace: true,
     preserveLineBreaks: true
-  }, output);
+  });
 });
 
 QUnit.test('collapse inline tag whitespace', function(assert) {
   var input, output;
 
   input = '<button>a</button> <button>b</button>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true
-  }, input);
+  });
 
   output = '<button>a</button><button>b</button>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
-  }, output);
+  });
 
   input = '<p>where <math> <mi>R</mi> </math> is the Rici tensor.</p>';
   output = '<p>where <math><mi>R</mi></math> is the Rici tensor.</p>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true
-  }, output);
+  });
 
   output = '<p>where<math><mi>R</mi></math>is the Rici tensor.</p>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     collapseInlineTagWhitespace: true
-  }, output);
+  });
 });
 
 QUnit.test('ignore custom comments', function(assert) {
   var input, output;
 
   input = '<!--! test -->';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { removeComments: true }, input);
-  test_minify_sync(assert, input, { ignoreCustomComments: false }, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { removeComments: true });
+  test_minify(assert, input, input, { ignoreCustomComments: false });
+  test_minify(assert, input, '', {
     removeComments: true,
     ignoreCustomComments: []
-  }, '');
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, '', {
     removeComments: true,
     ignoreCustomComments: false
-  }, '');
+  });
 
   input = '<!-- htmlmin:ignore -->test<!-- htmlmin:ignore -->';
   output = 'test';
-  test_minify_sync(assert, input, output);
-  test_minify_sync(assert, input, { removeComments: true }, output);
-  test_minify_sync(assert, input, { ignoreCustomComments: false }, output);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output);
+  test_minify(assert, input, output, { removeComments: true });
+  test_minify(assert, input, output, { ignoreCustomComments: false });
+  test_minify(assert, input, output, {
     removeComments: true,
     ignoreCustomComments: []
-  }, output);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, output, {
     removeComments: true,
     ignoreCustomComments: false
-  }, output);
+  });
 
   input = '<!-- ko if: someExpressionGoesHere --><li>test</li><!-- /ko -->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     removeComments: true,
     // ignore knockout comments
     ignoreCustomComments: [
       /^\s+ko/,
       /\/ko\s+$/
     ]
-  }, input);
+  });
 
   input = '<!--#include virtual="/cgi-bin/counter.pl" -->';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     removeComments: true,
     // ignore Apache SSI includes
     ignoreCustomComments: [
       /^\s*#/
     ]
-  }, input);
+  });
 });
 
 QUnit.test('processScripts', function(assert) {
   var input = '<script type="text/ng-template"><!--test--><div>   <span> foobar </span> \n\n</div></script>';
   var output = '<script type="text/ng-template"><div><span>foobar</span></div></script>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     removeComments: true,
     processScripts: ['text/ng-template']
-  }, output);
+  });
 });
 
 QUnit.test('ignore', function(assert) {
@@ -2936,10 +2938,10 @@ QUnit.test('ignore', function(assert) {
           '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>';
   output = '<div class="blah" style="color: red">\n   test   <span> <input disabled/>  foo </span>\n\n   </div>' +
            '<div class="blah" style="color: red">test <span><input disabled="disabled"> foo</span></div>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<!-- htmlmin:ignore --><!-- htmlmin:ignore -->';
-  test_minify_sync(assert, input, '');
+  test_minify(assert, input, '');
 
   input = '<p>.....</p><!-- htmlmin:ignore -->' +
           '@for( $i = 0 ; $i < $criterions->count() ; $i++ )' +
@@ -2951,23 +2953,23 @@ QUnit.test('ignore', function(assert) {
                '<h1>{{ $criterions[$i]->value }}</h1>' +
            '@endfor' +
            '<p>....</p>';
-  test_minify_sync(assert, input, { removeComments: true }, output);
+  test_minify(assert, input, output, { removeComments: true });
 
   input = '<!-- htmlmin:ignore --> <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> <!-- htmlmin:ignore -->';
   output = ' <p class="logged"|cond="$is_logged === true" id="foo"> bar</p> ';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<!-- htmlmin:ignore --><body <?php body_class(); ?>><!-- htmlmin:ignore -->';
   output = '<body <?php body_class(); ?>>';
-  test_minify_sync(assert, input, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] }, output);
+  test_minify(assert, input, output, { ignoreCustomFragments: [/<\?php[\s\S]*?\?>/] });
 
   input = 'a\n<!-- htmlmin:ignore -->b<!-- htmlmin:ignore -->';
   output = 'a b';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 
   input = '<p>foo <!-- htmlmin:ignore --><span>\n\tbar\n</span><!-- htmlmin:ignore -->.</p>';
   output = '<p>foo <span>\n\tbar\n</span>.</p>';
-  test_minify_sync(assert, input, { collapseWhitespace: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: true });
 });
 
 QUnit.test('meta viewport', function(assert) {
@@ -2975,37 +2977,36 @@ QUnit.test('meta viewport', function(assert) {
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="initial-scale=1, maximum-scale=1.0">';
   output = '<meta name="viewport" content="initial-scale=1,maximum-scale=1">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="width= 500 ,  initial-scale=1">';
   output = '<meta name="viewport" content="width=500,initial-scale=1">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 
   input = '<meta name="viewport" content="width=device-width, initial-scale=1.0001, maximum-scale=3.140000">';
   output = '<meta name="viewport" content="width=device-width,initial-scale=1.0001,maximum-scale=3.14">';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('downlevel-revealed conditional comments', function(assert) {
   var input = '<![if !IE]><link href="non-ie.css" rel="stylesheet"><![endif]>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { removeComments: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { removeComments: true });
 });
 
 QUnit.test('noscript', function(assert) {
   var input;
 
   input = '<SCRIPT SRC="x"></SCRIPT><NOSCRIPT>x</NOSCRIPT>';
-  test_minify_sync(assert, input, '<script src="x"></script><noscript>x</noscript>');
+  test_minify(assert, input, '<script src="x"></script><noscript>x</noscript>');
 
   input = '<noscript>\n<!-- anchor linking to external file -->\n' +
           '<a href="#" onclick="javascript:">External Link</a>\n</noscript>';
-  test_minify_sync(assert, input, { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true },
-    '<noscript><a href="#">External Link</a></noscript>');
+  test_minify(assert, input, '<noscript><a href="#">External Link</a></noscript>', { removeComments: true, collapseWhitespace: true, removeEmptyAttributes: true });
 });
 
 QUnit.test('max line length', function(assert) {
@@ -3013,57 +3014,51 @@ QUnit.test('max line length', function(assert) {
   var options = { maxLineLength: 25 };
 
   input = '123456789012345678901234567890';
-  test_minify_sync(assert, input, options, input);
+  test_minify(assert, input, input, options);
 
   input = '<div data-attr="foo"></div>';
-  test_minify_sync(assert, input, options, '<div data-attr="foo">\n</div>');
+  test_minify(assert, input, '<div data-attr="foo">\n</div>', options);
 
   input = '<code>    hello   world  \n    world   hello  </code>';
-  test_minify_sync(assert, input, options, '<code>\n    hello   world  \n    world   hello  \n</code>');
+  test_minify(assert, input, '<code>\n    hello   world  \n    world   hello  \n</code>', options);
 
-  test_minify_sync(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
-  test_minify_sync(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
-  test_minify_sync(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
-  test_minify_sync(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
-  test_minify_sync(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
+  test_minify(assert, '<p title="</p>">x</p>', '<p title="</p>">x</p>');
+  test_minify(assert, '<p title=" <!-- hello world --> ">x</p>', '<p title=" <!-- hello world --> ">x</p>');
+  test_minify(assert, '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>', '<p title=" <![CDATA[ \n\n foobar baz ]]> ">x</p>');
+  test_minify(assert, '<p foo-bar=baz>xxx</p>', '<p foo-bar="baz">xxx</p>');
+  test_minify(assert, '<p foo:bar=baz>xxx</p>', '<p foo:bar="baz">xxx</p>');
 
   input = '<div><div><div><div><div><div><div><div><div><div>' +
             'i\'m 10 levels deep' +
           '</div></div></div></div></div></div></div></div></div></div>';
-  test_minify_sync(assert, input, input);
+  test_minify(assert, input, input);
 
-  test_minify_sync(assert, '<script>alert(\'<!--\')</script>', options, '<script>alert(\'<!--\')\n</script>');
+  test_minify(assert, '<script>alert(\'<!--\')</script>', '<script>alert(\'<!--\')\n</script>', options);
   input = '<script>\nalert(\'<!-- foo -->\')\n</script>';
-  test_minify_sync(assert, '<script>alert(\'<!-- foo -->\')</script>', options, input);
-  test_minify_sync(assert, input, options, input);
-  test_minify_sync(assert, '<script>alert(\'-->\')</script>', options, '<script>alert(\'-->\')\n</script>');
-
-  test_minify_sync(assert, '<a title="x"href=" ">foo</a>', options, '<a title="x" href="">foo\n</a>');
-  test_minify_sync(assert, '<p id=""class=""title="">x', options, '<p id="" class="" \ntitle="">x</p>');
-  test_minify_sync(assert, '<p x="x\'"">x</p>', options, '<p x="x\'">x</p>', 'trailing quote should be ignored');
-  test_minify_sync(assert, '<a href="#"><p>Click me</p></a>', options, '<a href="#"><p>Click me\n</p></a>');
+  test_minify(assert, '<script>alert(\'<!-- foo -->\')</script>', input, options);
+  test_minify(assert, input, input, options);
+  test_minify(assert, '<script>alert(\'-->\')</script>', '<script>alert(\'-->\')\n</script>', options);
+
+  test_minify(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo\n</a>', options);
+  test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" \ntitle="">x</p>', options);
+  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', options, 'trailing quote should be ignored');
+  test_minify(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me\n</p></a>', options);
   input = '<span><button>Hit me\n</button></span>';
-  test_minify_sync(assert, '<span><button>Hit me</button></span>', options, input);
-  test_minify_sync(assert, input, options, input);
-  test_minify_sync(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', options,
-    '<object \ntype="image/svg+xml" \ndata="image.svg"><div>\n[fallback image]</div>\n</object>'
-  );
+  test_minify(assert, '<span><button>Hit me</button></span>', input, options);
+  test_minify(assert, input, input, options);
+  test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', '<object \ntype="image/svg+xml" \ndata="image.svg"><div>\n[fallback image]</div>\n</object>', options);
 
-  test_minify_sync(assert, '<ng-include src="x"></ng-include>', options, '<ng-include src="x">\n</ng-include>');
-  test_minify_sync(assert, '<ng:include src="x"></ng:include>', options, '<ng:include src="x">\n</ng:include>');
-  test_minify_sync(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', options,
-    '<ng-include \nsrc="\'views/partial-notification.html\'">\n</ng-include><div \nng-view=""></div>'
-  );
-  test_minify_sync(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', options,
-    '<some-tag-1>\n</some-tag-1>\n<some-tag-2>\n</some-tag-2>'
-  );
-  test_minify_sync(assert, '[\']["]', options, '[\']["]');
-  test_minify_sync(assert, '<a href="test.html"><div>hey</div></a>', options, '<a href="test.html">\n<div>hey</div></a>');
-  test_minify_sync(assert, ':) <a href="http://example.com">link</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
-  test_minify_sync(assert, ':) <a href="http://example.com">\nlink</a>', options, ':) <a \nhref="http://example.com">\nlink</a>');
-  test_minify_sync(assert, ':) <a href="http://example.com">\n\nlink</a>', options, ':) <a \nhref="http://example.com">\n\nlink</a>');
+  test_minify(assert, '<ng-include src="x"></ng-include>', '<ng-include src="x">\n</ng-include>', options);
+  test_minify(assert, '<ng:include src="x"></ng:include>', '<ng:include src="x">\n</ng:include>', options);
+  test_minify(assert, '<ng-include src="\'views/partial-notification.html\'"></ng-include><div ng-view=""></div>', '<ng-include \nsrc="\'views/partial-notification.html\'">\n</ng-include><div \nng-view=""></div>', options);
+  test_minify(assert, '<some-tag-1></some-tag-1><some-tag-2></some-tag-2>', '<some-tag-1>\n</some-tag-1>\n<some-tag-2>\n</some-tag-2>', options);
+  test_minify(assert, '[\']["]', '[\']["]', options);
+  test_minify(assert, '<a href="test.html"><div>hey</div></a>', '<a href="test.html">\n<div>hey</div></a>', options);
+  test_minify(assert, ':) <a href="http://example.com">link</a>', ':) <a \nhref="http://example.com">\nlink</a>', options);
+  test_minify(assert, ':) <a href="http://example.com">\nlink</a>', ':) <a \nhref="http://example.com">\nlink</a>', options);
+  test_minify(assert, ':) <a href="http://example.com">\n\nlink</a>', ':) <a \nhref="http://example.com">\n\nlink</a>', options);
 
-  test_minify_sync(assert, '<a href>ok</a>', options, '<a href>ok</a>');
+  test_minify(assert, '<a href>ok</a>', '<a href>ok</a>', options);
 });
 
 QUnit.test('custom attribute collapse', function(assert) {
@@ -3080,15 +3075,15 @@ QUnit.test('custom attribute collapse', function(assert) {
           '">foo</div>';
   output = '<div data-bind="css: {fadeIn: selected(),fadeOut: !selected()},visible: function () {return pageWeAreOn() == \'home\';}">foo</div>';
 
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { customAttrCollapse: /data-bind/ }, output);
+  test_minify(assert, input, input);
+  test_minify(assert, input, output, { customAttrCollapse: /data-bind/ });
 
   input = '<div style="' +
             'color: red;' +
             'font-size: 100em;' +
           '">bar</div>';
   output = '<div style="color: red;font-size: 100em;">bar</div>';
-  test_minify_sync(assert, input, { customAttrCollapse: /style/ }, output);
+  test_minify(assert, input, output, { customAttrCollapse: /style/ });
 
   input = '<div ' +
     'class="fragment square" ' +
@@ -3100,13 +3095,13 @@ QUnit.test('custom attribute collapse', function(assert) {
   '> ' +
   '</div>';
   output = '<div class="fragment square" ng-hide="square1.hide" ng-class="{\'bounceInDown\': !square1.hide, \'bounceOutDown\': square1.hide }"> </div>';
-  test_minify_sync(assert, input, { customAttrCollapse: /ng-class/ }, output);
+  test_minify(assert, input, output, { customAttrCollapse: /ng-class/ });
 });
 
 QUnit.test('custom attribute collapse with empty attribute value', function(assert) {
   var input = '<div ng-some\n\n></div>';
   var output = '<div ng-some></div>';
-  test_minify_sync(assert, input, { customAttrCollapse: /.+/ }, output);
+  test_minify(assert, input, output, { customAttrCollapse: /.+/ });
 });
 
 QUnit.test('custom attribute collapse with newlines, whitespace, and carriage returns', function(assert) {
@@ -3115,7 +3110,7 @@ QUnit.test('custom attribute collapse with newlines, whitespace, and carriage re
           '               value2:false \n\r' +
           '               }"></div>';
   var output = '<div ng-class="{value:true,value2:false}"></div>';
-  test_minify_sync(assert, input, { customAttrCollapse: /ng-class/ }, output);
+  test_minify(assert, input, output, { customAttrCollapse: /ng-class/ });
 });
 
 QUnit.test('do not escape attribute value', function(assert) {
@@ -3124,23 +3119,23 @@ QUnit.test('do not escape attribute value', function(assert) {
   input = '<div data=\'{\n' +
           '\t"element": "<div class=\\"test\\"></div>\n"' +
           '}\'></div>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { preventAttributesEscaping: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { preventAttributesEscaping: true });
 
   input = '<div foo bar=\'\' baz="" moo=1 loo=\'2\' haa="3"></div>';
-  test_minify_sync(assert, input, { preventAttributesEscaping: true }, input);
+  test_minify(assert, input, input, { preventAttributesEscaping: true });
   output = '<div foo bar="" baz="" moo="1" loo="2" haa="3"></div>';
-  test_minify_sync(assert, input, output);
+  test_minify(assert, input, output);
 });
 
 QUnit.test('quoteCharacter is single quote', function(assert) {
-  test_minify_sync(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
-  test_minify_sync(assert, '<div class="bar">foo</div>', { quoteCharacter: '\'' }, '<div class=\'bar\'>foo</div>');
+  test_minify(assert, '<div class=\'bar\'>foo</div>', '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' });
+  test_minify(assert, '<div class="bar">foo</div>', '<div class=\'bar\'>foo</div>', { quoteCharacter: '\'' });
 });
 
 QUnit.test('quoteCharacter is not single quote or double quote', function(assert) {
-  test_minify_sync(assert, '<div class=\'bar\'>foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
-  test_minify_sync(assert, '<div class="bar">foo</div>', { quoteCharacter: 'm' }, '<div class="bar">foo</div>');
+  test_minify(assert, '<div class=\'bar\'>foo</div>', '<div class="bar">foo</div>', { quoteCharacter: 'm' });
+  test_minify(assert, '<div class="bar">foo</div>', '<div class="bar">foo</div>', { quoteCharacter: 'm' });
 });
 
 QUnit.test('remove space between attributes', function(assert) {
@@ -3154,27 +3149,27 @@ QUnit.test('remove space between attributes', function(assert) {
 
   input = '<input data-attr="example" value="hello world!" checked="checked">';
   output = '<input data-attr=example value="hello world!"checked>';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 
   input = '<input checked="checked" value="hello world!" data-attr="example">';
   output = '<input checked value="hello world!"data-attr=example>';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 
   input = '<input checked="checked" data-attr="example" value="hello world!">';
   output = '<input checked data-attr=example value="hello world!">';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 
   input = '<input data-attr="example" value="hello world!" checked="checked"/>';
   output = '<input data-attr=example value="hello world!"checked/>';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 
   input = '<input checked="checked" value="hello world!" data-attr="example"/>';
   output = '<input checked value="hello world!"data-attr=example />';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 
   input = '<input checked="checked" data-attr="example" value="hello world!"/>';
   output = '<input checked data-attr=example value="hello world!"/>';
-  test_minify_sync(assert, input, options, output);
+  test_minify(assert, input, output, options);
 });
 
 QUnit.test('markups from Angular 2', function(assert) {
@@ -3200,7 +3195,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '  </div>\n' +
            '  <button type="submit" [disabled]="!theForm.form.valid">Submit</button>\n' +
            '</form>';
-  test_minify_sync(assert, input, { caseSensitive: true }, output);
+  test_minify(assert, input, output, { caseSensitive: true });
   output = '<template ngFor #hero [ngForOf]=heroes>' +
            '<hero-detail *ngIf=hero [hero]=hero></hero-detail>' +
            '</template>' +
@@ -3211,7 +3206,7 @@ QUnit.test('markups from Angular 2', function(assert) {
            '</div>' +
            '<button type=submit [disabled]=!theForm.form.valid>Submit</button>' +
            '</form>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseWhitespace: true,
@@ -3224,58 +3219,58 @@ QUnit.test('markups from Angular 2', function(assert) {
     removeStyleLinkTypeAttributes: true,
     removeTagWhitespace: true,
     useShortDoctype: true
-  }, output);
+  });
 });
 
 QUnit.test('auto-generated tags', function(assert) {
   var input, output;
 
   input = '</p>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify(assert, input, input, { includeAutoGeneratedTags: false });
 
   input = '<p id=""class=""title="">x';
   output = '<p id="" class="" title="">x';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, output);
+  test_minify(assert, input, output, { includeAutoGeneratedTags: false });
   output = '<p id="" class="" title="">x</p>';
-  test_minify_sync(assert, input, output);
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify(assert, input, output);
+  test_minify(assert, input, output, { includeAutoGeneratedTags: true });
 
   input = '<body onload="  foo();   bar() ;  "><p>x</body>';
   output = '<body onload="foo();   bar() ;"><p>x</body>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, output);
+  test_minify(assert, input, output, { includeAutoGeneratedTags: false });
 
   input = '<a href="#"><div>Well, look at me! I\'m a div!</div></a>';
   output = '<a href="#"><div>Well, look at me! I\'m a div!</div>';
-  test_minify_sync(assert, input, { html5: false, includeAutoGeneratedTags: false }, output);
-  test_minify_sync(assert, '<p id=""class=""title="">x', {
+  test_minify(assert, input, output, { html5: false, includeAutoGeneratedTags: false });
+  test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" \ntitle="">x', {
     maxLineLength: 25,
     includeAutoGeneratedTags: false
-  }, '<p id="" class="" \ntitle="">x');
+  });
 
   input = '<p>foo';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, { includeAutoGeneratedTags: false });
+  test_minify(assert, input, input, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
-  }, input);
+  });
 
   input = '</p>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify(assert, input, input, { includeAutoGeneratedTags: false });
   output = '';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     includeAutoGeneratedTags: false,
     removeOptionalTags: true
-  }, output);
+  });
 
   input = '<select><option>foo<option>bar</select>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify(assert, input, input, { includeAutoGeneratedTags: false });
   output = '<select><option>foo</option><option>bar</option></select>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify(assert, input, output, { includeAutoGeneratedTags: true });
 
   input = '<datalist><option label="A" value="1"><option label="B" value="2"></datalist>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: false }, input);
+  test_minify(assert, input, input, { includeAutoGeneratedTags: false });
   output = '<datalist><option label="A" value="1"></option><option label="B" value="2"></option></datalist>';
-  test_minify_sync(assert, input, { includeAutoGeneratedTags: true }, output);
+  test_minify(assert, input, output, { includeAutoGeneratedTags: true });
 });
 
 QUnit.test('sort attributes', function(assert) {
@@ -3284,31 +3279,31 @@ QUnit.test('sort attributes', function(assert) {
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<link type="text/css" href="app.css" rel="stylesheet" async>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { sortAttributes: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { sortAttributes: false });
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<link href="app.css" rel="stylesheet" async type="text/css">';
-  test_minify_sync(assert, input, { sortAttributes: true }, output);
+  test_minify(assert, input, output, { sortAttributes: true });
 
   input = '<link href="foo">' +
           '<link rel="bar" href="baz">' +
           '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { sortAttributes: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { sortAttributes: false });
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link type="text/css" href="app.css" rel="stylesheet" async></script>';
-  test_minify_sync(assert, input, { sortAttributes: true }, output);
+  test_minify(assert, input, output, { sortAttributes: true });
   output = '<link href="foo">' +
            '<link href="baz" rel="bar">' +
            '<script type="text/html"><link href="app.css" rel="stylesheet" async type="text/css"></script>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     processScripts: [
       'text/html'
     ],
     sortAttributes: true
-  }, output);
+  });
 
   input = '<link type="text/css" href="foo.css">' +
           '<link rel="stylesheet" type="text/abc" href="bar.css">' +
@@ -3316,45 +3311,45 @@ QUnit.test('sort attributes', function(assert) {
   output = '<link href="foo.css" type="text/css">' +
            '<link href="bar.css" type="text/abc" rel="stylesheet">' +
            '<link href="baz.css">';
-  test_minify_sync(assert, input, { sortAttributes: true }, output);
+  test_minify(assert, input, output, { sortAttributes: true });
   output = '<link href="foo.css">' +
            '<link href="bar.css" rel="stylesheet" type="text/abc">' +
            '<link href="baz.css">';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     removeStyleLinkTypeAttributes: true,
     sortAttributes: true
-  }, output);
+  });
 
   input = '<a foo moo></a>' +
           '<a bar foo></a>' +
           '<a baz bar foo></a>' +
           '<a baz foo moo></a>' +
           '<a moo baz></a>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { sortAttributes: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { sortAttributes: false });
   output = '<a foo moo></a>' +
            '<a foo bar></a>' +
            '<a foo bar baz></a>' +
            '<a foo baz moo></a>' +
            '<a baz moo></a>';
-  test_minify_sync(assert, input, { sortAttributes: true }, output);
+  test_minify(assert, input, output, { sortAttributes: true });
 
   input = '<span nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
-  }, input);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: false
-  }, input);
+  });
   output = '<span foo_bar nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> ></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortAttributes: true
-  }, output);
+  });
 
   input = '<a 0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z></a>';
-  test_minify_sync(assert, input, { sortAttributes: true }, input);
+  test_minify(assert, input, input, { sortAttributes: true });
 });
 
 QUnit.test('sort style classes', function(assert) {
@@ -3365,125 +3360,125 @@ QUnit.test('sort style classes', function(assert) {
           '<i class="baz bar foo"></i>' +
           '<s class="baz foo moo"></s>' +
           '<u class="moo baz"></u>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { sortClassName: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { sortClassName: false });
   output = '<a class="foo moo"></a>' +
            '<b class="foo bar"></b>' +
            '<i class="foo bar baz"></i>' +
            '<s class="foo baz moo"></s>' +
            '<u class="baz moo"></u>';
-  test_minify_sync(assert, input, { sortClassName: true }, output);
+  test_minify(assert, input, output, { sortClassName: true });
 
   input = '<a class="moo <!-- htmlmin:ignore -->bar<!-- htmlmin:ignore --> foo baz"></a>';
   output = '<a class="moo bar foo baz"></a>';
-  test_minify_sync(assert, input, output);
-  test_minify_sync(assert, input, { sortClassName: false }, output);
+  test_minify(assert, input, output);
+  test_minify(assert, input, output, { sortClassName: false });
   output = '<a class="baz foo moo bar"></a>';
-  test_minify_sync(assert, input, { sortClassName: true }, output);
+  test_minify(assert, input, output, { sortClassName: true });
 
   input = '<div class="nav_sv_fo_v_column <#=(j === 0) ? \'nav_sv_fo_v_first\' : \'\' #> foo_bar"></div>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/]
-  }, input);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: false
-  }, input);
-  test_minify_sync(assert, input, {
+  });
+  test_minify(assert, input, input, {
     ignoreCustomFragments: [/<#[\s\S]*?#>/],
     sortClassName: true
-  }, input);
+  });
 
   input = '<a class="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z"></a>';
-  test_minify_sync(assert, input, { sortClassName: false }, input);
-  test_minify_sync(assert, input, { sortClassName: true }, input);
+  test_minify(assert, input, input, { sortClassName: false });
+  test_minify(assert, input, input, { sortClassName: true });
 
   input = '<a class="add sort keys createSorter"></a>';
-  test_minify_sync(assert, input, { sortClassName: false }, input);
+  test_minify(assert, input, input, { sortClassName: false });
   output = '<a class="add createSorter keys sort"></a>';
-  test_minify_sync(assert, input, { sortClassName: true }, output);
+  test_minify(assert, input, output, { sortClassName: true });
 
   input = '<span class="sprite sprite-{{sprite}}"></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }, input);
+  });
 
   input = '<span class="{{sprite}}-sprite sprite"></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }, input);
+  });
 
   input = '<span class="sprite-{{sprite}}-sprite"></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }, input);
+  });
 
   input = '<span class="{{sprite}}"></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, input, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }, input);
+  });
 
   input = '<span class={{sprite}}></span>';
   output = '<span class="{{sprite}}"></span>';
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     ignoreCustomFragments: [/{{.*?}}/],
     removeAttributeQuotes: true,
     sortClassName: true
-  }, output);
+  });
 });
 
 QUnit.test('decode entity characters', function(assert) {
   var input, output;
 
   input = '<!-- &ne; -->';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { decodeEntities: false }, input);
-  test_minify_sync(assert, input, { decodeEntities: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { decodeEntities: false });
+  test_minify(assert, input, input, { decodeEntities: true });
 
   input = '<script type="text/html">&colon;</script>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { decodeEntities: false }, input);
-  test_minify_sync(assert, input, { decodeEntities: true }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { decodeEntities: false });
+  test_minify(assert, input, input, { decodeEntities: true });
   output = '<script type="text/html">:</script>';
-  test_minify_sync(assert, input, { decodeEntities: true, processScripts: ['text/html'] }, output);
+  test_minify(assert, input, output, { decodeEntities: true, processScripts: ['text/html'] });
 
   input = '<div style="font: &quot;monospace&#34;">foo&dollar;</div>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { decodeEntities: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { decodeEntities: false });
   output = '<div style=\'font: "monospace"\'>foo$</div>';
-  test_minify_sync(assert, input, { decodeEntities: true }, output);
+  test_minify(assert, input, output, { decodeEntities: true });
   output = '<div style="font:&quot">foo&dollar;</div>';
-  test_minify_sync(assert, input, { minifyCSS: true }, output);
-  test_minify_sync(assert, input, { decodeEntities: false, minifyCSS: true }, output);
+  test_minify(assert, input, output, { minifyCSS: true });
+  test_minify(assert, input, output, { decodeEntities: false, minifyCSS: true });
   output = '<div style="font:monospace">foo$</div>';
-  test_minify_sync(assert, input, { decodeEntities: true, minifyCSS: true }, output);
+  test_minify(assert, input, output, { decodeEntities: true, minifyCSS: true });
 
   input = '<a href="/?foo=1&amp;bar=&lt;2&gt;">baz&lt;moo&gt;&copy;</a>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { decodeEntities: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { decodeEntities: false });
   output = '<a href="/?foo=1&bar=<2>">baz&lt;moo>\u00a9</a>';
-  test_minify_sync(assert, input, { decodeEntities: true }, output);
+  test_minify(assert, input, output, { decodeEntities: true });
 
   input = '<? &amp; ?>&amp;<pre><? &amp; ?>&amp;</pre>';
-  test_minify_sync(assert, input, input);
-  test_minify_sync(assert, input, { collapseWhitespace: false, decodeEntities: false }, input);
-  test_minify_sync(assert, input, { collapseWhitespace: true, decodeEntities: false }, input);
+  test_minify(assert, input, input);
+  test_minify(assert, input, input, { collapseWhitespace: false, decodeEntities: false });
+  test_minify(assert, input, input, { collapseWhitespace: true, decodeEntities: false });
   output = '<? &amp; ?>&<pre><? &amp; ?>&</pre>';
-  test_minify_sync(assert, input, { collapseWhitespace: false, decodeEntities: true }, output);
-  test_minify_sync(assert, input, { collapseWhitespace: true, decodeEntities: true }, output);
+  test_minify(assert, input, output, { collapseWhitespace: false, decodeEntities: true });
+  test_minify(assert, input, output, { collapseWhitespace: true, decodeEntities: true });
 });
 
 QUnit.test('tests from PHPTAL', function(assert) {
@@ -3565,7 +3560,7 @@ QUnit.test('tests from PHPTAL', function(assert) {
       'foo</body> </html>  <!-- bla -->'
     ]*/
   ].forEach(function(tokens) {
-    test_minify_sync(assert, tokens[1], {
+    test_minify(assert, tokens[1], tokens[0], {
       collapseBooleanAttributes: true,
       collapseWhitespace: true,
       removeAttributeQuotes: true,
@@ -3578,7 +3573,7 @@ QUnit.test('tests from PHPTAL', function(assert) {
       removeTagWhitespace: true,
       sortAttributes: true,
       useShortDoctype: true
-    }, tokens[0]);
+    });
   });
 });
 
@@ -3593,33 +3588,33 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   var input = '<div class="leaveAlone"><span> </span> foo  bar</div>';
   var output = '<div class="leaveAlone"><span> </span> foo  bar</div>';
 
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }, output);
+  });
 
   // Regression test: Previously the first </div> would clear the internal
   // stackNo{Collapse,Trim}Whitespace, so that ' foo  bar' turned into ' foo bar'
   input = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
   output = '<div class="leaveAlone"><div></div><span> </span> foo  bar</div>';
 
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }, output);
+  });
 
   // Make sure that the stack does get reset when leaving the element for which
   // the hooks returned false:
   input = '<div class="leaveAlone"></div><div> foo  bar </div>';
   output = '<div class="leaveAlone"></div><div>foo bar</div>';
 
-  test_minify_sync(assert, input, {
+  test_minify(assert, input, output, {
     collapseWhitespace: true,
     canTrimWhitespace: canCollapseAndTrimWhitespace,
     canCollapseWhitespace: canCollapseAndTrimWhitespace
-  }, output);
+  });
 });
 
 QUnit.test('Async execution', function(assert) {
@@ -3652,26 +3647,26 @@ QUnit.test('Async execution', function(assert) {
   var styleOutput = '<style>Normal CSS</style>';
   var scriptOutput = '<script>Normal JS</script>';
 
-  test_minify_async(assert, input, {}, input);
+  test_minify(assert, input, input, {}, null, true);
 
   output = styleOutput + scriptInput;
-  test_minify_async(assert, input, { minifyCSS: cssAsync }, output);
-  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: false }, output);
+  test_minify(assert, input, output, { minifyCSS: cssAsync }, null, true);
+  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: false }, null, true);
 
   output = styleInput + scriptOutput;
-  test_minify_async(assert, input, { minifyJS: jsAsync }, output);
-  test_minify_async(assert, input, { minifyCSS: false, minifyJS: jsAsync }, output);
+  test_minify(assert, input, output, { minifyJS: jsAsync }, null, true);
+  test_minify(assert, input, output, { minifyCSS: false, minifyJS: jsAsync }, null, true);
 
   output = styleOutput + scriptOutput;
-  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: jsAsync }, output);
-  test_minify_async(assert, input, { minifyCSS: cssAsync, minifyJS: jsSync }, output);
-  test_minify_async(assert, input, { minifyCSS: cssSync, minifyJS: jsAsync }, output);
+  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: jsAsync }, null, true);
+  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: jsSync }, null, true);
+  test_minify(assert, input, output, { minifyCSS: cssSync, minifyJS: jsAsync }, null, true);
 });
 
 QUnit.test('minify error with callback', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style><$unicorn>';
 
-  test_minify_async_error(assert, input, 'Invalid tag name');
+  test_minify_error(assert, input, null, null, 'Invalid tag name', true);
 });
 
 QUnit.test('error in callback', function(assert) {
@@ -3682,7 +3677,7 @@ QUnit.test('error in callback', function(assert) {
     throw error;
   }
 
-  test_minify_async_error(assert, input, { minifyCSS: css }, error);
+  test_minify_error(assert, input, { minifyCSS: css }, error, null, true);
 });
 
 QUnit.test('callback called multiple times', function(assert) {

From 1a1edc548afb1de6207ed9796f368854a77ed5a2 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Tue, 24 Apr 2018 22:15:40 +1200
Subject: [PATCH 53/66] Refactored.

---
 tests/minifier.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index dcdad2d2..5de14c41 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -1,6 +1,15 @@
 /* global minify */
 'use strict';
 
+QUnit.config.autostart = false;
+if (typeof minify === 'undefined') {
+  self.minify = require('html-minifier').minify;
+}
+
+QUnit.test('`minifiy` exists', function(assert) {
+  assert.ok(minify);
+});
+
 /**
  * Converts the options in the given object to use callbacks where possible.
  *
@@ -140,7 +149,7 @@ function test_minify(assert, input, output, inputOptions, description, asyncOnly
  *
  * @param {Assert} assert
  * @param {string} input
- * @param {Object} [options]
+ * @param {Object} [inputOptions]
  * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
  * @param {string} [description=input]
  * @param {boolean} [asyncOnly=false]
@@ -223,15 +232,6 @@ function test_minify_error(assert, input, inputOptions, errorMatcher, descriptio
   });
 }
 
-QUnit.config.autostart = false;
-if (typeof minify === 'undefined') {
-  self.minify = require('html-minifier').minify;
-}
-
-QUnit.test('`minifiy` exists', function(assert) {
-  assert.ok(minify);
-});
-
 QUnit.test('parsing non-trivial markup', function(assert) {
   var input, output;
 

From 61e5cd9b65f342dc776c83fbdba942a54f9f62cd Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Tue, 24 Apr 2018 22:27:54 +1200
Subject: [PATCH 54/66] Added safety checks and fix bad test.

---
 tests/minifier.js | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 5de14c41..38bece6e 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -89,6 +89,23 @@ function test_minify(assert, input, output, inputOptions, description, asyncOnly
     asyncOnly = false;
   }
 
+  // Safety Checks - ensure this function was called with the correct var types.
+  if (typeof input !== 'string') {
+    throw new Error('Bad input: ' + input);
+  }
+  if (typeof output !== 'string') {
+    throw new Error('Bad output: ' + output);
+  }
+  if (inputOptions !== null && typeof inputOptions !== 'undefined' && typeof inputOptions !== 'object') {
+    throw new Error('Bad inputOptions: ' + inputOptions);
+  }
+  if (typeof description !== 'string') {
+    throw new Error('Bad description: ' + description);
+  }
+  if (typeof asyncOnly !== 'boolean') {
+    throw new Error('Bad asyncOnly: ' + asyncOnly);
+  }
+
   // Standard test.
   if (!asyncOnly) {
     var descriptionPrefix = 'Standard Test: ';
@@ -258,7 +275,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
 
   test_minify(assert, '<a title="x"href=" ">foo</a>', '<a title="x" href="">foo</a>');
   test_minify(assert, '<p id=""class=""title="">x', '<p id="" class="" title="">x</p>');
-  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', 'trailing quote should be ignored');
+  test_minify(assert, '<p x="x\'"">x</p>', '<p x="x\'">x</p>', null, 'trailing quote should be ignored');
   test_minify(assert, '<a href="#"><p>Click me</p></a>', '<a href="#"><p>Click me</p></a>');
   test_minify(assert, '<span><button>Hit me</button></span>', '<span><button>Hit me</button></span>');
   test_minify(assert, '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>', '<object type="image/svg+xml" data="image.svg"><div>[fallback image]</div></object>');

From 7ef92b4d85058f589688268a7bddb0030a422890 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Tue, 24 Apr 2018 23:04:45 +1200
Subject: [PATCH 55/66] Switch out assert.throws with test_minify_error

---
 tests/minifier.js | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 38bece6e..016e488b 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -296,9 +296,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   test_minify(assert, input, input);
 
   input = '<$unicorn>';
-  assert.throws(function() {
-    minify(input);
-  }, 'Invalid tag name');
+  test_minify_error(assert, input, null, null, 'Invalid tag name');
 
   input = '<begriffs.pagination ng-init="perPage=20" collection="logs" url="\'/api/logs?user=-1\'" per-page="perPage" per-page-presets="[10,20,50,100]" template-url="/assets/paginate-anything.html"></begriffs.pagination>';
   test_minify(assert, input, input);
@@ -326,9 +324,7 @@ QUnit.test('parsing non-trivial markup', function(assert) {
   // https://github.com/kangax/html-minifier/issues/507
   input = '<tag v-ref:vm_pv :imgs=" objpicsurl_ "></tag>';
   test_minify(assert, input, input);
-  assert.throws(function() {
-    minify('<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>');
-  }, 'invalid attribute name');
+  test_minify_error(assert, '<tag v-ref:vm_pv :imgs=" objpicsurl_ " ss"123></tag>', null, null, 'invalid attribute name');
 
   // https://github.com/kangax/html-minifier/issues/512
   input = '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
@@ -339,18 +335,14 @@ QUnit.test('parsing non-trivial markup', function(assert) {
           ' data-ng-pattern="vm.options.format"' +
           ' data-options="vm.datepickerOptions">';
   test_minify(assert, input, input);
-  assert.throws(function() {
-    minify(
-      '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
+  test_minify_error(assert, '<input class="form-control" type="text" style="" id="{{vm.formInputName}}" name="{{vm.formInputName}}"' +
       ' <!--FIXME hardcoded placeholder - dates may not be used for service required fields yet. -->' +
       ' placeholder="YYYY-MM-DD"' +
       ' date-range-picker' +
       ' data-ng-model="vm.value"' +
       ' data-ng-model-options="{ debounce: 1000 }"' +
       ' data-ng-pattern="vm.options.format"' +
-      ' data-options="vm.datepickerOptions">'
-    );
-  }, 'HTML comment inside tag');
+      ' data-options="vm.datepickerOptions">', null, null, 'HTML comment inside tag');
 
   input = '<br a=\u00A0 b="&nbsp;" c="\u00A0">';
   output = '<br a="\u00A0" b="&nbsp;" c="\u00A0">';

From b17b970a5269042f8e7f80542d52bb3cc32ad45c Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 12:55:09 +1200
Subject: [PATCH 56/66] Removed async only option from test_minify.

---
 tests/minifier.js | 205 ++++++++++++++++++++--------------------------
 1 file changed, 89 insertions(+), 116 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index 016e488b..c7fd6b36 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -76,19 +76,13 @@ function convertOptionsCallbacks(options, async) {
  * @param {string} output
  * @param {Object} [inputOptions]
  * @param {string} [description=input]
- * @param {boolean} [asyncOnly=false]
  */
-function test_minify(assert, input, output, inputOptions, description, asyncOnly) {
+function test_minify(assert, input, output, inputOptions, description) {
   // Set default description.
   if (description === null || typeof description === 'undefined') {
     description = input;
   }
 
-  // Set default asyncOnly.
-  if (asyncOnly === null || typeof asyncOnly === 'undefined') {
-    asyncOnly = false;
-  }
-
   // Safety Checks - ensure this function was called with the correct var types.
   if (typeof input !== 'string') {
     throw new Error('Bad input: ' + input);
@@ -102,43 +96,35 @@ function test_minify(assert, input, output, inputOptions, description, asyncOnly
   if (typeof description !== 'string') {
     throw new Error('Bad description: ' + description);
   }
-  if (typeof asyncOnly !== 'boolean') {
-    throw new Error('Bad asyncOnly: ' + asyncOnly);
-  }
 
   // Standard test.
-  if (!asyncOnly) {
-    var descriptionPrefix = 'Standard Test: ';
-    assert.equal(minify(input, inputOptions), output, descriptionPrefix + description);
-  }
+  assert.equal(minify(input, inputOptions), output, 'Standard Test: ' + description);
 
   // Callback tests.
-  var callbackTests = [];
-
-  if (!asyncOnly) {
+  var callbackTests = [
     // Sync callback test.
-    callbackTests.push({
+    {
       options: convertOptionsCallbacks(inputOptions, false),
       async: false,
       done: assert.async(),
       descriptionPrefix: 'Synchronous Callback Test: '
-    });
-  }
+    },
+    // Async callback test.
+    {
+      options: convertOptionsCallbacks(inputOptions, true),
+      async: true,
+      done: assert.async(),
+      descriptionPrefix: 'Asynchronous Callback Test: '
+    }
+  ];
 
-  // Async callback test.
-  callbackTests.push({
-    options: asyncOnly ? inputOptions : convertOptionsCallbacks(inputOptions, true),
-    async: true,
-    done: assert.async(),
-    descriptionPrefix: 'Asynchronous Callback Test: '
-  });
+  // Callbacks should take very long to complete.
+  assert.timeout(100);
 
   // Run callback tests.
-  assert.timeout(100);
   callbackTests.forEach(function(test) {
-    var callbackTestFinished = false;
     assert.notOk(minify(input, test.options, function(error, result) {
-      if (!callbackTestFinished) {
+      if (!test.finished) {
         var stackTrace = '';
         if (error && error instanceof Error) {
           stackTrace = error.stack;
@@ -147,15 +133,15 @@ function test_minify(assert, input, output, inputOptions, description, asyncOnly
         assert.equal(error, null, test.descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
         assert.equal(result, output, test.descriptionPrefix + description);
 
-        callbackTestFinished = true;
+        test.finished = true;
         test.done();
       }
     }));
 
-    // If callback test didn't finish synchronously.
-    if (!callbackTestFinished && !test.async) {
+    // If callback test didn't finish synchronously when it should have.
+    if (!(test.finished || test.async)) {
       assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
-      callbackTestFinished = true;
+      test.finished = true;
       test.done();
     }
   });
@@ -169,76 +155,69 @@ function test_minify(assert, input, output, inputOptions, description, asyncOnly
  * @param {Object} [inputOptions]
  * @param {Error|function(new:Error)|RegExp|function(boolean)} [errorMatcher]
  * @param {string} [description=input]
- * @param {boolean} [asyncOnly=false]
  */
-function test_minify_error(assert, input, inputOptions, errorMatcher, description, asyncOnly) {
+function test_minify_error(assert, input, inputOptions, errorMatcher, description) {
   // Set default description.
   if (description === null || typeof description === 'undefined') {
     description = input;
   }
 
-  // Set default asyncOnly.
-  if (asyncOnly === null || typeof asyncOnly === 'undefined') {
-    asyncOnly = false;
-  }
-
   // Standard test.
-  var descriptionPrefix = 'Standard Test: ';
   assert.throws(
     function() {
       minify(input, inputOptions);
     },
     errorMatcher,
-    descriptionPrefix + description
+    'Standard Test: ' + description
   );
 
   // Callback tests.
-  var callbackTests = [];
-
-  if (!asyncOnly) {
+  var callbackTests = [
     // Sync callback test.
-    callbackTests.push({
+    {
       options: convertOptionsCallbacks(inputOptions, false),
       async: false,
       done: assert.async(),
       descriptionPrefix: 'Synchronous Callback Test: '
-    });
-  }
+    },
+    // Async callback test.
+    {
+      options: convertOptionsCallbacks(inputOptions, true),
+      async: true,
+      done: assert.async(),
+      descriptionPrefix: 'Asynchronous Callback Test: '
+    }
+  ];
 
-  // Async callback test.
-  callbackTests.push({
-    options: asyncOnly ? inputOptions : convertOptionsCallbacks(inputOptions, true),
-    async: true,
-    done: assert.async(),
-    descriptionPrefix: 'Asynchronous Callback Test: '
-  });
+  // Callbacks should take very long to complete.
+  assert.timeout(100);
 
   // Run callback tests.
   callbackTests.forEach(function(test) {
-    var callbackTestFinished = false;
     try {
-      assert.timeout(100);
       assert.notOk(minify(input, test.options, function(error, result) {
-        if (!callbackTestFinished) {
-          assert.ok(error, descriptionPrefix + 'An error should have occurred.');
-          assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
-          assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
+        if (!test.finished) {
+          assert.ok(error, test.descriptionPrefix + 'An error should have occurred.');
+          assert.ok(error instanceof Error, test.descriptionPrefix + '"' + error + '" was returned as an error.');
+          assert.throws(function() { throw error; }, errorMatcher, test.descriptionPrefix + description);
           assert.notOk(result);
 
-          callbackTestFinished = true;
+          test.finished = true;
           test.done();
         }
       }));
 
-      // If callback test didn't finish synchronously.
-      if (!callbackTestFinished && !test.async) {
+      // If callback test didn't finish synchronously when it should have.
+      if (!(test.finished || test.async)) {
         assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
-        callbackTestFinished = true;
+        test.finished = true;
         test.done();
       }
     }
     catch (error) {
-      callbackTestFinished = true;
+      test.finished = true;
+
+      // An error shouldn't be thrown - fail the test.
       if (error && error instanceof Error) {
         assert.ok(false, test.descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
       }
@@ -3626,67 +3605,61 @@ QUnit.test('canCollapseWhitespace and canTrimWhitespace hooks', function(assert)
   });
 });
 
-QUnit.test('Async execution', function(assert) {
-  var input, output;
-
-  function cssSync(text, type) {
-    return (type || 'Normal') + ' CSS';
-  }
+QUnit.test('minify error with callback', function(assert) {
+  var input = '<style>div#foo { background-color: red; }</style><$unicorn>';
 
-  function jsSync(text, inline) {
-    return inline ? 'Inline JS' : 'Normal JS';
-  }
+  var done = assert.async();
+  assert.timeout(100);
 
-  function cssAsync(text, type, cb) {
-    setTimeout(function() {
-      cb(cssSync(text, type));
-    }, 1);
+  try {
+    assert.notOk(minify(input, null, function(error, result) {
+      assert.ok(error, 'An error should have occurred.');
+      assert.ok(error instanceof Error, '"' + error + '" was returned as an error.');
+      assert.throws(function() { throw error; }, null, 'An error should have been thrown');
+      assert.notOk(result);
+      done();
+    }));
   }
-
-  function jsAsync(text, inline, cb) {
-    setTimeout(function() {
-      cb(jsSync(text, inline));
-    }, 1);
+  catch (error) {
+    // An error shouldn't be thrown - fail the test.
+    if (error && error instanceof Error) {
+      assert.ok(false, test.descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
+    }
+    else {
+      assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
+    }
   }
-
-  var styleInput = '<style>div#foo { background-color: red; color: white }</style>';
-  var scriptInput = '<script>(function(  ){  console.log("Hello" + " World"); })()</script>';
-  input = styleInput + scriptInput;
-
-  var styleOutput = '<style>Normal CSS</style>';
-  var scriptOutput = '<script>Normal JS</script>';
-
-  test_minify(assert, input, input, {}, null, true);
-
-  output = styleOutput + scriptInput;
-  test_minify(assert, input, output, { minifyCSS: cssAsync }, null, true);
-  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: false }, null, true);
-
-  output = styleInput + scriptOutput;
-  test_minify(assert, input, output, { minifyJS: jsAsync }, null, true);
-  test_minify(assert, input, output, { minifyCSS: false, minifyJS: jsAsync }, null, true);
-
-  output = styleOutput + scriptOutput;
-  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: jsAsync }, null, true);
-  test_minify(assert, input, output, { minifyCSS: cssAsync, minifyJS: jsSync }, null, true);
-  test_minify(assert, input, output, { minifyCSS: cssSync, minifyJS: jsAsync }, null, true);
-});
-
-QUnit.test('minify error with callback', function(assert) {
-  var input = '<style>div#foo { background-color: red; }</style><$unicorn>';
-
-  test_minify_error(assert, input, null, null, 'Invalid tag name', true);
 });
 
 QUnit.test('error in callback', function(assert) {
   var input = '<style>div#foo { background-color: red; }</style>';
-  var error = new Error();
+  var cssError = new Error();
 
   function css() {
-    throw error;
+    throw cssError;
   }
 
-  test_minify_error(assert, input, { minifyCSS: css }, error, null, true);
+  var done = assert.async();
+  assert.timeout(100);
+
+  try {
+    assert.notOk(minify(input, { minifyCSS: css }, function(error, result) {
+      assert.ok(error, 'An error should have occurred.');
+      assert.ok(error instanceof Error, '"' + error + '" was returned as an error.');
+      assert.throws(function() { throw error; }, cssError, cssError + ' should have been thrown');
+      assert.notOk(result);
+      done();
+    }));
+  }
+  catch (error) {
+    // An error shouldn't be thrown - fail the test.
+    if (error && error instanceof Error) {
+      assert.ok(false, test.descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
+    }
+    else {
+      assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
+    }
+  }
 });
 
 QUnit.test('callback called multiple times', function(assert) {

From fcd3c59bbe6e4c0bcfcdeaf26c625b381877936b Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 13:17:40 +1200
Subject: [PATCH 57/66] Refactored Task and TaskGroup.

---
 src/htmlminifier.js | 122 ++++++++++++++++++++++++--------------------
 1 file changed, 68 insertions(+), 54 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 42ab0ae0..ecd0c97b 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -842,46 +842,15 @@ function createSortFns(value, options, uidIgnore, uidAttr, cb) {
 }
 
 /**
- * Minify HTML.
+ * A task that may finish either synchronously or asynchronously.
  *
- * @param {string} value
- * @param {Object} options
- * @param {boolean} partialMarkup
- * @param {Callback} cb
+ * The task will not be executed until explicitly told to.
+ *
+ * @class
  */
-function minify(value, options, partialMarkup, cb) {
-  if (options.collapseWhitespace) {
-    value = collapseWhitespace(value, options, true, true);
-  }
-
-  var buffer = [],
-      charsPrevTag,
-      currentChars = '',
-      hasChars,
-      currentTag = '',
-      currentAttrs = [],
-      stackNoTrimWhitespace = [],
-      stackNoCollapseWhitespace = [],
-      optionalStartTag = '',
-      optionalEndTag = '',
-      ignoredMarkupChunks = [],
-      ignoredCustomMarkupChunks = [],
-      uidIgnore,
-      uidAttr,
-      uidPattern;
-
+var Task = (function() {
   /**
-   * Set of tasks to perform.
-   *
-   * @type {Array<Task|TaskGroup>}
-   */
-  var tasks = [];
-
-  /**
-   * A task.
-   *
    * @constructor
-   *
    * @param {function(Callback)} task
    */
   function Task(task) {
@@ -897,12 +866,23 @@ function minify(value, options, partialMarkup, cb) {
     this.task(cb);
   };
 
+  return Task;
+})();
+
+
+/**
+ * A group of Tasks and or other TaskGroups to execute in series.
+ *
+ * The tasks will not be executed until explicitly told to.
+ * Additional tasks can be added to the group by pushing to the `tasks` array
+ * property. Do not modify this property once execution was begun.
+ *
+ * @class
+ */
+var TaskGroup = (function() {
   /**
-   * A group of Tasks to execute in series.
-   *
    * @constructor
-   *
-   * @param {Task[]} [tasks]
+   * @param {Array<Task|TaskGroup>} [tasks]
    */
   function TaskGroup(tasks) {
     this.tasks = tasks ? tasks : [];
@@ -923,20 +903,16 @@ function minify(value, options, partialMarkup, cb) {
     (function implementation(index) {
       if (index < this.tasks.length) {
         try {
-          this.tasks[index].exec(
-            function(error) {
-              if (error) {
-                throw error;
-              }
-
-              if (this.tasks[index].cbExecuted) {
-                throw new Error('Async completion has already occurred.');
-              }
-              this.tasks[index].cbExecuted = true;
-
-              implementation.call(this, index + 1);
-            }.bind(this)
-          );
+          this.tasks[index].exec(function(error) {
+            if (error) {
+              throw error;
+            }
+            if (this.tasks[index].cbExecuted) {
+              throw new Error('Async completion has already occurred.');
+            }
+            this.tasks[index].cbExecuted = true;
+            implementation.call(this, index + 1);
+          }.bind(this));
         }
         catch (error) {
           cb(error);
@@ -947,6 +923,44 @@ function minify(value, options, partialMarkup, cb) {
       }
     }.bind(this))(0);
   };
+  return TaskGroup;
+})();
+
+/**
+ * Minify HTML.
+ *
+ * @param {string} value
+ * @param {Object} options
+ * @param {boolean} partialMarkup
+ * @param {Callback} cb
+ */
+function minify(value, options, partialMarkup, cb) {
+  if (options.collapseWhitespace) {
+    value = collapseWhitespace(value, options, true, true);
+  }
+
+  var buffer = [],
+      charsPrevTag,
+      currentChars = '',
+      hasChars,
+      currentTag = '',
+      currentAttrs = [],
+      stackNoTrimWhitespace = [],
+      stackNoCollapseWhitespace = [],
+      optionalStartTag = '',
+      optionalEndTag = '',
+      ignoredMarkupChunks = [],
+      ignoredCustomMarkupChunks = [],
+      uidIgnore,
+      uidAttr,
+      uidPattern;
+
+  /**
+   * Set of tasks to perform.
+   *
+   * @type {Array<Task|TaskGroup>}
+   */
+  var tasks = [];
 
   // temporarily replace ignored chunks with comments,
   // so that we don't have to worry what's there.

From a2968a0409ab599285d9cfdc3d3699da6c42badd Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 13:31:20 +1200
Subject: [PATCH 58/66] Fix issue with not all callbacks being in the form of
 (error, result).

---
 src/htmlminifier.js | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index ecd0c97b..878e0539 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -265,9 +265,11 @@ function isSrcset(attrName, tag) {
 function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
   if (attrValue && isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
-    attrValue = options.minifyJS(attrValue, true, cb);
+    attrValue = options.minifyJS(attrValue, true, function(result) {
+      cb(null, result);
+    });
     if (typeof attrValue !== 'undefined') {
-      return cb(attrValue);
+      return cb(null, attrValue);
     }
     return;
   }
@@ -279,14 +281,14 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
     else {
       attrValue = collapseWhitespaceAll(attrValue);
     }
-    return cb(attrValue);
+    return cb(null, attrValue);
   }
   else if (isUriTypeAttribute(attrName, tag)) {
     attrValue = trimWhitespace(attrValue);
-    return cb(isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue));
+    return cb(null, isLinkType(tag, attrs, 'canonical') ? attrValue : options.minifyURLs(attrValue));
   }
   else if (isNumberTypeAttribute(attrName, tag)) {
-    return cb(trimWhitespace(attrValue));
+    return cb(null, trimWhitespace(attrValue));
   }
   else if (attrName === 'style') {
     attrValue = trimWhitespace(attrValue);
@@ -294,13 +296,15 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
       if (/;$/.test(attrValue) && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
         attrValue = attrValue.replace(/\s*;$/, ';');
       }
-      attrValue = options.minifyCSS(attrValue, 'inline', cb);
+      attrValue = options.minifyCSS(attrValue, 'inline', function(result) {
+        cb(null, result);
+      });
       if (typeof attrValue !== 'undefined') {
-        return cb(attrValue);
+        return cb(null, attrValue);
       }
       return;
     }
-    return cb(attrValue);
+    return cb(null, attrValue);
   }
   else if (isSrcset(attrName, tag)) {
     // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
@@ -335,13 +339,15 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, cb) {
   }
   else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
-    attrValue = options.minifyCSS(attrValue, 'media', cb);
+    attrValue = options.minifyCSS(attrValue, 'media', function(result) {
+      cb(null, result);
+    });
     if (typeof attrValue !== 'undefined') {
-      return cb(attrValue);
+      return cb(null, attrValue);
     }
     return;
   }
-  return cb(attrValue);
+  return cb(null, attrValue);
 }
 
 function isMetaViewport(tag, attrs) {
@@ -394,7 +400,7 @@ function processScript(text, options, currentAttrs, cb) {
       return minify(text, options, false, cb);
     }
   }
-  return cb(text);
+  return cb(null, text);
 }
 
 // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
@@ -561,7 +567,11 @@ function normalizeAttr(attr, attrs, tag, options, cb) {
     return cb();
   }
 
-  cleanAttributeValue(tag, attrName, attrValue, options, attrs, function(attrValue) {
+  cleanAttributeValue(tag, attrName, attrValue, options, attrs, function(error, attrValue) {
+    if (error) {
+      return cb(error);
+    }
+
     if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
       return cb();

From f9dee3c2d163207f01729b8098921933cb1dab46 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 14:57:16 +1200
Subject: [PATCH 59/66] Moved typedefs below imports.

---
 src/htmlminifier.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 878e0539..4fe544c0 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1,10 +1,5 @@
 'use strict';
 
-/**
- * A callback that tasks an error and a result.
- * @typedef {function([?Error], [string]):void} Callback
- */
-
 var CleanCSS = require('clean-css');
 var decode = require('he').decode;
 var HTMLParser = require('./htmlparser').HTMLParser;
@@ -13,6 +8,11 @@ var TokenChain = require('./tokenchain');
 var UglifyJS = require('uglify-js');
 var utils = require('./utils');
 
+/**
+ * A callback that takes an error and a result.
+ * @typedef {function([?Error], [string]):void} Callback
+ */
+
 function trimWhitespace(str) {
   if (typeof str !== 'string') {
     return str;

From 675d086505a81f41c9b929112277480e3ec01b2f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 16:32:16 +1200
Subject: [PATCH 60/66] Fixed 'Maximum call stack size exceeded' in the sync
 case.

---
 src/htmlminifier.js | 738 +++++++++++++++++++++++++-------------------
 1 file changed, 414 insertions(+), 324 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 4fe544c0..b0607635 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -646,10 +646,11 @@ function identity(value) {
   return value;
 }
 
-function processOptions(values) {
+function processOptions(values, ensureSynchronicity) {
   var options = {
     canCollapseWhitespace: canCollapseWhitespace,
     canTrimWhitespace: canTrimWhitespace,
+    ensureSynchronicity: ensureSynchronicity,
     html5: true,
     ignoreCustomComments: [/^!/],
     ignoreCustomFragments: [
@@ -861,7 +862,7 @@ function createSortFns(value, options, uidIgnore, uidAttr, cb) {
 var Task = (function() {
   /**
    * @constructor
-   * @param {function(Callback)} task
+   * @param {function([Callback])} task
    */
   function Task(task) {
     this.task = task;
@@ -870,9 +871,12 @@ var Task = (function() {
   /**
    * Execute this task.
    *
-   * @param {Callback} cb
+   * @param {Callback} [cb]
    */
   Task.prototype.exec = function(cb) {
+    if (!cb) {
+      cb = function() {};
+    }
     this.task(cb);
   };
 
@@ -945,6 +949,8 @@ var TaskGroup = (function() {
  * @param {Callback} cb
  */
 function minify(value, options, partialMarkup, cb) {
+  var topLevelCb = cb;
+
   if (options.collapseWhitespace) {
     value = collapseWhitespace(value, options, true, true);
   }
@@ -972,6 +978,13 @@ function minify(value, options, partialMarkup, cb) {
    */
   var tasks = [];
 
+  /**
+   * The next task to perform.
+   *
+   * @type {Task}
+   */
+  var nextTask;
+
   // temporarily replace ignored chunks with comments,
   // so that we don't have to worry what's there.
   // for all we care there might be
@@ -1027,9 +1040,15 @@ function minify(value, options, partialMarkup, cb) {
 
   if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||
       options.sortClassName && typeof options.sortClassName !== 'function') {
-    tasks.push(new Task(function(cb) {
+    nextTask = new Task(function(cb) {
       createSortFns(value, options, uidIgnore, uidAttr, cb);
-    }));
+    });
+    if (options.ensureSynchronicity) {
+      nextTask.exec();
+    }
+    else {
+      tasks.push(nextTask);
+    }
   }
 
   function _canCollapseWhitespace(tag, attrs) {
@@ -1084,7 +1103,7 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
-  tasks.push(new Task(function(cb) {
+  nextTask = new Task(function(cb) {
     try {
       var subtasks = [];
 
@@ -1093,395 +1112,462 @@ function minify(value, options, partialMarkup, cb) {
         html5: options.html5,
 
         start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-          subtasks.push(
-            new Task(function(cb) {
-              var lowerTag = tag.toLowerCase();
-
-              if (lowerTag === 'svg') {
-                options = Object.create(options);
-                options.keepClosingSlash = true;
-                options.caseSensitive = true;
-              }
+          nextTask = new Task(function(cb) {
+            var lowerTag = tag.toLowerCase();
 
-              tag = options.caseSensitive ? tag : lowerTag;
+            if (lowerTag === 'svg') {
+              options = Object.create(options);
+              options.keepClosingSlash = true;
+              options.caseSensitive = true;
+            }
 
-              currentTag = tag;
-              charsPrevTag = tag;
-              if (!inlineTextTags(tag)) {
-                currentChars = '';
-              }
-              hasChars = false;
-              currentAttrs = attrs;
+            tag = options.caseSensitive ? tag : lowerTag;
 
-              var optional = options.removeOptionalTags;
-              if (optional) {
-                var htmlTag = htmlTags(tag);
-                // <html> may be omitted if first thing inside is not comment
-                // <head> may be omitted if first thing inside is an element
-                // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-                // <colgroup> may be omitted if first thing inside is <col>
-                // <tbody> may be omitted if first thing inside is <tr>
-                if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
-                  removeStartTag();
-                }
-                optionalStartTag = '';
-                // end-tag-followed-by-start-tag omission rules
-                if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
-                  removeEndTag();
-                  // <colgroup> cannot be omitted if preceding </colgroup> is omitted
-                  // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
-                  optional = !isStartTagMandatory(optionalEndTag, tag);
-                }
-                optionalEndTag = '';
+            currentTag = tag;
+            charsPrevTag = tag;
+            if (!inlineTextTags(tag)) {
+              currentChars = '';
+            }
+            hasChars = false;
+            currentAttrs = attrs;
+
+            var optional = options.removeOptionalTags;
+            if (optional) {
+              var htmlTag = htmlTags(tag);
+              // <html> may be omitted if first thing inside is not comment
+              // <head> may be omitted if first thing inside is an element
+              // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+              // <colgroup> may be omitted if first thing inside is <col>
+              // <tbody> may be omitted if first thing inside is <tr>
+              if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
+                removeStartTag();
+              }
+              optionalStartTag = '';
+              // end-tag-followed-by-start-tag omission rules
+              if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
+                removeEndTag();
+                // <colgroup> cannot be omitted if preceding </colgroup> is omitted
+                // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
+                optional = !isStartTagMandatory(optionalEndTag, tag);
               }
+              optionalEndTag = '';
+            }
 
-              // set whitespace flags for nested tags (eg. <code> within a <pre>)
-              if (options.collapseWhitespace) {
-                if (!stackNoTrimWhitespace.length) {
-                  squashTrailingWhitespace(tag);
+            // set whitespace flags for nested tags (eg. <code> within a <pre>)
+            if (options.collapseWhitespace) {
+              if (!stackNoTrimWhitespace.length) {
+                squashTrailingWhitespace(tag);
+              }
+              if (!unary) {
+                if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
+                  stackNoTrimWhitespace.push(tag);
                 }
-                if (!unary) {
-                  if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
-                    stackNoTrimWhitespace.push(tag);
-                  }
-                  if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
-                    stackNoCollapseWhitespace.push(tag);
-                  }
+                if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
+                  stackNoCollapseWhitespace.push(tag);
                 }
               }
+            }
 
-              var openTag = '<' + tag;
-              var hasUnarySlash = unarySlash && options.keepClosingSlash;
+            var openTag = '<' + tag;
+            var hasUnarySlash = unarySlash && options.keepClosingSlash;
 
-              buffer.push(openTag);
+            buffer.push(openTag);
 
-              if (options.sortAttributes) {
-                options.sortAttributes(tag, attrs);
-              }
+            if (options.sortAttributes) {
+              options.sortAttributes(tag, attrs);
+            }
 
-              var parts = [];
-
-              // Loop through all the attributes and normalize them.
-              (function normalizeAttrLoop(i, isLast) {
-                // Attributes to normalize?
-                if (--i >= 0) {
-                  var innerLoopResult;
-                  // Normalize all the attributes in series.
-                  normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
-                    if (error) {
-                      return cb(error);
-                    }
+            var parts = [];
 
-                    if (normalized) {
-                      parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
-                      isLast = false;
-                    }
+            // Loop through all the attributes and normalize them.
+            (function normalizeAttrLoop(i, isLast) {
+              // Attributes to normalize?
+              if (--i >= 0) {
+                var innerLoopResult;
+                // Normalize all the attributes in series.
+                normalizeAttr(attrs[i], attrs, tag, options, function(error, normalized) {
+                  if (error) {
+                    return cb(error);
+                  }
 
-                    innerLoopResult = normalizeAttrLoop(i, isLast);
-                  });
-                  return innerLoopResult;
-                }
+                  if (normalized) {
+                    parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
+                    isLast = false;
+                  }
 
-                // All attributes are now normalize.
+                  innerLoopResult = normalizeAttrLoop(i, isLast);
+                });
+                return innerLoopResult;
+              }
 
-                if (parts.length > 0) {
-                  buffer.push(' ');
-                  buffer.push.apply(buffer, parts);
-                }
-                // start tag must never be omitted if it has any attributes
-                else if (optional && optionalStartTags(tag)) {
-                  optionalStartTag = tag;
-                }
+              // All attributes are now normalize.
 
-                buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
+              if (parts.length > 0) {
+                buffer.push(' ');
+                buffer.push.apply(buffer, parts);
+              }
+              // start tag must never be omitted if it has any attributes
+              else if (optional && optionalStartTags(tag)) {
+                optionalStartTag = tag;
+              }
 
-                if (autoGenerated && !options.includeAutoGeneratedTags) {
-                  removeStartTag();
-                  optionalStartTag = '';
-                }
+              buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
+
+              if (autoGenerated && !options.includeAutoGeneratedTags) {
+                removeStartTag();
+                optionalStartTag = '';
+              }
 
-                return cb();
-              })(attrs.length, true);
-            })
-          );
+              return cb();
+            })(attrs.length, true);
+          });
+          if (options.ensureSynchronicity) {
+            nextTask.exec();
+          }
+          else {
+            subtasks.push(nextTask);
+          }
         },
         end: function(tag, attrs, autoGenerated) {
-          subtasks.push(
-            new Task(function(cb) {
-              var lowerTag = tag.toLowerCase();
-              if (lowerTag === 'svg') {
-                options = Object.getPrototypeOf(options);
-              }
-              tag = options.caseSensitive ? tag : lowerTag;
+          nextTask = new Task(function(cb) {
+            var lowerTag = tag.toLowerCase();
+            if (lowerTag === 'svg') {
+              options = Object.getPrototypeOf(options);
+            }
+            tag = options.caseSensitive ? tag : lowerTag;
 
-              // check if current tag is in a whitespace stack
-              if (options.collapseWhitespace) {
-                if (stackNoTrimWhitespace.length) {
-                  if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
-                    stackNoTrimWhitespace.pop();
-                  }
-                }
-                else {
-                  squashTrailingWhitespace('/' + tag);
-                }
-                if (stackNoCollapseWhitespace.length &&
-                  tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
-                  stackNoCollapseWhitespace.pop();
+            // check if current tag is in a whitespace stack
+            if (options.collapseWhitespace) {
+              if (stackNoTrimWhitespace.length) {
+                if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+                  stackNoTrimWhitespace.pop();
                 }
               }
-
-              var isElementEmpty = false;
-              if (tag === currentTag) {
-                currentTag = '';
-                isElementEmpty = !hasChars;
+              else {
+                squashTrailingWhitespace('/' + tag);
               }
-
-              if (options.removeOptionalTags) {
-                // <html>, <head> or <body> may be omitted if the element is empty
-                if (isElementEmpty && topLevelTags(optionalStartTag)) {
-                  removeStartTag();
-                }
-                optionalStartTag = '';
-                // </html> or </body> may be omitted if not followed by comment
-                // </head> may be omitted if not followed by space or comment
-                // </p> may be omitted if no more content in non-</a> parent
-                // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
-                if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
-                  removeEndTag();
-                }
-                optionalEndTag = optionalEndTags(tag) ? tag : '';
+              if (stackNoCollapseWhitespace.length &&
+                tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+                stackNoCollapseWhitespace.pop();
               }
+            }
 
-              if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-                // remove last "element" from buffer
+            var isElementEmpty = false;
+            if (tag === currentTag) {
+              currentTag = '';
+              isElementEmpty = !hasChars;
+            }
+
+            if (options.removeOptionalTags) {
+              // <html>, <head> or <body> may be omitted if the element is empty
+              if (isElementEmpty && topLevelTags(optionalStartTag)) {
                 removeStartTag();
-                optionalStartTag = '';
+              }
+              optionalStartTag = '';
+              // </html> or </body> may be omitted if not followed by comment
+              // </head> may be omitted if not followed by space or comment
+              // </p> may be omitted if no more content in non-</a> parent
+              // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
+              if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
+                removeEndTag();
+              }
+              optionalEndTag = optionalEndTags(tag) ? tag : '';
+            }
+
+            if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
+              // remove last "element" from buffer
+              removeStartTag();
+              optionalStartTag = '';
+              optionalEndTag = '';
+            }
+            else {
+              if (autoGenerated && !options.includeAutoGeneratedTags) {
                 optionalEndTag = '';
               }
               else {
-                if (autoGenerated && !options.includeAutoGeneratedTags) {
-                  optionalEndTag = '';
-                }
-                else {
-                  buffer.push('</' + tag + '>');
-                }
-                charsPrevTag = '/' + tag;
-                if (!inlineTags(tag)) {
-                  currentChars = '';
-                }
-                else if (isElementEmpty) {
-                  currentChars += '|';
-                }
+                buffer.push('</' + tag + '>');
+              }
+              charsPrevTag = '/' + tag;
+              if (!inlineTags(tag)) {
+                currentChars = '';
               }
+              else if (isElementEmpty) {
+                currentChars += '|';
+              }
+            }
 
-              return cb();
-            })
-          );
+            return cb();
+          });
+          if (options.ensureSynchronicity) {
+            nextTask.exec();
+          }
+          else {
+            subtasks.push(nextTask);
+          }
         },
         chars: function(text, prevTag, nextTag) {
-          subtasks.push(
-            new Task(function(cb) {
-              var subtasks = [];
-              prevTag = prevTag === '' ? 'comment' : prevTag;
-              nextTag = nextTag === '' ? 'comment' : nextTag;
-              if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-                text = decode(text);
-              }
-              if (options.collapseWhitespace) {
-                if (!stackNoTrimWhitespace.length) {
-                  if (prevTag === 'comment') {
-                    var prevComment = buffer[buffer.length - 1];
-                    if (prevComment.indexOf(uidIgnore) === -1) {
-                      if (!prevComment) {
-                        prevTag = charsPrevTag;
-                      }
-                      if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
-                        var charsIndex = buffer.length - 2;
-                        buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
-                          text = trailingSpaces + text;
-                          return '';
-                        });
-                      }
+          nextTask = new Task(function(cb) {
+            var subtasks = [];
+            prevTag = prevTag === '' ? 'comment' : prevTag;
+            nextTag = nextTag === '' ? 'comment' : nextTag;
+            if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+              text = decode(text);
+            }
+            if (options.collapseWhitespace) {
+              if (!stackNoTrimWhitespace.length) {
+                if (prevTag === 'comment') {
+                  var prevComment = buffer[buffer.length - 1];
+                  if (prevComment.indexOf(uidIgnore) === -1) {
+                    if (!prevComment) {
+                      prevTag = charsPrevTag;
+                    }
+                    if (buffer.length > 1 && (!prevComment || !options.conservativeCollapse && / $/.test(currentChars))) {
+                      var charsIndex = buffer.length - 2;
+                      buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function(trailingSpaces) {
+                        text = trailingSpaces + text;
+                        return '';
+                      });
                     }
                   }
-                  if (prevTag) {
-                    if (prevTag === '/nobr' || prevTag === 'wbr') {
-                      if (/^\s/.test(text)) {
-                        var tagIndex = buffer.length - 1;
-                        while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
-                          tagIndex--;
-                        }
-                        trimTrailingWhitespace(tagIndex - 1, 'br');
+                }
+                if (prevTag) {
+                  if (prevTag === '/nobr' || prevTag === 'wbr') {
+                    if (/^\s/.test(text)) {
+                      var tagIndex = buffer.length - 1;
+                      while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
+                        tagIndex--;
                       }
-                    }
-                    else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
-                      text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
+                      trimTrailingWhitespace(tagIndex - 1, 'br');
                     }
                   }
-                  if (prevTag || nextTag) {
-                    text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
-                  }
-                  else {
-                    text = collapseWhitespace(text, options, true, true);
-                  }
-                  if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
-                    trimTrailingWhitespace(buffer.length - 1, nextTag);
+                  else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+                    text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
                   }
                 }
-                if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
-                  text = collapseWhitespace(text, options, false, false, true);
+                if (prevTag || nextTag) {
+                  text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
+                }
+                else {
+                  text = collapseWhitespace(text, options, true, true);
+                }
+                if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
+                  trimTrailingWhitespace(buffer.length - 1, nextTag);
                 }
               }
-              if (options.processScripts && specialContentTags(currentTag)) {
-                subtasks.push(new Task(function(cb) {
-                  processScript(text, options, currentAttrs, function(error, result) {
-                    text = result;
-                    return cb(error);
-                  });
-                }));
+              if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
+                text = collapseWhitespace(text, options, false, false, true);
               }
-              if (isExecutableScript(currentTag, currentAttrs)) {
-                subtasks.push(new Task(function(cb) {
-                  var result = options.minifyJS(text, null, minifyJS_cb);
-                  if (typeof result !== 'undefined') {
-                    return minifyJS_cb(result);
-                  }
-
-                  var callbackCalled = false;
-                  function minifyJS_cb(result) {
-                    if (callbackCalled) {
-                      throw new Error('Async completion has already occurred.');
-                    }
-                    else {
-                      callbackCalled = true;
-                      text = result;
-                      return cb();
-                    }
-                  }
-                }));
+            }
+            if (options.processScripts && specialContentTags(currentTag)) {
+              nextTask = new Task(function(cb) {
+                processScript(text, options, currentAttrs, function(error, result) {
+                  text = result;
+                  return cb(error);
+                });
+              });
+              if (options.ensureSynchronicity) {
+                nextTask.exec();
               }
-              if (isStyleSheet(currentTag, currentAttrs)) {
-                subtasks.push(new Task(function(cb) {
-                  var result = options.minifyCSS(text, null, minifyCSS_cb);
-                  if (typeof result !== 'undefined') {
-                    return minifyCSS_cb(result);
-                  }
-
-                  var callbackCalled = false;
-                  function minifyCSS_cb(result) {
-                    if (callbackCalled) {
-                      throw new Error('Async completion has already occurred.');
-                    }
-                    else {
-                      callbackCalled = true;
-                      text = result;
-                      return cb();
-                    }
-                  }
-                }));
+              else {
+                subtasks.push(nextTask);
               }
-              subtasks.push(
-                new Task(function(cb) {
-                  if (options.removeOptionalTags && text) {
-                    // <html> may be omitted if first thing inside is not comment
-                    // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
-                    if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-                      removeStartTag();
-                    }
-                    optionalStartTag = '';
-                    // </html> or </body> may be omitted if not followed by comment
-                    // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
-                    if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-                      removeEndTag();
-                    }
-                    optionalEndTag = '';
+            }
+            if (isExecutableScript(currentTag, currentAttrs)) {
+              nextTask = new Task(function(cb) {
+                var result = options.minifyJS(text, null, minifyJS_cb);
+                if (typeof result !== 'undefined') {
+                  return minifyJS_cb(result);
+                }
+
+                var callbackCalled = false;
+                function minifyJS_cb(result) {
+                  if (callbackCalled) {
+                    throw new Error('Async completion has already occurred.');
                   }
-                  charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-                  if (options.decodeEntities && text && !specialContentTags(currentTag)) {
-                    // semi-colon can be omitted
-                    // https://mathiasbynens.be/notes/ambiguous-ampersands
-                    text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+                  else {
+                    callbackCalled = true;
+                    text = result;
+                    return cb();
                   }
-                  if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-                    text = text.replace(uidPattern, function(match, prefix, index) {
-                      return ignoredCustomMarkupChunks[+index][0];
-                    });
+                }
+              });
+              if (options.ensureSynchronicity) {
+                nextTask.exec();
+              }
+              else {
+                subtasks.push(nextTask);
+              }
+            }
+            if (isStyleSheet(currentTag, currentAttrs)) {
+              nextTask = new Task(function(cb) {
+                var result = options.minifyCSS(text, null, minifyCSS_cb);
+                if (typeof result !== 'undefined') {
+                  return minifyCSS_cb(result);
+                }
+
+                var callbackCalled = false;
+                function minifyCSS_cb(result) {
+                  if (callbackCalled) {
+                    throw new Error('Async completion has already occurred.');
                   }
-                  currentChars += text;
-                  if (text) {
-                    hasChars = true;
+                  else {
+                    callbackCalled = true;
+                    text = result;
+                    return cb();
                   }
+                }
+              });
+              if (options.ensureSynchronicity) {
+                nextTask.exec();
+              }
+              else {
+                subtasks.push(nextTask);
+              }
+            }
+            nextTask = new Task(function(cb) {
+              if (options.removeOptionalTags && text) {
+                // <html> may be omitted if first thing inside is not comment
+                // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
+                if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
+                  removeStartTag();
+                }
+                optionalStartTag = '';
+                // </html> or </body> may be omitted if not followed by comment
+                // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
+                if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
+                  removeEndTag();
+                }
+                optionalEndTag = '';
+              }
+              charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+              if (options.decodeEntities && text && !specialContentTags(currentTag)) {
+                // semi-colon can be omitted
+                // https://mathiasbynens.be/notes/ambiguous-ampersands
+                text = text.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp$1').replace(/</g, '&lt;');
+              }
+              if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+                text = text.replace(uidPattern, function(match, prefix, index) {
+                  return ignoredCustomMarkupChunks[+index][0];
+                });
+              }
+              currentChars += text;
+              if (text) {
+                hasChars = true;
+              }
+
+              buffer.push(text);
+              return cb();
+            });
+            if (options.ensureSynchronicity) {
+              nextTask.exec();
+            }
+            else {
+              subtasks.push(nextTask);
+            }
 
-                  buffer.push(text);
-                  return cb();
-                })
-              );
 
+            if (!options.ensureSynchronicity) {
               // Run this task's subtasks.
               new TaskGroup(subtasks).exec(cb);
-            })
-          );
+            }
+          });
+          if (options.ensureSynchronicity) {
+            nextTask.exec();
+          }
+          else {
+            subtasks.push(nextTask);
+          }
         },
         comment: function(text, nonStandard) {
-          subtasks.push(
-            new Task(function(cb) {
-              var subtasks = [];
-              var prefix = nonStandard ? '<!' : '<!--';
-              var suffix = nonStandard ? '>' : '-->';
-              if (isConditionalComment(text)) {
-                subtasks.push(new Task(function(cb) {
-                  cleanConditionalComment(text, options, function(error, result) {
-                    text = prefix + result + suffix;
-                    return cb(error);
-                  });
-                }));
+          nextTask = new Task(function(cb) {
+            var subtasks = [];
+            var prefix = nonStandard ? '<!' : '<!--';
+            var suffix = nonStandard ? '>' : '-->';
+            if (isConditionalComment(text)) {
+              nextTask = new Task(function(cb) {
+                cleanConditionalComment(text, options, function(error, result) {
+                  text = prefix + result + suffix;
+                  return cb(error);
+                });
+              });
+              if (options.ensureSynchronicity) {
+                nextTask.exec();
               }
-              else if (options.removeComments) {
-                if (isIgnoredComment(text, options)) {
-                  text = '<!--' + text + '-->';
-                }
-                else {
-                  text = '';
-                }
+              else {
+                subtasks.push(nextTask);
+              }
+            }
+            else if (options.removeComments) {
+              if (isIgnoredComment(text, options)) {
+                text = '<!--' + text + '-->';
               }
               else {
-                text = prefix + text + suffix;
+                text = '';
               }
+            }
+            else {
+              text = prefix + text + suffix;
+            }
 
-              subtasks.push(new Task(function(cb) {
-                if (options.removeOptionalTags && text) {
-                  // preceding comments suppress tag omissions
-                  optionalStartTag = '';
-                  optionalEndTag = '';
-                }
-                buffer.push(text);
-                cb();
-              }));
+            nextTask = new Task(function(cb) {
+              if (options.removeOptionalTags && text) {
+                // preceding comments suppress tag omissions
+                optionalStartTag = '';
+                optionalEndTag = '';
+              }
+              buffer.push(text);
+              cb();
+            });
+            if (options.ensureSynchronicity) {
+              nextTask.exec();
+            }
+            else {
+              subtasks.push(nextTask);
+            }
 
+            if (!options.ensureSynchronicity) {
               // Run this task's subtasks.
               new TaskGroup(subtasks).exec(cb);
-            })
-          );
+            }
+          });
+          if (options.ensureSynchronicity) {
+            nextTask.exec();
+          }
+          else {
+            subtasks.push(nextTask);
+          }
         },
         doctype: function(doctype) {
-          subtasks.push(
-            new Task(function(cb) {
-              buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
-              return cb();
-            })
-          );
+          nextTask = new Task(function(cb) {
+            buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
+            return cb();
+          });
+          if (options.ensureSynchronicity) {
+            nextTask.exec();
+          }
+          else {
+            subtasks.push(nextTask);
+          }
         },
         customAttrAssign: options.customAttrAssign,
         customAttrSurround: options.customAttrSurround
       });
 
-      // Run this task's subtasks.
-      new TaskGroup(subtasks).exec(cb);
+      if (!options.ensureSynchronicity) {
+        // Run this task's subtasks.
+        new TaskGroup(subtasks).exec(cb);
+      }
     }
     catch (error) {
-      return cb(error);
+      return topLevelCb(error);
     }
-  }));
+  });
+  if (options.ensureSynchronicity) {
+    nextTask.exec();
+  }
+  else {
+    tasks.push(nextTask);
+  }
 
   function finalize() {
     if (options.removeOptionalTags) {
@@ -1534,16 +1620,20 @@ function minify(value, options, partialMarkup, cb) {
       result = finalize();
     }
     catch (error) {
-      return cb(error);
+      return topLevelCb(error);
     }
-    return cb(null, result);
+    return topLevelCb(null, result);
+  }
+
+  if (options.ensureSynchronicity) {
+    return invokeCallBack();
   }
 
   // Run the tasks.
   new TaskGroup(tasks)
     .exec(function(error) {
       if (error) {
-        return cb(error);
+        return topLevelCb(error);
       }
       return invokeCallBack();
     });
@@ -1589,7 +1679,7 @@ function joinResultSegments(results, options) {
 exports.minify = function(value, options, cb) {
   var start = Date.now();
   var hasCallback = typeof cb === 'function';
-  options = processOptions(options || {});
+  options = processOptions(options || {}, !hasCallback);
 
   var minified;
   minify(value, options, false, function(error, result) {

From aef9258bf56e38c5dd73d8c049eb441e2a7c204c Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 18:00:00 +1200
Subject: [PATCH 61/66] Removed sync callback tests. Callbacks are never sync
 now.

---
 tests/minifier.js | 164 +++++++++++++---------------------------------
 1 file changed, 44 insertions(+), 120 deletions(-)

diff --git a/tests/minifier.js b/tests/minifier.js
index c7fd6b36..bbbbb35c 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -14,10 +14,9 @@ QUnit.test('`minifiy` exists', function(assert) {
  * Converts the options in the given object to use callbacks where possible.
  *
  * @param {?Object} options
- * @param {boolean} [async=false]
  * @returns {Object}
  */
-function convertOptionsCallbacks(options, async) {
+function convertOptionsCallbacks(options) {
   var convertedOptions = {};
 
   if (options) {
@@ -27,40 +26,22 @@ function convertOptionsCallbacks(options, async) {
 
     if (typeof options.minifyJS === 'function') {
       convertedOptions.minifyJS = function(text, inline, cb) {
-        function runMinifyJS() {
+        setTimeout(function() {
           var result = options.minifyJS(text, inline, cb);
           if (typeof result !== 'undefined') {
             cb(result);
           }
-        }
-
-        if (async) {
-          setTimeout(function() {
-            runMinifyJS();
-          }, 1);
-        }
-        else {
-          runMinifyJS();
-        }
+        }, 1);
       };
     }
     if (typeof options.minifyCSS === 'function') {
       convertedOptions.minifyCSS = function(text, type, cb) {
-        function runMinifyCSS() {
+        setTimeout(function() {
           var result = options.minifyCSS(text, type, cb);
           if (typeof result !== 'undefined') {
             cb(result);
           }
-        }
-
-        if (async) {
-          setTimeout(function() {
-            runMinifyCSS();
-          }, 1);
-        }
-        else {
-          runMinifyCSS();
-        }
+        }, 1);
       };
     }
   }
@@ -97,54 +78,25 @@ function test_minify(assert, input, output, inputOptions, description) {
     throw new Error('Bad description: ' + description);
   }
 
-  // Standard test.
+  // Synchronous test.
   assert.equal(minify(input, inputOptions), output, 'Standard Test: ' + description);
 
-  // Callback tests.
-  var callbackTests = [
-    // Sync callback test.
-    {
-      options: convertOptionsCallbacks(inputOptions, false),
-      async: false,
-      done: assert.async(),
-      descriptionPrefix: 'Synchronous Callback Test: '
-    },
-    // Async callback test.
-    {
-      options: convertOptionsCallbacks(inputOptions, true),
-      async: true,
-      done: assert.async(),
-      descriptionPrefix: 'Asynchronous Callback Test: '
-    }
-  ];
-
-  // Callbacks should take very long to complete.
+  // Asynchronous test.
+  var done = assert.async();
   assert.timeout(100);
+  var descriptionPrefix = 'Asynchronous Test: ';
 
-  // Run callback tests.
-  callbackTests.forEach(function(test) {
-    assert.notOk(minify(input, test.options, function(error, result) {
-      if (!test.finished) {
-        var stackTrace = '';
-        if (error && error instanceof Error) {
-          stackTrace = error.stack;
-        }
-
-        assert.equal(error, null, test.descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
-        assert.equal(result, output, test.descriptionPrefix + description);
-
-        test.finished = true;
-        test.done();
-      }
-    }));
-
-    // If callback test didn't finish synchronously when it should have.
-    if (!(test.finished || test.async)) {
-      assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
-      test.finished = true;
-      test.done();
+  assert.notOk(minify(input, convertOptionsCallbacks(inputOptions), function(error, result) {
+    var stackTrace = '';
+    if (error && error instanceof Error) {
+      stackTrace = error.stack;
     }
-  });
+
+    assert.equal(error, null, descriptionPrefix + 'An error occurred - stack trace:\n' + stackTrace);
+    assert.equal(result, output, descriptionPrefix + description);
+
+    done();
+  }));
 }
 
 /**
@@ -162,70 +114,40 @@ function test_minify_error(assert, input, inputOptions, errorMatcher, descriptio
     description = input;
   }
 
-  // Standard test.
+  // Synchronous test.
   assert.throws(
     function() {
       minify(input, inputOptions);
     },
     errorMatcher,
-    'Standard Test: ' + description
+    'Synchronous Test: ' + description
   );
 
-  // Callback tests.
-  var callbackTests = [
-    // Sync callback test.
-    {
-      options: convertOptionsCallbacks(inputOptions, false),
-      async: false,
-      done: assert.async(),
-      descriptionPrefix: 'Synchronous Callback Test: '
-    },
-    // Async callback test.
-    {
-      options: convertOptionsCallbacks(inputOptions, true),
-      async: true,
-      done: assert.async(),
-      descriptionPrefix: 'Asynchronous Callback Test: '
-    }
-  ];
-
-  // Callbacks should take very long to complete.
+  // Asynchronous test.
+  var done = assert.async();
   assert.timeout(100);
+  var descriptionPrefix = 'Asynchronous Test: ';
 
-  // Run callback tests.
-  callbackTests.forEach(function(test) {
-    try {
-      assert.notOk(minify(input, test.options, function(error, result) {
-        if (!test.finished) {
-          assert.ok(error, test.descriptionPrefix + 'An error should have occurred.');
-          assert.ok(error instanceof Error, test.descriptionPrefix + '"' + error + '" was returned as an error.');
-          assert.throws(function() { throw error; }, errorMatcher, test.descriptionPrefix + description);
-          assert.notOk(result);
-
-          test.finished = true;
-          test.done();
-        }
-      }));
-
-      // If callback test didn't finish synchronously when it should have.
-      if (!(test.finished || test.async)) {
-        assert.ok(false, test.descriptionPrefix + 'Didn\'t finish synchronously.');
-        test.finished = true;
-        test.done();
-      }
+  try {
+    assert.notOk(minify(input, convertOptionsCallbacks(inputOptions), function(error, result) {
+      assert.ok(error, descriptionPrefix + 'An error should have occurred.');
+      assert.ok(error instanceof Error, descriptionPrefix + '"' + error + '" was returned as an error.');
+      assert.throws(function() { throw error; }, errorMatcher, descriptionPrefix + description);
+      assert.notOk(result);
+
+      done();
+    }));
+  }
+  catch (error) {
+    // An error shouldn't be thrown - fail the test.
+    if (error && error instanceof Error) {
+      assert.ok(false, descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
     }
-    catch (error) {
-      test.finished = true;
-
-      // An error shouldn't be thrown - fail the test.
-      if (error && error instanceof Error) {
-        assert.ok(false, test.descriptionPrefix + 'threw an error - stack trace:\n' + error.stack);
-      }
-      else {
-        assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
-      }
+    else {
+      assert.ok(false, descriptionPrefix + 'threw an error - "' + error + '"');
     }
-  });
+    done();
+  }
 }
 
 QUnit.test('parsing non-trivial markup', function(assert) {
@@ -3628,6 +3550,7 @@ QUnit.test('minify error with callback', function(assert) {
     else {
       assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
     }
+    done();
   }
 });
 
@@ -3659,6 +3582,7 @@ QUnit.test('error in callback', function(assert) {
     else {
       assert.ok(false, test.descriptionPrefix + 'threw an error - "' + error + '"');
     }
+    done();
   }
 });
 

From e8c904886374e0a22f3810f858426b4fb27e7331 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 18:00:36 +1200
Subject: [PATCH 62/66] Fixed 'Maximum call stack size exceeded' in the async
 case.

---
 src/htmlminifier.js | 40 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 5 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index b0607635..5e35bfa1 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -871,12 +871,41 @@ var Task = (function() {
   /**
    * Execute this task.
    *
+   * If a callback is given, the task will complete asynchronously, otherwise
+   * synchronously.
+   *
    * @param {Callback} [cb]
    */
   Task.prototype.exec = function(cb) {
-    if (!cb) {
-      cb = function() {};
+    // Callback?
+    if (cb) {
+      // Make the callback async.
+      var origCb = cb;
+      cb = function() {
+        var args = arguments;
+        if (process && process.nextTick) {
+          process.nextTick(function() {
+            origCb.apply(null, args);
+          });
+        }
+        else {
+          setTimeout(function() {
+            origCb.apply(null, args);
+          }, 0);
+        }
+      };
+    }
+    // No callback?
+    else {
+      // Create simple callback to handle errors.
+      cb = function(error) {
+        if (error) {
+          Task.errorCb(error);
+        }
+      };
     }
+
+    // Run the task.
     this.task(cb);
   };
 
@@ -919,10 +948,10 @@ var TaskGroup = (function() {
         try {
           this.tasks[index].exec(function(error) {
             if (error) {
-              throw error;
+              return cb(error);
             }
             if (this.tasks[index].cbExecuted) {
-              throw new Error('Async completion has already occurred.');
+              return cb(new Error('Async completion has already occurred.'));
             }
             this.tasks[index].cbExecuted = true;
             implementation.call(this, index + 1);
@@ -950,6 +979,7 @@ var TaskGroup = (function() {
  */
 function minify(value, options, partialMarkup, cb) {
   var topLevelCb = cb;
+  Task.errorCb = cb;
 
   if (options.collapseWhitespace) {
     value = collapseWhitespace(value, options, true, true);
@@ -1559,7 +1589,7 @@ function minify(value, options, partialMarkup, cb) {
       }
     }
     catch (error) {
-      return topLevelCb(error);
+      return cb(error);
     }
   });
   if (options.ensureSynchronicity) {

From c39b07a43bf98937a9a2fb39082f4819a381e312 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 18:23:23 +1200
Subject: [PATCH 63/66] Improved comment.

---
 src/htmlminifier.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 5e35bfa1..c6836643 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -879,7 +879,7 @@ var Task = (function() {
   Task.prototype.exec = function(cb) {
     // Callback?
     if (cb) {
-      // Make the callback async.
+      // Make the callback async to avoid a `Maximum call stack size exceeded` error.
       var origCb = cb;
       cb = function() {
         var args = arguments;

From 38a147de7dc343b294efa996a3d7d61c2d875ff6 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Thu, 26 Apr 2018 19:11:05 +1200
Subject: [PATCH 64/66] Recovered from 'Maximum call stack size exceeded'
 error.

---
 src/htmlminifier.js | 83 +++++++++++++++++----------------------------
 1 file changed, 31 insertions(+), 52 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index c6836643..46952073 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -871,41 +871,9 @@ var Task = (function() {
   /**
    * Execute this task.
    *
-   * If a callback is given, the task will complete asynchronously, otherwise
-   * synchronously.
-   *
-   * @param {Callback} [cb]
+   * @param {Callback} cb
    */
   Task.prototype.exec = function(cb) {
-    // Callback?
-    if (cb) {
-      // Make the callback async to avoid a `Maximum call stack size exceeded` error.
-      var origCb = cb;
-      cb = function() {
-        var args = arguments;
-        if (process && process.nextTick) {
-          process.nextTick(function() {
-            origCb.apply(null, args);
-          });
-        }
-        else {
-          setTimeout(function() {
-            origCb.apply(null, args);
-          }, 0);
-        }
-      };
-    }
-    // No callback?
-    else {
-      // Create simple callback to handle errors.
-      cb = function(error) {
-        if (error) {
-          Task.errorCb(error);
-        }
-      };
-    }
-
-    // Run the task.
     this.task(cb);
   };
 
@@ -950,15 +918,20 @@ var TaskGroup = (function() {
             if (error) {
               return cb(error);
             }
-            if (this.tasks[index].cbExecuted) {
-              return cb(new Error('Async completion has already occurred.'));
-            }
-            this.tasks[index].cbExecuted = true;
             implementation.call(this, index + 1);
           }.bind(this));
         }
         catch (error) {
-          cb(error);
+          // Recover from `Maximum call stack size exceeded`.
+          if (error.message === 'Maximum call stack size exceeded') {
+            // Wait for stack to clear, then try again.
+            setTimeout(function() {
+              implementation.call(this, index);
+            }.bind(this), 0);
+          }
+          else {
+            cb(error);
+          }
         }
       }
       else {
@@ -979,7 +952,13 @@ var TaskGroup = (function() {
  */
 function minify(value, options, partialMarkup, cb) {
   var topLevelCb = cb;
-  Task.errorCb = cb;
+
+  // Calls the `topLevelCb` if an error is passed in.
+  function errorCallback(error) {
+    if (error) {
+      topLevelCb(error);
+    }
+  }
 
   if (options.collapseWhitespace) {
     value = collapseWhitespace(value, options, true, true);
@@ -1074,7 +1053,7 @@ function minify(value, options, partialMarkup, cb) {
       createSortFns(value, options, uidIgnore, uidAttr, cb);
     });
     if (options.ensureSynchronicity) {
-      nextTask.exec();
+      nextTask.exec(errorCallback);
     }
     else {
       tasks.push(nextTask);
@@ -1252,7 +1231,7 @@ function minify(value, options, partialMarkup, cb) {
             })(attrs.length, true);
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec();
+            nextTask.exec(errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1329,7 +1308,7 @@ function minify(value, options, partialMarkup, cb) {
             return cb();
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec();
+            nextTask.exec(errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1396,7 +1375,7 @@ function minify(value, options, partialMarkup, cb) {
                 });
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec();
+                nextTask.exec(errorCallback);
               }
               else {
                 subtasks.push(nextTask);
@@ -1422,7 +1401,7 @@ function minify(value, options, partialMarkup, cb) {
                 }
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec();
+                nextTask.exec(errorCallback);
               }
               else {
                 subtasks.push(nextTask);
@@ -1448,7 +1427,7 @@ function minify(value, options, partialMarkup, cb) {
                 }
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec();
+                nextTask.exec(errorCallback);
               }
               else {
                 subtasks.push(nextTask);
@@ -1489,7 +1468,7 @@ function minify(value, options, partialMarkup, cb) {
               return cb();
             });
             if (options.ensureSynchronicity) {
-              nextTask.exec();
+              nextTask.exec(errorCallback);
             }
             else {
               subtasks.push(nextTask);
@@ -1502,7 +1481,7 @@ function minify(value, options, partialMarkup, cb) {
             }
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec();
+            nextTask.exec(errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1521,7 +1500,7 @@ function minify(value, options, partialMarkup, cb) {
                 });
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec();
+                nextTask.exec(errorCallback);
               }
               else {
                 subtasks.push(nextTask);
@@ -1549,7 +1528,7 @@ function minify(value, options, partialMarkup, cb) {
               cb();
             });
             if (options.ensureSynchronicity) {
-              nextTask.exec();
+              nextTask.exec(errorCallback);
             }
             else {
               subtasks.push(nextTask);
@@ -1561,7 +1540,7 @@ function minify(value, options, partialMarkup, cb) {
             }
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec();
+            nextTask.exec(errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1573,7 +1552,7 @@ function minify(value, options, partialMarkup, cb) {
             return cb();
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec();
+            nextTask.exec(errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1593,7 +1572,7 @@ function minify(value, options, partialMarkup, cb) {
     }
   });
   if (options.ensureSynchronicity) {
-    nextTask.exec();
+    nextTask.exec(errorCallback);
   }
   else {
     tasks.push(nextTask);

From 8767828c4e7eb548bf52f5ed5499ee8ec5bbe66d Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 27 Apr 2018 13:16:44 +1200
Subject: [PATCH 65/66] Refactored

---
 src/htmlminifier.js | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 46952073..50569bec 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -880,7 +880,6 @@ var Task = (function() {
   return Task;
 })();
 
-
 /**
  * A group of Tasks and or other TaskGroups to execute in series.
  *
@@ -951,12 +950,14 @@ var TaskGroup = (function() {
  * @param {Callback} cb
  */
 function minify(value, options, partialMarkup, cb) {
-  var topLevelCb = cb;
-
-  // Calls the `topLevelCb` if an error is passed in.
+  /**
+   * Calls the `topLevelCb` if there is an error; otherwise does nothing.
+   *
+   * @param {Error} [error]
+   */
   function errorCallback(error) {
     if (error) {
-      topLevelCb(error);
+      return cb(error);
     }
   }
 
@@ -1578,7 +1579,7 @@ function minify(value, options, partialMarkup, cb) {
     tasks.push(nextTask);
   }
 
-  function finalize() {
+  function finalizeResult() {
     if (options.removeOptionalTags) {
       // <html> may be omitted if first thing inside is not comment
       // <head> or <body> may be omitted if empty
@@ -1623,28 +1624,28 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  function invokeCallBack() {
+  function finishUp() {
     var result;
     try {
-      result = finalize();
+      result = finalizeResult();
     }
     catch (error) {
-      return topLevelCb(error);
+      return cb(error);
     }
-    return topLevelCb(null, result);
+    return cb(null, result);
   }
 
   if (options.ensureSynchronicity) {
-    return invokeCallBack();
+    return finishUp();
   }
 
   // Run the tasks.
   new TaskGroup(tasks)
     .exec(function(error) {
       if (error) {
-        return topLevelCb(error);
+        return cb(error);
       }
-      return invokeCallBack();
+      return finishUp();
     });
   return;
 }

From 955882a405ced9ca302ea6f7f53dde9056340083 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Fri, 27 Apr 2018 15:21:21 +1200
Subject: [PATCH 66/66] The buffer can now recover from 'Maximum call stack
 size exceeded' error.

---
 src/htmlminifier.js | 186 ++++++++++++++++++++++++--------------------
 1 file changed, 101 insertions(+), 85 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 50569bec..f9df2ee7 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -9,8 +9,14 @@ var UglifyJS = require('uglify-js');
 var utils = require('./utils');
 
 /**
- * A callback that takes an error and a result.
- * @typedef {function([?Error], [string]):void} Callback
+ * A callback that takes an error and a string result.
+ * @typedef {function(?Error, string):void} ResultCallback
+ *
+ * A callback that takes an error and an update buffer.
+ * @typedef {function(?Error, Buffer):void} BufferCallback
+ *
+ * A buffer of strings.
+ * @typedef {string[]} Buffer
  */
 
 function trimWhitespace(str) {
@@ -853,7 +859,7 @@ function createSortFns(value, options, uidIgnore, uidAttr, cb) {
 }
 
 /**
- * A task that may finish either synchronously or asynchronously.
+ * A task that operates on the a buffer.
  *
  * The task will not be executed until explicitly told to.
  *
@@ -862,7 +868,7 @@ function createSortFns(value, options, uidIgnore, uidAttr, cb) {
 var Task = (function() {
   /**
    * @constructor
-   * @param {function([Callback])} task
+   * @param {function(Buffer, BufferCallback)} task
    */
   function Task(task) {
     this.task = task;
@@ -871,10 +877,11 @@ var Task = (function() {
   /**
    * Execute this task.
    *
-   * @param {Callback} cb
+   * @param {Buffer} buffer
+   * @param {BufferCallback} cb
    */
-  Task.prototype.exec = function(cb) {
-    this.task(cb);
+  Task.prototype.exec = function(buffer, cb) {
+    this.task(buffer, cb);
   };
 
   return Task;
@@ -901,23 +908,24 @@ var TaskGroup = (function() {
   /**
    * Run all tasks in this group in series.
    *
-   * @param {Callback} cb
+   * @param {Buffer} buffer
+   * @param {BufferCallback} cb
    */
-  TaskGroup.prototype.exec = function(cb) {
+  TaskGroup.prototype.exec = function(buffer, cb) {
     /**
      * Run the task at the given index, giving it a callback to run the next
      * task the same way.
      *
      * @param {number} index
      */
-    (function implementation(index) {
+    (function implementation(buffer, index) {
       if (index < this.tasks.length) {
         try {
-          this.tasks[index].exec(function(error) {
+          this.tasks[index].exec(buffer.slice(0), function(error, buffer) {
             if (error) {
               return cb(error);
             }
-            implementation.call(this, index + 1);
+            return implementation.call(this, buffer, index + 1);
           }.bind(this));
         }
         catch (error) {
@@ -925,7 +933,7 @@ var TaskGroup = (function() {
           if (error.message === 'Maximum call stack size exceeded') {
             // Wait for stack to clear, then try again.
             setTimeout(function() {
-              implementation.call(this, index);
+              implementation.call(this, buffer, index);
             }.bind(this), 0);
           }
           else {
@@ -934,9 +942,9 @@ var TaskGroup = (function() {
         }
       }
       else {
-        cb();
+        cb(null, buffer);
       }
-    }.bind(this))(0);
+    }.bind(this))(buffer, 0);
   };
   return TaskGroup;
 })();
@@ -947,7 +955,7 @@ var TaskGroup = (function() {
  * @param {string} value
  * @param {Object} options
  * @param {boolean} partialMarkup
- * @param {Callback} cb
+ * @param {ResultCallback} cb
  */
 function minify(value, options, partialMarkup, cb) {
   /**
@@ -965,8 +973,12 @@ function minify(value, options, partialMarkup, cb) {
     value = collapseWhitespace(value, options, true, true);
   }
 
-  var buffer = [],
-      charsPrevTag,
+  /**
+   * @type {Buffer}
+   */
+  var buffer = [];
+
+  var charsPrevTag,
       currentChars = '',
       hasChars,
       currentTag = '',
@@ -1050,11 +1062,13 @@ function minify(value, options, partialMarkup, cb) {
 
   if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||
       options.sortClassName && typeof options.sortClassName !== 'function') {
-    nextTask = new Task(function(cb) {
-      createSortFns(value, options, uidIgnore, uidAttr, cb);
+    nextTask = new Task(function(buffer, cb) {
+      createSortFns(value, options, uidIgnore, uidAttr, function(error) {
+        cb(error, buffer);
+      });
     });
     if (options.ensureSynchronicity) {
-      nextTask.exec(errorCallback);
+      nextTask.exec(buffer, errorCallback);
     }
     else {
       tasks.push(nextTask);
@@ -1069,7 +1083,7 @@ function minify(value, options, partialMarkup, cb) {
     return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);
   }
 
-  function removeStartTag() {
+  function removeStartTag(buffer) {
     var index = buffer.length - 1;
     while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
       index--;
@@ -1077,7 +1091,7 @@ function minify(value, options, partialMarkup, cb) {
     buffer.length = Math.max(0, index);
   }
 
-  function removeEndTag() {
+  function removeEndTag(buffer) {
     var index = buffer.length - 1;
     while (index > 0 && !/^<\//.test(buffer[index])) {
       index--;
@@ -1086,7 +1100,7 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   // look for trailing whitespaces, bypass any inline tags
-  function trimTrailingWhitespace(index, nextTag) {
+  function trimTrailingWhitespace(buffer, index, nextTag) {
     for (var endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {
       var str = buffer[index];
       var match = str.match(/^<\/([\w:-]+)>$/);
@@ -1102,7 +1116,7 @@ function minify(value, options, partialMarkup, cb) {
   // look for trailing whitespaces from previously processed text
   // which may not be trimmed due to a following comment or an empty
   // element which has now been removed
-  function squashTrailingWhitespace(nextTag) {
+  function squashTrailingWhitespace(buffer, nextTag) {
     var charsIndex = buffer.length - 1;
     if (buffer.length > 1) {
       var item = buffer[buffer.length - 1];
@@ -1110,10 +1124,10 @@ function minify(value, options, partialMarkup, cb) {
         charsIndex--;
       }
     }
-    trimTrailingWhitespace(charsIndex, nextTag);
+    trimTrailingWhitespace(buffer, charsIndex, nextTag);
   }
 
-  nextTask = new Task(function(cb) {
+  nextTask = new Task(function(buffer, cb) {
     try {
       var subtasks = [];
 
@@ -1122,7 +1136,7 @@ function minify(value, options, partialMarkup, cb) {
         html5: options.html5,
 
         start: function(tag, attrs, unary, unarySlash, autoGenerated) {
-          nextTask = new Task(function(cb) {
+          nextTask = new Task(function(buffer, cb) {
             var lowerTag = tag.toLowerCase();
 
             if (lowerTag === 'svg') {
@@ -1150,12 +1164,12 @@ function minify(value, options, partialMarkup, cb) {
               // <colgroup> may be omitted if first thing inside is <col>
               // <tbody> may be omitted if first thing inside is <tr>
               if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
-                removeStartTag();
+                removeStartTag(buffer);
               }
               optionalStartTag = '';
               // end-tag-followed-by-start-tag omission rules
               if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
-                removeEndTag();
+                removeEndTag(buffer);
                 // <colgroup> cannot be omitted if preceding </colgroup> is omitted
                 // <tbody> cannot be omitted if preceding </tbody>, </thead> or </tfoot> is omitted
                 optional = !isStartTagMandatory(optionalEndTag, tag);
@@ -1166,7 +1180,7 @@ function minify(value, options, partialMarkup, cb) {
             // set whitespace flags for nested tags (eg. <code> within a <pre>)
             if (options.collapseWhitespace) {
               if (!stackNoTrimWhitespace.length) {
-                squashTrailingWhitespace(tag);
+                squashTrailingWhitespace(buffer, tag);
               }
               if (!unary) {
                 if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
@@ -1224,22 +1238,22 @@ function minify(value, options, partialMarkup, cb) {
               buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
 
               if (autoGenerated && !options.includeAutoGeneratedTags) {
-                removeStartTag();
+                removeStartTag(buffer);
                 optionalStartTag = '';
               }
 
-              return cb();
+              return cb(null, buffer);
             })(attrs.length, true);
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec(errorCallback);
+            nextTask.exec(buffer, errorCallback);
           }
           else {
             subtasks.push(nextTask);
           }
         },
         end: function(tag, attrs, autoGenerated) {
-          nextTask = new Task(function(cb) {
+          nextTask = new Task(function(buffer, cb) {
             var lowerTag = tag.toLowerCase();
             if (lowerTag === 'svg') {
               options = Object.getPrototypeOf(options);
@@ -1254,7 +1268,7 @@ function minify(value, options, partialMarkup, cb) {
                 }
               }
               else {
-                squashTrailingWhitespace('/' + tag);
+                squashTrailingWhitespace(buffer, '/' + tag);
               }
               if (stackNoCollapseWhitespace.length &&
                 tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
@@ -1271,7 +1285,7 @@ function minify(value, options, partialMarkup, cb) {
             if (options.removeOptionalTags) {
               // <html>, <head> or <body> may be omitted if the element is empty
               if (isElementEmpty && topLevelTags(optionalStartTag)) {
-                removeStartTag();
+                removeStartTag(buffer);
               }
               optionalStartTag = '';
               // </html> or </body> may be omitted if not followed by comment
@@ -1279,14 +1293,14 @@ function minify(value, options, partialMarkup, cb) {
               // </p> may be omitted if no more content in non-</a> parent
               // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
               if (htmlTags(tag) && optionalEndTag && !trailingTags(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags(tag))) {
-                removeEndTag();
+                removeEndTag(buffer);
               }
               optionalEndTag = optionalEndTags(tag) ? tag : '';
             }
 
             if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
               // remove last "element" from buffer
-              removeStartTag();
+              removeStartTag(buffer);
               optionalStartTag = '';
               optionalEndTag = '';
             }
@@ -1306,17 +1320,17 @@ function minify(value, options, partialMarkup, cb) {
               }
             }
 
-            return cb();
+            return cb(null, buffer);
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec(errorCallback);
+            nextTask.exec(buffer, errorCallback);
           }
           else {
             subtasks.push(nextTask);
           }
         },
         chars: function(text, prevTag, nextTag) {
-          nextTask = new Task(function(cb) {
+          nextTask = new Task(function(buffer, cb) {
             var subtasks = [];
             prevTag = prevTag === '' ? 'comment' : prevTag;
             nextTag = nextTag === '' ? 'comment' : nextTag;
@@ -1347,7 +1361,7 @@ function minify(value, options, partialMarkup, cb) {
                       while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
                         tagIndex--;
                       }
-                      trimTrailingWhitespace(tagIndex - 1, 'br');
+                      trimTrailingWhitespace(buffer, tagIndex - 1, 'br');
                     }
                   }
                   else if (inlineTextTags(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
@@ -1361,7 +1375,7 @@ function minify(value, options, partialMarkup, cb) {
                   text = collapseWhitespace(text, options, true, true);
                 }
                 if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
-                  trimTrailingWhitespace(buffer.length - 1, nextTag);
+                  trimTrailingWhitespace(buffer, buffer.length - 1, nextTag);
                 }
               }
               if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
@@ -1369,27 +1383,28 @@ function minify(value, options, partialMarkup, cb) {
               }
             }
             if (options.processScripts && specialContentTags(currentTag)) {
-              nextTask = new Task(function(cb) {
+              nextTask = new Task(function(buffer, cb) {
                 processScript(text, options, currentAttrs, function(error, result) {
                   text = result;
-                  return cb(error);
+                  return cb(error, buffer);
                 });
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec(errorCallback);
+                nextTask.exec(buffer, errorCallback);
               }
               else {
                 subtasks.push(nextTask);
               }
             }
             if (isExecutableScript(currentTag, currentAttrs)) {
-              nextTask = new Task(function(cb) {
+              nextTask = new Task(function(buffer, cb) {
+                var callbackCalled = false;
+
                 var result = options.minifyJS(text, null, minifyJS_cb);
                 if (typeof result !== 'undefined') {
                   return minifyJS_cb(result);
                 }
 
-                var callbackCalled = false;
                 function minifyJS_cb(result) {
                   if (callbackCalled) {
                     throw new Error('Async completion has already occurred.');
@@ -1397,25 +1412,26 @@ function minify(value, options, partialMarkup, cb) {
                   else {
                     callbackCalled = true;
                     text = result;
-                    return cb();
+                    return cb(null, buffer);
                   }
                 }
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec(errorCallback);
+                nextTask.exec(buffer, errorCallback);
               }
               else {
                 subtasks.push(nextTask);
               }
             }
             if (isStyleSheet(currentTag, currentAttrs)) {
-              nextTask = new Task(function(cb) {
+              nextTask = new Task(function(buffer, cb) {
+                var callbackCalled = false;
+
                 var result = options.minifyCSS(text, null, minifyCSS_cb);
                 if (typeof result !== 'undefined') {
                   return minifyCSS_cb(result);
                 }
 
-                var callbackCalled = false;
                 function minifyCSS_cb(result) {
                   if (callbackCalled) {
                     throw new Error('Async completion has already occurred.');
@@ -1423,29 +1439,29 @@ function minify(value, options, partialMarkup, cb) {
                   else {
                     callbackCalled = true;
                     text = result;
-                    return cb();
+                    return cb(null, buffer);
                   }
                 }
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec(errorCallback);
+                nextTask.exec(buffer, errorCallback);
               }
               else {
                 subtasks.push(nextTask);
               }
             }
-            nextTask = new Task(function(cb) {
+            nextTask = new Task(function(buffer, cb) {
               if (options.removeOptionalTags && text) {
                 // <html> may be omitted if first thing inside is not comment
                 // <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>
                 if (optionalStartTag === 'html' || optionalStartTag === 'body' && !/^\s/.test(text)) {
-                  removeStartTag();
+                  removeStartTag(buffer);
                 }
                 optionalStartTag = '';
                 // </html> or </body> may be omitted if not followed by comment
                 // </head>, </colgroup> or </caption> may be omitted if not followed by space or comment
                 if (compactTags(optionalEndTag) || looseTags(optionalEndTag) && !/^\s/.test(text)) {
-                  removeEndTag();
+                  removeEndTag(buffer);
                 }
                 optionalEndTag = '';
               }
@@ -1466,10 +1482,10 @@ function minify(value, options, partialMarkup, cb) {
               }
 
               buffer.push(text);
-              return cb();
+              return cb(null, buffer);
             });
             if (options.ensureSynchronicity) {
-              nextTask.exec(errorCallback);
+              nextTask.exec(buffer, errorCallback);
             }
             else {
               subtasks.push(nextTask);
@@ -1478,30 +1494,30 @@ function minify(value, options, partialMarkup, cb) {
 
             if (!options.ensureSynchronicity) {
               // Run this task's subtasks.
-              new TaskGroup(subtasks).exec(cb);
+              new TaskGroup(subtasks).exec(buffer, cb);
             }
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec(errorCallback);
+            nextTask.exec(buffer, errorCallback);
           }
           else {
             subtasks.push(nextTask);
           }
         },
         comment: function(text, nonStandard) {
-          nextTask = new Task(function(cb) {
+          nextTask = new Task(function(buffer, cb) {
             var subtasks = [];
             var prefix = nonStandard ? '<!' : '<!--';
             var suffix = nonStandard ? '>' : '-->';
             if (isConditionalComment(text)) {
-              nextTask = new Task(function(cb) {
+              nextTask = new Task(function(buffer, cb) {
                 cleanConditionalComment(text, options, function(error, result) {
                   text = prefix + result + suffix;
-                  return cb(error);
+                  return cb(error, buffer);
                 });
               });
               if (options.ensureSynchronicity) {
-                nextTask.exec(errorCallback);
+                nextTask.exec(buffer, errorCallback);
               }
               else {
                 subtasks.push(nextTask);
@@ -1519,17 +1535,17 @@ function minify(value, options, partialMarkup, cb) {
               text = prefix + text + suffix;
             }
 
-            nextTask = new Task(function(cb) {
+            nextTask = new Task(function(buffer, cb) {
               if (options.removeOptionalTags && text) {
                 // preceding comments suppress tag omissions
                 optionalStartTag = '';
                 optionalEndTag = '';
               }
               buffer.push(text);
-              cb();
+              cb(null, buffer);
             });
             if (options.ensureSynchronicity) {
-              nextTask.exec(errorCallback);
+              nextTask.exec(buffer, errorCallback);
             }
             else {
               subtasks.push(nextTask);
@@ -1537,23 +1553,23 @@ function minify(value, options, partialMarkup, cb) {
 
             if (!options.ensureSynchronicity) {
               // Run this task's subtasks.
-              new TaskGroup(subtasks).exec(cb);
+              new TaskGroup(subtasks).exec(buffer, cb);
             }
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec(errorCallback);
+            nextTask.exec(buffer, errorCallback);
           }
           else {
             subtasks.push(nextTask);
           }
         },
         doctype: function(doctype) {
-          nextTask = new Task(function(cb) {
+          nextTask = new Task(function(buffer, cb) {
             buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
-            return cb();
+            return cb(null, buffer);
           });
           if (options.ensureSynchronicity) {
-            nextTask.exec(errorCallback);
+            nextTask.exec(buffer, errorCallback);
           }
           else {
             subtasks.push(nextTask);
@@ -1565,7 +1581,7 @@ function minify(value, options, partialMarkup, cb) {
 
       if (!options.ensureSynchronicity) {
         // Run this task's subtasks.
-        new TaskGroup(subtasks).exec(cb);
+        new TaskGroup(subtasks).exec(buffer, cb);
       }
     }
     catch (error) {
@@ -1573,26 +1589,26 @@ function minify(value, options, partialMarkup, cb) {
     }
   });
   if (options.ensureSynchronicity) {
-    nextTask.exec(errorCallback);
+    nextTask.exec(buffer, errorCallback);
   }
   else {
     tasks.push(nextTask);
   }
 
-  function finalizeResult() {
+  function finalizeResult(buffer) {
     if (options.removeOptionalTags) {
       // <html> may be omitted if first thing inside is not comment
       // <head> or <body> may be omitted if empty
       if (topLevelTags(optionalStartTag)) {
-        removeStartTag();
+        removeStartTag(buffer);
       }
       // except for </dt> or </thead>, end tags may be omitted if no more content in parent element
       if (optionalEndTag && !trailingTags(optionalEndTag)) {
-        removeEndTag();
+        removeEndTag(buffer);
       }
     }
     if (options.collapseWhitespace) {
-      squashTrailingWhitespace('br');
+      squashTrailingWhitespace(buffer, 'br');
     }
 
     var str = joinResultSegments(buffer, options);
@@ -1624,10 +1640,10 @@ function minify(value, options, partialMarkup, cb) {
     return str;
   }
 
-  function finishUp() {
+  function finishUp(buffer) {
     var result;
     try {
-      result = finalizeResult();
+      result = finalizeResult(buffer);
     }
     catch (error) {
       return cb(error);
@@ -1636,16 +1652,16 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   if (options.ensureSynchronicity) {
-    return finishUp();
+    return finishUp(buffer);
   }
 
   // Run the tasks.
   new TaskGroup(tasks)
-    .exec(function(error) {
+    .exec(buffer, function(error, buffer) {
       if (error) {
         return cb(error);
       }
-      return finishUp();
+      return finishUp(buffer);
     });
   return;
 }