From 8a675e4a2cdf2c2511750e76a0c26072eb040425 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 16:42:48 +1200
Subject: [PATCH 01/16] Added tests for async style and script minification
 using callbacks.

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

diff --git a/tests/minifier.js b/tests/minifier.js
index 4f71d662..9f461cc7 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3397,3 +3397,43 @@ 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(result) {
+      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(result) {
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});

From 7f1dc9ca8513a8f9b31da2eb2369aef089cc75e3 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 16:43:42 +1200
Subject: [PATCH 02/16] Added more tests for async style and script
 minification using callbacks.

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

diff --git a/tests/minifier.js b/tests/minifier.js
index 9f461cc7..8d5abc22 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3437,3 +3437,149 @@ QUnit.test('script minification with callback', function(assert) {
     }
   ));
 });
+
+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(result) {
+      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(result) {
+      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(result) {
+      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(result) {
+      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(result) {
+      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(result) {
+      assert.equal(result, output);
+      done();
+    }
+  ));
+});

From 8a3105ac5fee4747ae4a639078ef7040b27d64d6 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 16:51:18 +1200
Subject: [PATCH 03/16] Added a test to ensure that the minify function still
 results a result when a callback is given, if it finished synchronously.

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

diff --git a/tests/minifier.js b/tests/minifier.js
index 8d5abc22..54643126 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3583,3 +3583,17 @@ QUnit.test('multiple async minifications', function(assert) {
     }
   ));
 });
+
+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(result) {
+      assert.equal(result, output);
+      done();
+    }
+  ), output);
+});

From a68ee19317fb2fb05b9cef9c6b3a3ed77490414b Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 16:55:55 +1200
Subject: [PATCH 04/16] 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 892ca4b6a56d9428d71078e6b0b8b38d1ab1be59 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 16:57:07 +1200
Subject: [PATCH 05/16] 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 77f378691f1f19e2c2b66742a2192fe166371b3e Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:00:11 +1200
Subject: [PATCH 06/16] Added an onComplete function to the the HTMLParser
 class.

---
 src/htmlparser.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/htmlparser.js b/src/htmlparser.js
index dc1eb53c..1a35d98d 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -398,6 +398,20 @@ function HTMLParser(html, handler) {
   }
 }
 
+/**
+ * Called when the HTMLParser has finished.
+ *
+ * @param {Function} cb - Callback function.
+ */
+HTMLParser.prototype.onComplete = function(cb) {
+  if (this.finished) {
+    cb();
+  }
+  else {
+    this.onCompleteCallback = cb;
+  }
+};
+
 exports.HTMLParser = HTMLParser;
 exports.HTMLtoXML = function(html) {
   var results = '';

From 127669dbb9f37b90f8af71d47e30a05fcb1a8e54 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:25:27 +1200
Subject: [PATCH 07/16] Switch out the iterative loop for a recursive loop that
 supports callbacks.

---
 src/htmlparser.js | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/src/htmlparser.js b/src/htmlparser.js
index 1a35d98d..d6a8c824 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -120,7 +120,12 @@ function HTMLParser(html, handler) {
   var stack = [], lastTag;
   var attribute = attrForHandler(handler);
   var last, prevTag, nextTag;
-  while (html) {
+
+  (function iterate(cb) {
+    if (!html) {
+      return cb();
+    }
+
     last = html;
     // Make sure we're not in a script or style element
     if (!lastTag || !special(lastTag)) {
@@ -136,7 +141,7 @@ function HTMLParser(html, handler) {
             }
             html = html.substring(commentEnd + 3);
             prevTag = '';
-            continue;
+            return iterate(cb);
           }
         }
 
@@ -150,7 +155,7 @@ function HTMLParser(html, handler) {
             }
             html = html.substring(conditionalEnd + 2);
             prevTag = '';
-            continue;
+            return iterate(cb);
           }
         }
 
@@ -162,7 +167,7 @@ function HTMLParser(html, handler) {
           }
           html = html.substring(doctypeMatch[0].length);
           prevTag = '';
-          continue;
+          return iterate(cb);
         }
 
         // End tag:
@@ -171,7 +176,7 @@ function HTMLParser(html, handler) {
           html = html.substring(endTagMatch[0].length);
           endTagMatch[0].replace(endTag, parseEndTag);
           prevTag = '/' + endTagMatch[1].toLowerCase();
-          continue;
+          return iterate(cb);
         }
 
         // Start tag:
@@ -180,7 +185,7 @@ function HTMLParser(html, handler) {
           html = startTagMatch.rest;
           handleStartTag(startTagMatch);
           prevTag = startTagMatch.tagName.toLowerCase();
-          continue;
+          return iterate(cb);
         }
       }
 
@@ -239,12 +244,20 @@ function HTMLParser(html, handler) {
     if (html === last) {
       throw new Error('Parse Error: ' + html);
     }
-  }
 
-  if (!handler.partialMarkup) {
-    // Clean up any remaining tags
-    parseEndTag();
-  }
+
+    return iterate(cb);
+  })(function() {
+    if (!handler.partialMarkup) {
+      // Clean up any remaining tags
+      parseEndTag();
+    }
+
+    this.finished = true;
+    if (this.onCompleteCallback) {
+      this.onCompleteCallback();
+    }
+  }.bind(this));
 
   function parseStartTag(input) {
     var start = input.match(startTagOpen);

From 16c9ab7df99e0caee6b4c033bd18ba400df5ea3f Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:37:07 +1200
Subject: [PATCH 08/16] Wrapped the parse error check up into a function so its
 execution can be postponed.

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

diff --git a/src/htmlparser.js b/src/htmlparser.js
index d6a8c824..bfcf5e55 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -126,6 +126,8 @@ function HTMLParser(html, handler) {
       return cb();
     }
 
+    var waitingForCallback = false;
+
     last = html;
     // Make sure we're not in a script or style element
     if (!lastTag || !special(lastTag)) {
@@ -239,14 +241,18 @@ function HTMLParser(html, handler) {
       });
 
       parseEndTag('</' + stackedTag + '>', stackedTag);
-    }
 
-    if (html === last) {
-      throw new Error('Parse Error: ' + html);
+    if (!waitingForCallback) {
+      return checkForParseError(cb);
     }
 
+    function checkForParseError(cb) {
+      if (html === last) {
+        throw new Error('Parse Error: ' + html);
+      }
 
-    return iterate(cb);
+      return iterate(cb);
+    }
   })(function() {
     if (!handler.partialMarkup) {
       // Clean up any remaining tags

From 9c447fda585f499d253079d08d86cf170a822352 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:47:12 +1200
Subject: [PATCH 09/16] Refactored HTMLParser's parse loop.

---
 src/htmlparser.js | 35 ++++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/htmlparser.js b/src/htmlparser.js
index bfcf5e55..2d0e241a 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -117,13 +117,14 @@ function joinSingleAttrAssigns(handler) {
 }
 
 function HTMLParser(html, handler) {
+  var $this = this;
   var stack = [], lastTag;
   var attribute = attrForHandler(handler);
   var last, prevTag, nextTag;
 
-  (function iterate(cb) {
+  function parse() {
     if (!html) {
-      return cb();
+      return parseComplete();
     }
 
     var waitingForCallback = false;
@@ -143,7 +144,7 @@ function HTMLParser(html, handler) {
             }
             html = html.substring(commentEnd + 3);
             prevTag = '';
-            return iterate(cb);
+            return parse();
           }
         }
 
@@ -157,7 +158,7 @@ function HTMLParser(html, handler) {
             }
             html = html.substring(conditionalEnd + 2);
             prevTag = '';
-            return iterate(cb);
+            return parse();
           }
         }
 
@@ -169,7 +170,7 @@ function HTMLParser(html, handler) {
           }
           html = html.substring(doctypeMatch[0].length);
           prevTag = '';
-          return iterate(cb);
+          return parse();
         }
 
         // End tag:
@@ -178,7 +179,7 @@ function HTMLParser(html, handler) {
           html = html.substring(endTagMatch[0].length);
           endTagMatch[0].replace(endTag, parseEndTag);
           prevTag = '/' + endTagMatch[1].toLowerCase();
-          return iterate(cb);
+          return parse();
         }
 
         // Start tag:
@@ -187,7 +188,7 @@ function HTMLParser(html, handler) {
           html = startTagMatch.rest;
           handleStartTag(startTagMatch);
           prevTag = startTagMatch.tagName.toLowerCase();
-          return iterate(cb);
+          return parse();
         }
       }
 
@@ -243,27 +244,31 @@ function HTMLParser(html, handler) {
       parseEndTag('</' + stackedTag + '>', stackedTag);
 
     if (!waitingForCallback) {
-      return checkForParseError(cb);
+      return checkForParseError();
     }
 
-    function checkForParseError(cb) {
+    function checkForParseError() {
       if (html === last) {
         throw new Error('Parse Error: ' + html);
       }
 
-      return iterate(cb);
+      return parse();
     }
-  })(function() {
+  }
+
+  parse();
+
+  function parseComplete() {
     if (!handler.partialMarkup) {
       // Clean up any remaining tags
       parseEndTag();
     }
 
-    this.finished = true;
-    if (this.onCompleteCallback) {
-      this.onCompleteCallback();
+    $this.finished = true;
+    if ($this.onCompleteCallback) {
+      $this.onCompleteCallback();
     }
-  }.bind(this));
+  }
 
   function parseStartTag(input) {
     var start = input.match(startTagOpen);

From bac6a0e0fc1d0e6eba73a5b7ddad44e80c8c5c94 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:52:51 +1200
Subject: [PATCH 10/16] Code at the end of the minify function now waits until
 the HTMLParser has finished parsing the code before continuing.

---
 src/htmlminifier.js | 82 ++++++++++++++++++++++++---------------------
 1 file changed, 44 insertions(+), 38 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index ea298d5f..c3aed0ba 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -941,6 +941,7 @@ function minify(value, options, partialMarkup, cb) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
+  var str;
   new HTMLParser(value, {
     partialMarkup: partialMarkup,
     html5: options.html5,
@@ -1226,50 +1227,55 @@ function minify(value, options, partialMarkup, cb) {
     },
     customAttrAssign: options.customAttrAssign,
     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();
+  }).onComplete(function() {
+    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);
+    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');
+
+    if (typeof cb === 'function') {
+      cb(str);
+    }
+  });
 
-  options.log('minified in: ' + (Date.now() - t) + 'ms');
   return str;
 }
 

From b2626ce758f75394f8ca404141bfa01ed8dc4c34 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 17:56:21 +1200
Subject: [PATCH 11/16] Added callback to chars function which will always be
 called once it completes. minifyJS and minifyCSS function are now passed a
 callback function.

---
 src/htmlminifier.js | 93 ++++++++++++++++++++++++++++++---------------
 1 file changed, 63 insertions(+), 30 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index c3aed0ba..3e1c41cd 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1107,7 +1107,7 @@ function minify(value, options, partialMarkup, cb) {
         }
       }
     },
-    chars: function(text, prevTag, nextTag) {
+    chars: function(text, prevTag, nextTag, cb) {
       prevTag = prevTag === '' ? 'comment' : prevTag;
       nextTag = nextTag === '' ? 'comment' : nextTag;
       if (options.decodeEntities && text && !specialContentTags(currentTag)) {
@@ -1161,42 +1161,75 @@ function minify(value, options, partialMarkup, cb) {
       if (options.processScripts && specialContentTags(currentTag)) {
         text = processScript(text, options, currentAttrs);
       }
+
+      var tasksWaitingFor = 0, tasksComplete = 0;
+
+      function onTaskFinished(result) {
+        text = result;
+        if (tasksWaitingFor === ++tasksComplete) {
+          afterTasksFinish();
+        }
+      }
+
       if (isExecutableScript(currentTag, currentAttrs)) {
-        text = options.minifyJS(text);
+        tasksWaitingFor++;
+        var minifyJSResult = options.minifyJS(text, null, onTaskFinished);
+
+        // If the result is defined then minifyJSResult completed synchronously.
+        // eslint-disable-next-line no-undefined
+        if (minifyJSResult !== undefined) {
+          onTaskFinished(minifyJSResult);
+        }
       }
+
       if (isStyleSheet(currentTag, currentAttrs)) {
-        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();
-        }
-        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();
+        tasksWaitingFor++;
+        var minifyCSSResult = options.minifyCSS(text, onTaskFinished);
+
+        // If the result is defined then minifyCSS completed synchronously.
+        // eslint-disable-next-line no-undefined
+        if (minifyCSSResult !== undefined) {
+          onTaskFinished(minifyCSSResult);
         }
-        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 (tasksWaitingFor === 0) {
+        afterTasksFinish();
       }
-      currentChars += text;
-      if (text) {
-        hasChars = true;
+
+      function afterTasksFinish() {
+        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);
+        cb();
       }
-      buffer.push(text);
     },
     comment: function(text, nonStandard) {
       var prefix = nonStandard ? '<!' : '<!--';

From 143a8feab783e385ffa7919a424445956e5b5bfc Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 18:00:28 +1200
Subject: [PATCH 12/16] HTMLParser now supplies the chars's callback function
 which will continue the parse loop once called.

---
 src/htmlparser.js | 46 +++++++++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/htmlparser.js b/src/htmlparser.js
index 2d0e241a..cf1eed24 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -218,30 +218,46 @@ function HTMLParser(html, handler) {
       }
 
       if (handler.chars) {
-        handler.chars(text, prevTag, nextTag);
+        waitingForCallback = true;
+        handler.chars(
+          text,
+          prevTag,
+          nextTag,
+          function() {
+            prevTag = '';
+            checkForParseError();
+          }
+        );
       }
-      prevTag = '';
 
     }
     else {
       var stackedTag = lastTag.toLowerCase();
       var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)</' + stackedTag + '[^>]*>', 'i'));
 
-      html = html.replace(reStackedTag, function(all, text) {
-        if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!--([\s\S]*?)-->/g, '$1')
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-
-        if (handler.chars) {
-          handler.chars(text);
-        }
+      var replaceDetails = html.match(reStackedTag);
 
-        return '';
-      });
+      var charsText = replaceDetails[1];
+      if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
+        charsText = charsText
+          .replace(/<!--([\s\S]*?)-->/g, '$1')
+          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+      }
 
-      parseEndTag('</' + stackedTag + '>', stackedTag);
+      if (handler.chars) {
+        waitingForCallback = true;
+        handler.chars(
+          charsText,
+          null,
+          null,
+          function() {
+            html = html.substring(0, replaceDetails.index) + html.substring(replaceDetails.index + replaceDetails[0].length);
+            parseEndTag('</' + stackedTag + '>', stackedTag);
+            checkForParseError();
+          }
+        );
+      }
+    }
 
     if (!waitingForCallback) {
       return checkForParseError();

From e487a50232f2517fb1c91a4e0017daef14677e67 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 18:02:30 +1200
Subject: [PATCH 13/16] Moved parse() call up so that it isn't hidden within
 function definitions.

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

diff --git a/src/htmlparser.js b/src/htmlparser.js
index cf1eed24..167c4317 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -122,6 +122,8 @@ function HTMLParser(html, handler) {
   var attribute = attrForHandler(handler);
   var last, prevTag, nextTag;
 
+  parse();
+
   function parse() {
     if (!html) {
       return parseComplete();
@@ -272,8 +274,6 @@ function HTMLParser(html, handler) {
     }
   }
 
-  parse();
-
   function parseComplete() {
     if (!handler.partialMarkup) {
       // Clean up any remaining tags

From b51fe21dc29462d6ed758c13a726dde990da2ca0 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 19:30:33 +1200
Subject: [PATCH 14/16] Added error handling.

---
 src/htmlminifier.js | 55 +++++++++++++++++++++++++++-------------
 src/htmlparser.js   | 35 +++++++++++++++++++++++---
 tests/minifier.js   | 61 ++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 122 insertions(+), 29 deletions(-)

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 3e1c41cd..a095125d 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -942,7 +942,7 @@ function minify(value, options, partialMarkup, cb) {
   }
 
   var str;
-  new HTMLParser(value, {
+  var parser = new HTMLParser(value, {
     partialMarkup: partialMarkup,
     html5: options.html5,
 
@@ -1172,24 +1172,34 @@ function minify(value, options, partialMarkup, cb) {
       }
 
       if (isExecutableScript(currentTag, currentAttrs)) {
-        tasksWaitingFor++;
-        var minifyJSResult = options.minifyJS(text, null, onTaskFinished);
-
-        // If the result is defined then minifyJSResult completed synchronously.
-        // eslint-disable-next-line no-undefined
-        if (minifyJSResult !== undefined) {
-          onTaskFinished(minifyJSResult);
+        try {
+          tasksWaitingFor++;
+          var minifyJSResult = options.minifyJS(text, null, onTaskFinished);
+
+          // If the result is defined then minifyJSResult completed synchronously.
+          // eslint-disable-next-line no-undefined
+          if (minifyJSResult !== undefined) {
+            onTaskFinished(minifyJSResult);
+          }
+        }
+        catch (error) {
+          cb(error);
         }
       }
 
       if (isStyleSheet(currentTag, currentAttrs)) {
-        tasksWaitingFor++;
-        var minifyCSSResult = options.minifyCSS(text, onTaskFinished);
-
-        // If the result is defined then minifyCSS completed synchronously.
-        // eslint-disable-next-line no-undefined
-        if (minifyCSSResult !== undefined) {
-          onTaskFinished(minifyCSSResult);
+        try {
+          tasksWaitingFor++;
+          var minifyCSSResult = options.minifyCSS(text, onTaskFinished);
+
+          // If the result is defined then minifyCSS completed synchronously.
+          // eslint-disable-next-line no-undefined
+          if (minifyCSSResult !== undefined) {
+            onTaskFinished(minifyCSSResult);
+          }
+        }
+        catch (error) {
+          cb(error);
         }
       }
 
@@ -1260,7 +1270,9 @@ function minify(value, options, partialMarkup, cb) {
     },
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround
-  }).onComplete(function() {
+  });
+
+  parser.onComplete(function() {
     if (options.removeOptionalTags) {
       // <html> may be omitted if first thing inside is not comment
       // <head> or <body> may be omitted if empty
@@ -1305,8 +1317,17 @@ function minify(value, options, partialMarkup, cb) {
     options.log('minified in: ' + (Date.now() - t) + 'ms');
 
     if (typeof cb === 'function') {
-      cb(str);
+      return cb(null, str);
+    }
+  });
+
+  parser.onError(function(error) {
+    if (typeof cb === 'function') {
+      return cb(error);
     }
+
+    // No callback to handle the error?
+    throw error;
   });
 
   return str;
diff --git a/src/htmlparser.js b/src/htmlparser.js
index 167c4317..af6a1f46 100644
--- a/src/htmlparser.js
+++ b/src/htmlparser.js
@@ -225,7 +225,11 @@ function HTMLParser(html, handler) {
           text,
           prevTag,
           nextTag,
-          function() {
+          function(error) {
+            if (error) {
+              return handleError(error);
+            }
+
             prevTag = '';
             checkForParseError();
           }
@@ -252,7 +256,11 @@ function HTMLParser(html, handler) {
           charsText,
           null,
           null,
-          function() {
+          function(error) {
+            if (error) {
+              return handleError(error);
+            }
+
             html = html.substring(0, replaceDetails.index) + html.substring(replaceDetails.index + replaceDetails[0].length);
             parseEndTag('</' + stackedTag + '>', stackedTag);
             checkForParseError();
@@ -267,7 +275,7 @@ function HTMLParser(html, handler) {
 
     function checkForParseError() {
       if (html === last) {
-        throw new Error('Parse Error: ' + html);
+        return handleError(new Error('Parse Error: ' + html));
       }
 
       return parse();
@@ -286,6 +294,13 @@ function HTMLParser(html, handler) {
     }
   }
 
+  function handleError(error) {
+    $this.error = error;
+    if ($this.onErrorCallback) {
+      $this.onErrorCallback(error);
+    }
+  }
+
   function parseStartTag(input) {
     var start = input.match(startTagOpen);
     if (start) {
@@ -452,6 +467,20 @@ HTMLParser.prototype.onComplete = function(cb) {
   }
 };
 
+/**
+ * Called when the HTMLParser encounters an error.
+ *
+ * @param {Function} cb - Callback function.
+ */
+HTMLParser.prototype.onError = function(cb) {
+  if (this.error) {
+    cb(this.error);
+  }
+  else {
+    this.onErrorCallback = cb;
+  }
+};
+
 exports.HTMLParser = HTMLParser;
 exports.HTMLtoXML = function(html) {
   var results = '';
diff --git a/tests/minifier.js b/tests/minifier.js
index 54643126..16cf76cf 100644
--- a/tests/minifier.js
+++ b/tests/minifier.js
@@ -3411,7 +3411,8 @@ QUnit.test('style minification with callback', function(assert) {
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3431,7 +3432,8 @@ QUnit.test('script minification with callback', function(assert) {
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3452,7 +3454,8 @@ QUnit.test('style async minification with script sync minification', function(as
       },
       minifyJS: true
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3473,7 +3476,8 @@ QUnit.test('style sync minification with script async minification', function(as
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3498,7 +3502,8 @@ QUnit.test('style async minification with script async minification', function(a
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3526,7 +3531,8 @@ QUnit.test('async minification along side sync minification', function(assert) {
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, asyncOutput);
       done();
     }
@@ -3557,7 +3563,8 @@ QUnit.test('multiple async minifications', function(assert) {
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3577,7 +3584,8 @@ QUnit.test('multiple async minifications', function(assert) {
         }, 0);
       }
     },
-    function(result) {
+    function(error, result) {
+      assert.notOk(error);
       assert.equal(result, output);
       done();
     }
@@ -3591,9 +3599,44 @@ QUnit.test('sync minify with callback', function(assert) {
   assert.equal(minify(
     input,
     {},
-    function(result) {
+    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 76007a1adc2a412069f1c06566644b6d980ee863 Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebeccastevens@catalyst.net.nz>
Date: Wed, 11 Apr 2018 19:44:17 +1200
Subject: [PATCH 15/16] Fixed comment.

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

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index a095125d..63930983 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1176,7 +1176,7 @@ function minify(value, options, partialMarkup, cb) {
           tasksWaitingFor++;
           var minifyJSResult = options.minifyJS(text, null, onTaskFinished);
 
-          // If the result is defined then minifyJSResult completed synchronously.
+          // If the result is defined then minifyJS completed synchronously.
           // eslint-disable-next-line no-undefined
           if (minifyJSResult !== undefined) {
             onTaskFinished(minifyJSResult);

From 65d142d0cc7bf2547741990a43c8390261b07b5a Mon Sep 17 00:00:00 2001
From: Rebecca Stevens <rebecca.stevens@outlook.co.nz>
Date: Wed, 11 Apr 2018 21:16:53 +1200
Subject: [PATCH 16/16] Switch out undefined compare for typeof undefined
 compare.

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

diff --git a/src/htmlminifier.js b/src/htmlminifier.js
index 63930983..3f945576 100644
--- a/src/htmlminifier.js
+++ b/src/htmlminifier.js
@@ -1177,8 +1177,7 @@ function minify(value, options, partialMarkup, cb) {
           var minifyJSResult = options.minifyJS(text, null, onTaskFinished);
 
           // If the result is defined then minifyJS completed synchronously.
-          // eslint-disable-next-line no-undefined
-          if (minifyJSResult !== undefined) {
+          if (typeof minifyJSResult !== 'undefined') {
             onTaskFinished(minifyJSResult);
           }
         }
@@ -1193,8 +1192,7 @@ function minify(value, options, partialMarkup, cb) {
           var minifyCSSResult = options.minifyCSS(text, onTaskFinished);
 
           // If the result is defined then minifyCSS completed synchronously.
-          // eslint-disable-next-line no-undefined
-          if (minifyCSSResult !== undefined) {
+          if (typeof minifyCSSResult !== 'undefined') {
             onTaskFinished(minifyCSSResult);
           }
         }