html-minifier 0.7.2 → 1.1.1

package/README.md

@@ -1,7 +1,7 @@
-[![NPM version](https://img.shields.io/npm/v/html-minifier.svg?style=flat)](https://www.npmjs.com/package/html-minifier)
-[![Build Status](https://img.shields.io/travis/kangax/html-minifier.svg?style=flat)](https://travis-ci.org/kangax/html-minifier)
-[![Dependency Status](https://img.shields.io/david/kangax/html-minifier.svg?style=flat)](https://david-dm.org/kangax/html-minifier)
-[![devDependency Status](https://img.shields.io/david/dev/kangax/html-minifier.svg?style=flat)](https://david-dm.org/kangax/html-minifier#info=devDependencies)
+[![NPM version](https://img.shields.io/npm/v/html-minifier.svg)](https://www.npmjs.com/package/html-minifier)
+[![Build Status](https://img.shields.io/travis/kangax/html-minifier.svg)](https://travis-ci.org/kangax/html-minifier)
+[![Dependency Status](https://img.shields.io/david/kangax/html-minifier.svg)](https://david-dm.org/kangax/html-minifier)
+[![devDependency Status](https://img.shields.io/david/dev/kangax/html-minifier.svg)](https://david-dm.org/kangax/html-minifier#info=devDependencies)
 
 [HTMLMinifier](http://kangax.github.io/html-minifier/) is a highly **configurable**, **well-tested**, Javascript-based HTML minifier, with lint-like capabilities.
 
@@ -11,17 +11,19 @@ See [corresponding blog post](http://perfectionkills.com/experimenting-with-html
 
 Also see corresponding [Ruby wrapper](https://github.com/stereobooster/html_minifier), and for Node.js, [Grunt plugin](https://github.com/gruntjs/grunt-contrib-htmlmin), [Gulp module](https://github.com/jonschlinkert/gulp-htmlmin), and [Koa middleware wrapper](https://github.com/koajs/html-minifier).
 
-How does HTMLMinifier compare to [another solution](http://www.willpeavy.com/minifier/) — HTML Minifier from Will Peavy (1st result in [google search for "html minifier"](https://www.google.com/#q=html+minifier)) as well as htmlcompressor.com?
+## Minification comparison
 
-| Site | Original size _(KB)_ | HTMLMinifier _(KB)_ | Will Peavy _(KB)_ | htmlcompressor.com _(KB)_ |
-| --------------------------------------------------------------------------- |:-----------:| ----------------:| ------------:| ----------------:|
-| [HTMLMinifier page](https://github.com/kangax/html-minifier)                | 48.8        | <b>37.3</b>      |   43.3       | 41.9 |
-| [ES6 table](http://kangax.github.io/es5-compat-table/es6/)                  | 117.9       | <b>79.9</b>      |   92         | 91.9 |
-| [MSN](http://msn.com)                                                       | 156.6       | <b>133</b>       |   145        | 138.3 |
-| [Stackoverflow](http://stackoverflow.com)                                   | 200.4       | <b>159.5</b>     |   168.3      | 163.3 |
-| [Amazon](http://amazon.com)                                                 | 245.9       | <b>206.3</b>     |   225        | 218.5 |
-| [Wikipedia](http://en.wikipedia.org/wiki/President_of_the_United_States)    | 401.4       | <b>380.6</b>     |   396.3      | n/a |
-| [Eloquent Javascript](http://eloquentjavascript.net/print.html)             | 869.5       | <b>830</b>       |   872        | n/a |
+How does HTMLMinifier compare to other solutions — [HTML Minifier from Will Peavy](http://www.willpeavy.com/minifier/) (1st result in [google search for "html minifier"](https://www.google.com/#q=html+minifier)) as well as [htmlcompressor.com](http://htmlcompressor.com) and [minimize](https://github.com/Swaagie/minimize)?
+
+| Site | Original size _(KB)_ | HTMLMinifier | minimize | Will Peavy | htmlcompressor.com |
+| --------------------------------------------------------------------------- |:-----------:| ----------------:| ----------------:| ------------:| ----------------:|
+| [HTMLMinifier page](https://github.com/kangax/html-minifier)                | 48.8        | <b>37.3</b>      | 41.8      |   43.3       | 41.9 |
+| [ES6 table](http://kangax.github.io/es5-compat-table/es6/)                  | 117.9       | <b>79.9</b>      | 94.1      |   92         | 91.9 |
+| [MSN](http://msn.com)                                                       | 156.6       | <b>133</b>       | 137.7     |   145        | 138.3 |
+| [Stackoverflow](http://stackoverflow.com)                                   | 200.4       | <b>159.5</b>     | 165.1     |   168.3      | 163.3 |
+| [Amazon](http://amazon.com)                                                 | 245.9       | <b>206.3</b>     | 234.1     |   225        | 218.5 |
+| [Wikipedia](http://en.wikipedia.org/wiki/President_of_the_United_States)    | 401.4       | <b>380.6</b>     | 386.6     |   396.3      | n/a |
+| [Eloquent Javascript](http://eloquentjavascript.net/print.html)             | 869.5       | <b>830</b>       | 838       |   872        | n/a |
 
 
 
@@ -44,7 +46,6 @@ How does HTMLMinifier compare to [another solution](http://www.willpeavy.com/min
 | `removeScriptTypeAttributes`   | Remove `type="text/javascript"` from `script` tags. Other `type` attribute values are left intact. | `false` |
 | `removeStyleLinkTypeAttributes`| Remove `type="text/css"` from `style` and `link` tags. Other `type` attribute values are left intact. | `false` |
 | `removeOptionalTags`           | [Remove unrequired tags](http://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags) | `false` |
-| `removeIgnored`                | Remove all tags starting and ending with `<%`, `%>`, `<?`, `?>` | `false` |
 | `removeEmptyElements`          | [Remove all elements with empty contents](http://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_elements) | `false` |
 | `lint`                         | [Toggle linting](http://perfectionkills.com/experimenting-with-html-minifier/#validate_input_through_html_lint) | `false` |
 | `keepClosingSlash`             | Keep the trailing slash on singleton elements                            | `false` |
@@ -53,11 +54,13 @@ How does HTMLMinifier compare to [another solution](http://www.willpeavy.com/min
 | `minifyCSS`                    | Minify CSS in style elements and style attributes (uses [clean-css](https://github.com/GoalSmashers/clean-css)) | `false` (could be `true`, `false`, `Object` (options)) |
 | `minifyURLs`                   | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `Object` (options)) |
 | `ignoreCustomComments`         | Array of regex'es that allow to ignore certain comments, when matched  | `[ ]` |
+| `ignoreCustomFragments`         | Array of regex'es that allow to ignore certain fragments, when matched (e.g. `<?php ... ?>`, `{{ ... }}`, etc.)  | `[ ]` |
 | `processScripts`               | Array of strings corresponding to types of script elements to process through minifier (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.) | `[ ]` |
 | `maxLineLength`                | Specify a maximum line length. Compressed output will be split by newlines at valid HTML split-points. |
 | `customAttrAssign`             | Arrays of regex'es that allow to support custom attribute assign expressions (e.g. `'<div flex?="{{mode != cover}}"></div>'`) | `[ ]` |
 | `customAttrSurround`           | Arrays of regex'es that allow to support custom attribute surround expressions (e.g. `<input {{#if value}}checked="checked"{{/if}}>`) | `[ ]` |
 | `customAttrCollapse`           | Regex that specifies custom attribute to strip newlines from (e.g. `/ng\-class/`) | |
+| `quoteCharacter`               | Type of quote to use for attribute values (' or ") | " |
 
 ## Special cases
 
@@ -69,6 +72,26 @@ If you have chunks of markup you would like preserved, you can wrap them `<!-- h
 
 SVG tags are automatically recognized, and when they are minified, both case-sensitivity and closing-slashes are preserved, regardless of the minification settings used for the rest of the file.
 
+### Working with invalid markup
+
+HTMLMinifier **can't work with invalid or partial chunks of markup**. This is because it parses markup into a tree structure, then modifies it (removing anything that was specified for removal, ignoring anything that was specified to be ingored, etc.), then it creates a markup out of that tree and returns it.
+
+Input markup (e.g. `<p id="">foo`)
+
+↓
+
+Internal representation of markup in a form of tree (e.g. `{tag: "p", attr: "id", children: ["foo"] }`)
+
+↓
+
+Transformation of internal representation (e.g. removal of "id" attribute)
+
+↓
+
+Output of resulting markup (e.g. `<p>foo</p>`)
+
+HTMLMinifier can't know that original markup was only half of the tree; it does its best to try to parse it as a full tree and it loses information about tree being malformed or partial in the beginning. As a result, it can't create a partial/malformed tree at the time of the output.
+
 ## Installation Instructions
 
 From NPM for use as a command line app:

package/cli.js

@@ -63,6 +63,7 @@ var mainOptions = {
   collapseWhitespace: [[false, 'Collapse white space that contributes to text nodes in a document tree.']],
   conservativeCollapse: [[false, 'Always collapse to 1 space (never remove it entirely)']],
   preserveLineBreaks: [[false, 'Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break.']],
+  collapseInlineTagWhitespace: [[false, 'Collapse white space around inline tag']],
   collapseBooleanAttributes: [[false, 'Omit attribute values from boolean attributes']],
   removeAttributeQuotes: [[false, 'Remove quotes around attributes when possible.']],
   removeRedundantAttributes: [[false, 'Remove attributes when value matches default.']],
@@ -72,7 +73,6 @@ var mainOptions = {
   removeScriptTypeAttributes: [[false, 'Remove type="text/javascript" from script tags. Other type attribute values are left intact.']],
   removeStyleLinkTypeAttributes: [[false, 'Remove type="text/css" from style and link tags. Other type attribute values are left intact.']],
   removeOptionalTags: [[false, 'Remove unrequired tags']],
-  removeIgnored: [[false, 'Remove all tags starting and ending with <%, %>, <?, ?>']],
   removeEmptyElements: [[false, 'Remove all elements with empty contents']],
   lint: [[false, 'Toggle linting']],
   keepClosingSlash: [[false, 'Keep the trailing slash on singleton elements']],
@@ -80,18 +80,20 @@ var mainOptions = {
   minifyJS: [[false, 'Minify Javascript in script elements and on* attributes (uses UglifyJS)']],
   minifyCSS: [[false, 'Minify CSS in style elements and style attributes (uses clean-css)']],
   minifyURLs: [[false, 'Minify URLs in various attributes (uses relateurl)']],
-  ignoreCustomComments: [[false, 'Array of regex\'es that allow to ignore certain comments, when matched', 'string'], 'json'],
-  processScripts: [[false, 'Array of strings corresponding to types of script elements to process through minifier (e.g. "text/ng-template", "text/x-handlebars-template", etc.)', 'string'], 'json'],
+  ignoreCustomComments: [[false, 'Array of regex\'es that allow to ignore certain comments, when matched', 'string'], 'json-regex'],
+  processScripts: [[false, 'Array of strings corresponding to types of script elements to process through minifier (e.g. "text/ng-template", "text/x-handlebars-template", etc.)', 'string'], 'json-regex'],
   maxLineLength: [[false, 'Max line length', 'number'], true],
-  customAttrAssign: [[false, 'Arrays of regex\'es that allow to support custom attribute assign expressions (e.g. \'<div flex?="{{mode != cover}}"></div>\')', 'string'], 'json'],
-  customAttrSurround: [[false, 'Arrays of regex\'es that allow to support custom attribute surround expressions (e.g. <input {{#if value}}checked="checked"{{/if}}>)', 'string'], 'json'],
-  customAttrCollapse: [[false, 'Regex that specifies custom attribute to strip newlines from (e.g. /ng\-class/)', 'string'], true]
+  customAttrAssign: [[false, 'Arrays of regex\'es that allow to support custom attribute assign expressions (e.g. \'<div flex?="{{mode != cover}}"></div>\')', 'string'], 'json-regex'],
+  customAttrSurround: [[false, 'Arrays of regex\'es that allow to support custom attribute surround expressions (e.g. <input {{#if value}}checked="checked"{{/if}}>)', 'string'], 'json-regex'],
+  customAttrCollapse: [[false, 'Regex that specifies custom attribute to strip newlines from (e.g. /ng\-class/)', 'string'], 'string-regex']
 };
 
 var cliOptions = {
   version: ['v', 'Version information'],
   output: ['o', 'Specify output file (if not specified STDOUT will be used for output)', 'file'],
-  'config-file': ['c', 'Use config file', 'file']
+  'config-file': ['c', 'Use config file', 'file'],
+  'input-dir': [false, 'Specify an input directory', 'dir'],
+  'output-dir': [false, 'Specify an output directory', 'dir']
 };
 
 var mainOptionKeys = Object.keys(mainOptions);
@@ -103,13 +105,48 @@ cli.parse(cliOptions);
 
 cli.main(function(args, options) {
 
-  function parseJSONOption(value) {
+  function stringToRegExp(value) {
+    // JSON does not support regexes, so, e.g., JSON.parse() will not create
+    // a RegExp from the JSON value `[ "/matchString/" ]`, which is
+    // technically just an array containing a string that begins and end with
+    // a forward slash. To get a RegExp from a JSON string, it must be
+    // constructed explicitly in JavaScript.
+    //
+    // The likelihood of actually wanting to match text that is enclosed in
+    // forward slashes is probably quite rare, so if forward slashes were
+    // included in an argument that requires a regex, the user most likely
+    // thought they were part of the syntax for specifying a regex.
+    //
+    // In the unlikely case that forward slashes are indeed desired in the
+    // search string, the user would need to enclose the expression in a
+    // second set of slashes:
+    //
+    //    --customAttrSrround "[\"//matchString//\"]"
+    //
+    if (value) {
+      var stripSlashes = /^\/(.*)\/$/.exec(value);
+      if (stripSlashes) {
+        value = stripSlashes[1];
+      }
+      return new RegExp(value);
+    }
+  }
+
+  function parseJSONOption(value, options) {
+    var opts = options || {};
     if (value !== null) {
       var jsonArray;
       try {
         jsonArray = JSON.parse(value);
+        if (opts.regexArray) {
+          jsonArray = jsonArray.map(function (regexString) {
+            return stringToRegExp(regexString);
+          });
+        }
+      }
+      catch (e) {
+        cli.fatal('Could not parse JSON value \'' + value + '\'');
       }
-      catch (e) {}
       if (jsonArray instanceof Array) {
         return jsonArray;
       }
@@ -119,7 +156,7 @@ cli.main(function(args, options) {
     }
   }
 
-  function runMinify(original) {
+  function runMinify(original, output) {
     var status = 0;
     var minified = null;
     try {
@@ -127,7 +164,8 @@ cli.main(function(args, options) {
     }
     catch (e) {
       status = 3;
-      process.stderr.write('Error: Minification error');
+      cli.error('Minification error');
+      process.stderr.write(e);
     }
 
     if (minifyOptions.lint) {
@@ -146,31 +184,76 @@ cli.main(function(args, options) {
       }
       catch (e) {
         status = 4;
-        process.stderr.write('Error: Cannot write to output');
+        console.log(output);
+        cli.error('Cannot write to output');
       }
     }
 
     cli.exit(status);
   }
 
+  function createDirectory(path) {
+    try {
+      fs.mkdirSync(path);
+    }
+    catch (e) {
+      if (e.code === 'EEXIST') {
+        return;
+      }
+      cli.fatal('Can not create directory ' + path);
+      cli.exit(3);
+    }
+  }
+
+  function processDirectory(inputDir, outputDir) {
+    createDirectory(outputDir);
+    var fileList = fs.readdirSync(inputDir);
+
+    fileList.forEach(function(fileName) {
+      var inputFilePath = inputDir + '/' + fileName;
+      var outputFilePath = outputDir + '/' + fileName;
+
+      var stat = fs.statSync(inputFilePath);
+      if (stat.isDirectory()) {
+        processDirectory(inputFilePath, outputFilePath);
+        return;
+      }
+
+      var originalContent = fs.readFileSync(inputFilePath, 'utf8');
+      runMinify(originalContent, outputFilePath);
+    });
+  }
+
   if (options.version) {
-    process.stderr.write(appName + ' v' + appVersion);
+    cli.output(appName + ' v' + appVersion);
     cli.exit(0);
   }
 
   if (options['config-file']) {
+    var fileOptions;
+    var fileOptionsPath = path.resolve(options['config-file']);
     try {
-      var fileOptions = JSON.parse(fs.readFileSync(path.resolve(options['config-file']), 'utf8'));
-      if ((fileOptions !== null) && (typeof fileOptions === 'object')) {
-        minifyOptions = fileOptions;
-      }
+      fs.accessSync(fileOptionsPath, fs.R_OK);
     }
     catch (e) {
-      process.stderr.write('Error: Cannot read the specified config file');
-      cli.exit(1);
+      cli.fatal('The specified config file doesn’t exist or is unreadable:\n' + fileOptionsPath);
+    }
+    try {
+      fileOptions = JSON.parse(fs.readFileSync(fileOptionsPath), 'utf8');
+    }
+    catch (je) {
+      try {
+        fileOptions = require(fileOptionsPath);
+      }
+      catch (ne) {
+        cli.fatal('Cannot read the specified config file. \nAs JSON: ' + je.message + '\nAs module: ' + ne.message);
+      }
     }
-  }
 
+    if (fileOptions && typeof fileOptions === 'object') {
+      minifyOptions = fileOptions;
+    }
+  }
   mainOptionKeys.forEach(function(key) {
     var paramKey = changeCase.paramCase(key);
     var value = options[paramKey];
@@ -179,6 +262,12 @@ cli.main(function(args, options) {
         case 'json':
           minifyOptions[key] = parseJSONOption(value);
           break;
+        case 'json-regex':
+          minifyOptions[key] = parseJSONOption(value, { regexArray: true });
+          break;
+        case 'string-regex':
+          minifyOptions[key] = stringToRegExp(value);
+          break;
         case true:
           minifyOptions[key] = value;
           break;
@@ -196,6 +285,42 @@ cli.main(function(args, options) {
     input = args;
   }
 
+  if (options['input-dir'] || options['output-dir']) {
+    var inputDir = options['input-dir'];
+    var outputDir = options['output-dir'];
+
+    if (!inputDir) {
+      cli.error('The option output-dir need to be use with the option include-dir. If you are working with only 1 file, use -o.');
+      cli.exit(2);
+    }
+
+    try {
+      fs.statSync(inputDir);
+    }
+    catch (e) {
+      cli.error('The input directory does not exits');
+      cli.exit(2);
+    }
+
+
+    if (!outputDir) {
+      cli.error('You need to specify where to write the output files with the option --output-dir');
+      cli.exit(2);
+    }
+
+    try {
+      processDirectory(inputDir, outputDir);
+    }
+    catch (e) {
+      cli.error('Something wrong happened');
+      cli.error(e);
+      cli.exit(3);
+    }
+
+    cli.exit(0);
+    return;
+  }
+
   if (options.output) {
     output = options.output;
   }
@@ -209,16 +334,15 @@ cli.main(function(args, options) {
         original += fs.readFileSync(afile, 'utf8');
       }
       catch (e) {
-        process.stderr.write('Error: Cannot read file ' + afile);
+        cli.error('Cannot read file ' + afile);
         cli.exit(2);
       }
     });
 
-    runMinify(original);
+    runMinify(original, output);
 
   }
   else { // Minifying input coming from STDIN
     process.stdin.pipe(concat({ encoding: 'string' }, runMinify));
   }
-
 });

package/dist/htmlminifier.js

@@ -1,7 +1,7 @@
 /*!
- * HTMLMinifier v0.7.2 (http://kangax.github.io/html-minifier/)
- * Copyright 2010-2015 Juriy "kangax" Zaytsev
- * Licensed under MIT (https://github.com/kangax/html-minifier/blob/gh-pages/LICENSE)
+ * HTMLMinifier v1.1.1 (http://kangax.github.io/html-minifier/)
+ * Copyright 2010-2016 Juriy "kangax" Zaytsev
+ * Licensed under the MIT license
  */
 /*!
  * HTML Parser By John Resig (ejohn.org)
@@ -73,7 +73,7 @@
   var fillAttrs = makeMap('checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected');
 
   // Special Elements (can contain anything)
-  var special = makeMap('script,style,noscript');
+  var special = makeMap('script,style');
 
   var reCache = {}, stackedTag, reStackedTag, tagMatch;
 
@@ -622,12 +622,12 @@
     lineBreakStamp = 'htmlmincollapsedlinebreak';
 
     if (prevTag && prevTag !== 'img' && prevTag !== 'input' && (prevTag.substr(0, 1) !== '/'
-      || (prevTag.substr(0, 1) === '/' && tags.indexOf(prevTag.substr(1)) === -1))) {
+      || (prevTag.substr(0, 1) === '/' && (options.collapseInlineTagWhitespace || tags.indexOf(prevTag.substr(1)) === -1)))) {
       str = str.replace(/^\s+/, options.conservativeCollapse ? ' ' : options.preserveLineBreaks ? preserveBefore : '');
     }
 
     if (nextTag && nextTag !== 'img' && nextTag !== 'input' && (nextTag.substr(0, 1) === '/'
-      || (nextTag.substr(0, 1) !== '/' && tags.indexOf(nextTag) === -1))) {
+      || (nextTag.substr(0, 1) !== '/' && (options.collapseInlineTagWhitespace || tags.indexOf(nextTag) === -1)))) {
       str = str.replace(/\s+$/, options.conservativeCollapse ? ' ' : options.preserveLineBreaks ? preserveAfter : '');
     }
 
@@ -652,7 +652,7 @@
   }
 
   function isIgnoredComment(text, options) {
-    if ((/^!/).test(text)) {
+    if ((/^!/).test(text) || /\s*htmlmin:temp/.test(text)) {
       return true;
     }
 
@@ -671,11 +671,11 @@
     return (/^on[a-z]+/).test(attrName);
   }
 
-  function canRemoveAttributeQuotes(value) {
+  function canRemoveAttributeQuotes(value, isLast) {
     // http://mathiasbynens.be/notes/unquoted-attribute-values
-    return (/^[^\x20\t\n\f\r"'`=<>]+$/).test(value) && !(/\/$/).test(value) &&
-    // make sure trailing slash is not interpreted as HTML self-closing tag
-        !(/\/$/).test(value);
+    return (/^[^\x20\t\n\f\r"'`=<>]+$/).test(value) &&
+           // make sure trailing slash is not interpreted as HTML self-closing tag
+           !(isLast && (/\/$/).test(value));
   }
 
   function attributesInclude(attributes, attribute) {
@@ -841,7 +841,7 @@
       attrValue = attrValue.replace(/1\.0/g, '1').replace(/\s+/g, '');
     }
     else if (attrValue && options.customAttrCollapse && options.customAttrCollapse.test(attrName)) {
-      attrValue = attrValue.replace(/\n+/g, '');
+      attrValue = attrValue.replace(/\n+|\r+|\s{2,}/g, '');
     }
     return attrValue;
   }
@@ -911,7 +911,7 @@
   }
 
   function isOptionalTag(tag) {
-    return (/^(?:html|t?body|t?head|tfoot|tr|td|th|dt|dd|option|colgroup|source)$/).test(tag);
+    return (/^(?:html|t?body|t?head|tfoot|tr|td|th|dt|dd|option|colgroup|source|track)$/).test(tag);
   }
 
   var reEmptyAttribute = new RegExp(
@@ -952,19 +952,11 @@
     return !(/^(?:pre|textarea)$/.test(tag));
   }
 
-  function attrsToMarkup(attrs) {
-    var markup = '';
-    for (var i = 0, len = attrs.length; i < len; i++) {
-      markup += (' ' + attrs[i].name + (isBooleanAttribute(attrs[i].value) ? '' : ('="' + attrs[i].value + '"')));
-    }
-    return markup;
-  }
-
-  function normalizeAttribute(attr, attrs, tag, unarySlash, index, options) {
+  function normalizeAttribute(attr, attrs, tag, unarySlash, index, options, isLast) {
 
     var attrName = options.caseSensitive ? attr.name : attr.name.toLowerCase(),
         attrValue = options.preventAttributesEscaping ? attr.value : attr.escaped,
-        attrQuote = options.preventAttributesEscaping ? attr.quote : '"',
+        attrQuote = options.preventAttributesEscaping ? attr.quote : (options.quoteCharacter === '\'' ? '\'' : '"'),
         attrFragment,
         emittedAttrValue,
         isTerminalOfUnarySlash = unarySlash && index === attrs.length - 1;
@@ -983,7 +975,7 @@
     attrValue = cleanAttributeValue(tag, attrName, attrValue, options, attrs);
 
     if (attrValue !== undefined && !options.removeAttributeQuotes ||
-        !canRemoveAttributeQuotes(attrValue) || isTerminalOfUnarySlash) {
+        !canRemoveAttributeQuotes(attrValue, isLast) || isTerminalOfUnarySlash) {
       emittedAttrValue = attrQuote + attrValue + attrQuote;
     }
     else {
@@ -1151,15 +1143,37 @@
         stackNoTrimWhitespace = [],
         stackNoCollapseWhitespace = [],
         lint = options.lint,
-        isIgnoring = false,
-        t = new Date();
+        t = new Date(),
+        ignoredMarkupChunks = [ ],
+        ignoredCustomMarkupChunks = [ ],
+        reIgnore = /<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g,
+        uidAttr = ' htmlmin' + (Math.random() + '').slice(2) + ' ',
+        reCustomIgnore,
+        customFragments;
+
+    if (options.ignoreCustomFragments) {
+
+      customFragments = options.ignoreCustomFragments.map(function(re) {
+        return re.source;
+      });
+      reCustomIgnore = new RegExp('(?:' + customFragments.join('|') + ')', 'g');
 
-    if (options.removeIgnored) {
-      value = value
-        .replace(/<\?[^\?]+\?>/g, '')
-        .replace(/<%[^%]+%>/g, '');
+      // temporarily replace custom ignored fragments with unique attributes
+      value = value.replace(reCustomIgnore, function(match) {
+        ignoredCustomMarkupChunks.push(match);
+        return uidAttr;
+      });
     }
 
+    // temporarily replace ignored chunks with comments,
+    // so that we don't have to worry what's there.
+    // for all we care there might be
+    // completely-horribly-broken-alien-non-html-emoj-cthulhu-filled content
+    value = value.replace(reIgnore, function(match, group1) {
+      ignoredMarkupChunks.push(group1);
+      return '<!-- htmlmin:temp -->';
+    });
+
     function _canCollapseWhitespace(tag, attrs) {
       return canCollapseWhitespace(tag) || options.canCollapseWhitespace(tag, attrs);
     }
@@ -1172,10 +1186,6 @@
       html5: typeof options.html5 !== 'undefined' ? options.html5 : true,
 
       start: function(tag, attrs, unary, unarySlash) {
-        if (isIgnoring) {
-          buffer.push('<' + tag, attrsToMarkup(attrs), unarySlash ? '/' : '', '>');
-          return;
-        }
 
         var lowerTag = tag.toLowerCase();
 
@@ -1218,13 +1228,14 @@
           lint.testElement(tag);
         }
 
-        var token;
+        var token, isLast;
         for (var i = 0, len = attrs.length; i < len; i++) {
+          isLast = i === len - 1;
           if (lint) {
             lint.testAttribute(tag, attrs[i].name.toLowerCase(), attrs[i].escaped);
           }
-          token = normalizeAttribute(attrs[i], attrs, tag, unarySlash, i, options);
-          if (i === len - 1) {
+          token = normalizeAttribute(attrs[i], attrs, tag, unarySlash, i, options, isLast);
+          if (isLast) {
             token += closeTag;
           }
           buffer.push(token);
@@ -1232,11 +1243,6 @@
       },
       end: function(tag, attrs) {
 
-        if (isIgnoring) {
-          buffer.push('</' + tag + '>');
-          return;
-        }
-
         var lowerTag = tag.toLowerCase();
         if (lowerTag === 'svg') {
           options = optionsStack.pop();
@@ -1282,11 +1288,6 @@
         prevTag = prevTag === '' ? 'comment' : prevTag;
         nextTag = nextTag === '' ? 'comment' : nextTag;
 
-        if (isIgnoring) {
-          buffer.push(text);
-          return;
-        }
-
         if (currentTag === 'script' || currentTag === 'style') {
           if (options.removeCommentsFromCDATA) {
             text = removeComments(text, currentTag);
@@ -1325,13 +1326,6 @@
         var prefix = nonStandard ? '<!' : '<!--';
         var suffix = nonStandard ? '>' : '-->';
 
-        if (/^\s*htmlmin:ignore/.test(text)) {
-          isIgnoring = !isIgnoring;
-          if (!options.removeComments) {
-            buffer.push('<!--' + text + '-->');
-          }
-          return;
-        }
         if (options.removeComments) {
           if (isConditionalComment(text)) {
             text = prefix + cleanConditionalComment(text) + suffix;
@@ -1357,6 +1351,16 @@
 
     results.push.apply(results, buffer);
     var str = joinResultSegments(results, options);
+
+    var customIgnoreRe = new RegExp('\\s*' + trimWhitespace(uidAttr) + '\\s*', 'g');
+
+    str = str.replace(customIgnoreRe, function() {
+      return ignoredCustomMarkupChunks.shift();
+    });
+    str = str.replace(/<!-- htmlmin:temp -->/g, function() {
+      return ignoredMarkupChunks.shift();
+    });
+
     log('minified in: ' + (new Date() - t) + 'ms');
     return str;
   }
@@ -1397,7 +1401,7 @@
     global.minify = minify;
   }
 
-}(this));
+}(typeof exports === 'undefined' ? this : exports));
 
 /*!
  * HTMLLint (to be used in conjunction with HTMLMinifier)