html-minifier 1.4.0 → 1.5.0

package/src/htmlminifier.js

@@ -1,8 +1,10 @@
 'use strict';
 
 var CleanCSS = require('clean-css');
+var decode = require('he').decode;
 var HTMLParser = require('./htmlparser').HTMLParser;
 var RelateUrl = require('relateurl');
+var TokenChain = require('./tokenchain');
 var UglifyJS = require('uglify-js');
 var utils = require('./utils');
 
@@ -17,20 +19,17 @@ else {
   log = function() {};
 }
 
-var trimWhitespace = function(str) {
+var trimWhitespace = String.prototype.trim ? function(str) {
+  if (typeof str !== 'string') {
+    return str;
+  }
+  return str.trim();
+} : function(str) {
   if (typeof str !== 'string') {
     return str;
   }
   return str.replace(/^\s+/, '').replace(/\s+$/, '');
 };
-if (String.prototype.trim) {
-  trimWhitespace = function(str) {
-    if (typeof str !== 'string') {
-      return str;
-    }
-    return str.trim();
-  };
-}
 
 function compressWhitespace(spaces) {
   return spaces === '\t' ? spaces : ' ';
@@ -119,14 +118,12 @@ function isEventAttribute(attrName, options) {
     }
     return false;
   }
-  else {
-    return (/^on[a-z]{3,}$/).test(attrName);
-  }
+  return /^on[a-z]{3,}$/.test(attrName);
 }
 
 function canRemoveAttributeQuotes(value) {
   // http://mathiasbynens.be/notes/unquoted-attribute-values
-  return (/^[^\x20\t\n\f\r"'`=<>]+$/).test(value);
+  return /^[^ \t\n\f\r"'`=<>]+$/.test(value);
 }
 
 function attributesInclude(attributes, attribute) {
@@ -142,29 +139,29 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs) {
   attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : '';
 
   return (
-      (tag === 'script' &&
+      tag === 'script' &&
       attrName === 'language' &&
-      attrValue === 'javascript') ||
+      attrValue === 'javascript' ||
 
-      (tag === 'form' &&
+      tag === 'form' &&
       attrName === 'method' &&
-      attrValue === 'get') ||
+      attrValue === 'get' ||
 
-      (tag === 'input' &&
+      tag === 'input' &&
       attrName === 'type' &&
-      attrValue === 'text') ||
+      attrValue === 'text' ||
 
-      (tag === 'script' &&
+      tag === 'script' &&
       attrName === 'charset' &&
-      !attributesInclude(attrs, 'src')) ||
+      !attributesInclude(attrs, 'src') ||
 
-      (tag === 'a' &&
+      tag === 'a' &&
       attrName === 'name' &&
-      attributesInclude(attrs, 'id')) ||
+      attributesInclude(attrs, 'id') ||
 
-      (tag === 'area' &&
+      tag === 'area' &&
       attrName === 'shape' &&
-      attrValue === 'rect')
+      attrValue === 'rect'
   );
 }
 
@@ -179,12 +176,9 @@ var executableScriptsMimetypes = utils.createMap([
   'application/ecmascript'
 ]);
 
-function isScriptTypeAttribute(tag, attrName, attrValue) {
-  return (
-    tag === 'script' &&
-    attrName === 'type' &&
-    executableScriptsMimetypes(trimWhitespace(attrValue.toLowerCase()))
-  );
+function isScriptTypeAttribute(attrValue) {
+  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
+  return attrValue === '' || executableScriptsMimetypes(attrValue);
 }
 
 function isExecutableScript(tag, attrs) {
@@ -194,13 +188,17 @@ function isExecutableScript(tag, attrs) {
   for (var i = 0, len = attrs.length; i < len; i++) {
     var attrName = attrs[i].name.toLowerCase();
     if (attrName === 'type') {
-      var attrValue = trimWhitespace(attrs[i].value.split(/;/, 2)[0]).toLowerCase();
-      return attrValue === '' || executableScriptsMimetypes(attrValue);
+      return isScriptTypeAttribute(attrs[i].value);
     }
   }
   return true;
 }
 
+function isStyleLinkTypeAttribute(attrValue) {
+  attrValue = trimWhitespace(attrValue).toLowerCase();
+  return attrValue === '' || attrValue === 'text/css';
+}
+
 function isStyleSheet(tag, attrs) {
   if (tag !== 'style') {
     return false;
@@ -208,21 +206,12 @@ function isStyleSheet(tag, attrs) {
   for (var i = 0, len = attrs.length; i < len; i++) {
     var attrName = attrs[i].name.toLowerCase();
     if (attrName === 'type') {
-      var attrValue = trimWhitespace(attrs[i].value).toLowerCase();
-      return attrValue === '' || attrValue === 'text/css';
+      return isStyleLinkTypeAttribute(attrs[i].value);
     }
   }
   return true;
 }
 
-function isStyleLinkTypeAttribute(tag, attrName, attrValue) {
-  return (
-    (tag === 'style' || tag === 'link') &&
-    attrName === 'type' &&
-    trimWhitespace(attrValue.toLowerCase()) === 'text/css'
-  );
-}
-
 var isSimpleBoolean = createMapFromString('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');
 var isBooleanValue = createMapFromString('true,false');
 
@@ -232,28 +221,28 @@ function isBooleanAttribute(attrName, attrValue) {
 
 function isUriTypeAttribute(attrName, tag) {
   return (
-    ((/^(?:a|area|link|base)$/).test(tag) && attrName === 'href') ||
-    (tag === 'img' && (/^(?:src|longdesc|usemap)$/).test(attrName)) ||
-    (tag === 'object' && (/^(?:classid|codebase|data|usemap)$/).test(attrName)) ||
-    (tag === 'q' && attrName === 'cite') ||
-    (tag === 'blockquote' && attrName === 'cite') ||
-    ((tag === 'ins' || tag === 'del') && attrName === 'cite') ||
-    (tag === 'form' && attrName === 'action') ||
-    (tag === 'input' && (attrName === 'src' || attrName === 'usemap')) ||
-    (tag === 'head' && attrName === 'profile') ||
-    (tag === 'script' && (attrName === 'src' || attrName === 'for'))
+    /^(?:a|area|link|base)$/.test(tag) && attrName === 'href' ||
+    tag === 'img' && /^(?:src|longdesc|usemap)$/.test(attrName) ||
+    tag === 'object' && /^(?:classid|codebase|data|usemap)$/.test(attrName) ||
+    tag === 'q' && attrName === 'cite' ||
+    tag === 'blockquote' && attrName === 'cite' ||
+    (tag === 'ins' || tag === 'del') && attrName === 'cite' ||
+    tag === 'form' && attrName === 'action' ||
+    tag === 'input' && (attrName === 'src' || attrName === 'usemap') ||
+    tag === 'head' && attrName === 'profile' ||
+    tag === 'script' && (attrName === 'src' || attrName === 'for')
   );
 }
 
 function isNumberTypeAttribute(attrName, tag) {
   return (
-    ((/^(?:a|area|object|button)$/).test(tag) && attrName === 'tabindex') ||
-    (tag === 'input' && (attrName === 'maxlength' || attrName === 'tabindex')) ||
-    (tag === 'select' && (attrName === 'size' || attrName === 'tabindex')) ||
-    (tag === 'textarea' && (/^(?:rows|cols|tabindex)$/).test(attrName)) ||
-    (tag === 'colgroup' && attrName === 'span') ||
-    (tag === 'col' && attrName === 'span') ||
-    ((tag === 'th' || tag === 'td') && (attrName === 'rowspan' || attrName === 'colspan'))
+    /^(?:a|area|object|button)$/.test(tag) && attrName === 'tabindex' ||
+    tag === 'input' && (attrName === 'maxlength' || attrName === 'tabindex') ||
+    tag === 'select' && (attrName === 'size' || attrName === 'tabindex') ||
+    tag === 'textarea' && /^(?:rows|cols|tabindex)$/.test(attrName) ||
+    tag === 'colgroup' && attrName === 'span' ||
+    tag === 'col' && attrName === 'span' ||
+    (tag === 'th' || tag === 'td') && (attrName === 'rowspan' || attrName === 'colspan')
   );
 }
 
@@ -281,7 +270,14 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
     return attrValue;
   }
   else if (attrName === 'class') {
-    return collapseWhitespaceAll(trimWhitespace(attrValue));
+    attrValue = trimWhitespace(attrValue);
+    if (options.sortClassName) {
+      attrValue = options.sortClassName(attrValue);
+    }
+    else {
+      attrValue = collapseWhitespaceAll(attrValue);
+    }
+    return attrValue;
   }
   else if (isUriTypeAttribute(attrName, tag)) {
     attrValue = trimWhitespace(attrValue);
@@ -295,8 +291,8 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   }
   else if (attrName === 'style') {
     attrValue = trimWhitespace(attrValue);
-    if (attrValue) {
-      attrValue = attrValue.replace(/\s*;\s*$/, '');
+    if (attrValue && /;$/.test(attrValue) && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
+      attrValue = attrValue.replace(/\s*;$/, '');
     }
     if (options.minifyCSS) {
       return minifyCSS(attrValue, options.minifyCSS, true);
@@ -342,9 +338,7 @@ function unwrapCSS(text) {
   if (matches && matches[1]) {
     return matches[1];
   }
-  else {
-    return text;
-  }
+  return text;
 }
 
 function cleanConditionalComment(comment, options) {
@@ -453,11 +447,9 @@ var reEmptyAttribute = new RegExp(
     '?:down|up|over|move|out)|key(?:press|down|up)))$');
 
 function canDeleteEmptyAttribute(tag, attrName, attrValue) {
-  var isValueEmpty = !attrValue || (/^\s*$/).test(attrValue);
+  var isValueEmpty = !attrValue || /^\s*$/.test(attrValue);
   if (isValueEmpty) {
-    return (
-      (tag === 'input' && attrName === 'value') ||
-      reEmptyAttribute.test(attrName));
+    return tag === 'input' && attrName === 'value' || reEmptyAttribute.test(attrName);
   }
   return false;
 }
@@ -502,50 +494,67 @@ function canRemoveElement(tag, attrs) {
 }
 
 function canCollapseWhitespace(tag) {
-  return !(/^(?:script|style|pre|textarea)$/.test(tag));
+  return !/^(?:script|style|pre|textarea)$/.test(tag);
 }
 
 function canTrimWhitespace(tag) {
-  return !(/^(?:pre|textarea)$/.test(tag));
+  return !/^(?:pre|textarea)$/.test(tag);
 }
 
-function normalizeAttribute(attr, attrs, tag, hasUnarySlash, index, options, isLast) {
-
+function normalizeAttr(attr, attrs, tag, options) {
   var attrName = options.caseSensitive ? attr.name : attr.name.toLowerCase(),
-      attrValue = attr.value,
-      attrQuote = attr.quote,
-      attrFragment,
-      emittedAttrValue;
+      attrValue = attr.value;
 
-  if ((options.removeRedundantAttributes &&
-    isAttributeRedundant(tag, attrName, attrValue, attrs))
-    ||
-    (options.removeScriptTypeAttributes &&
-    isScriptTypeAttribute(tag, attrName, attrValue))
-    ||
-    (options.removeStyleLinkTypeAttributes &&
-    isStyleLinkTypeAttribute(tag, attrName, attrValue))) {
-    return '';
+  if (options.decodeEntities && attrValue) {
+    attrValue = decode(attrValue, { isAttributeValue: true });
+  }
+
+  if (options.removeRedundantAttributes &&
+    isAttributeRedundant(tag, attrName, attrValue, attrs) ||
+    options.removeScriptTypeAttributes && tag === 'script' &&
+    attrName === 'type' && isScriptTypeAttribute(attrValue) ||
+    options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
+    attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) {
+    return;
   }
 
   attrValue = cleanAttributeValue(tag, attrName, attrValue, options, attrs);
 
   if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue)) {
-    return '';
+    return;
   }
 
-  if (attrValue !== undefined && !options.removeAttributeQuotes ||
+  if (options.decodeEntities && attrValue) {
+    attrValue = attrValue.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp;$1');
+  }
+
+  return {
+    attr: attr,
+    name: attrName,
+    value: attrValue
+  };
+}
+
+function buildAttr(normalized, hasUnarySlash, options, isLast) {
+  var attrName = normalized.name,
+      attrValue = normalized.value,
+      attr = normalized.attr,
+      attrQuote = attr.quote,
+      attrFragment,
+      emittedAttrValue;
+
+  if (typeof attrValue !== 'undefined' && !options.removeAttributeQuotes ||
       !canRemoveAttributeQuotes(attrValue)) {
     if (!options.preventAttributesEscaping) {
-      if (options.quoteCharacter !== undefined) {
-        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
-      }
-      else {
+      if (typeof options.quoteCharacter === 'undefined') {
         var apos = (attrValue.match(/'/g) || []).length;
         var quot = (attrValue.match(/"/g) || []).length;
         attrQuote = apos < quot ? '\'' : '"';
       }
+      else {
+        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+      }
       if (attrQuote === '"') {
         attrValue = attrValue.replace(/"/g, '&#34;');
       }
@@ -566,8 +575,8 @@ function normalizeAttribute(attr, attrs, tag, hasUnarySlash, index, options, isL
     emittedAttrValue = attrValue + ' ';
   }
 
-  if (attrValue === undefined || (options.collapseBooleanAttributes &&
-      isBooleanAttribute(attrName.toLowerCase(), attrValue.toLowerCase()))) {
+  if (typeof attrValue === 'undefined' || options.collapseBooleanAttributes &&
+      isBooleanAttribute(attrName.toLowerCase(), attrValue.toLowerCase())) {
     attrFragment = attrName;
     if (!isLast) {
       attrFragment += ' ';
@@ -646,9 +655,7 @@ function minifyCSS(text, options, inline) {
     if (inline) {
       return unwrapCSS(cleanCSS.minify(wrapCSS(style)).styles);
     }
-    else {
-      return cleanCSS.minify(style).styles;
-    }
+    return cleanCSS.minify(style).styles;
   }
   catch (err) {
     log(err);
@@ -664,13 +671,96 @@ function uniqueId(value) {
   return id;
 }
 
+var specialContentTags = createMapFromString('script,style');
+
+function createSortFns(value, options, uidIgnore, uidAttr) {
+  var attrChains = options.sortAttributes && Object.create(null);
+  var classChain = options.sortClassName && new TokenChain();
+
+  function attrNames(attrs) {
+    return attrs.map(function(attr) {
+      return options.caseSensitive ? attr.name : attr.name.toLowerCase();
+    });
+  }
+
+  function shouldSkipUID(token, uid) {
+    return !uid || token.indexOf(uid) === -1;
+  }
+
+  function shouldSkipUIDs(token) {
+    return shouldSkipUID(token, uidIgnore) && shouldSkipUID(token, uidAttr);
+  }
+
+  function scan(input) {
+    var currentTag, currentType;
+    new HTMLParser(input, {
+      start: function(tag, attrs) {
+        if (attrChains) {
+          if (!attrChains[tag]) {
+            attrChains[tag] = new TokenChain();
+          }
+          attrChains[tag].add(attrNames(attrs).filter(shouldSkipUIDs));
+        }
+        for (var i = 0, len = attrs.length; i < len; i++) {
+          var attr = attrs[i];
+          if (classChain && (options.caseSensitive ? attr.name : attr.name.toLowerCase()) === 'class') {
+            classChain.add(trimWhitespace(attr.value).split(/\s+/).filter(shouldSkipUIDs));
+          }
+          else if (options.processScripts && attr.name.toLowerCase() === 'type') {
+            currentTag = tag;
+            currentType = attr.value;
+          }
+        }
+      },
+      end: function() {
+        currentTag = '';
+      },
+      chars: function(text) {
+        if (options.processScripts && specialContentTags(currentTag) &&
+            options.processScripts.indexOf(currentType) > -1) {
+          scan(text);
+        }
+      }
+    });
+  }
+
+  options.sortAttributes = false;
+  options.sortClassName = false;
+  scan(minify(value, options));
+  if (attrChains) {
+    var attrSorters = Object.create(null);
+    for (var tag in attrChains) {
+      attrSorters[tag] = attrChains[tag].createSorter();
+    }
+    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(/\s+/)).join(' ');
+    };
+  }
+}
+
 function minify(value, options, partialMarkup) {
   options = options || {};
   var optionsStack = [];
   processOptions(options);
   value = options.collapseWhitespace ? trimWhitespace(value) : value;
 
-  var buffer = [ ],
+  var buffer = [],
       charsPrevTag,
       currentChars = '',
       hasChars,
@@ -682,8 +772,8 @@ function minify(value, options, partialMarkup) {
       optionalEndTag = '',
       lint = options.lint,
       t = Date.now(),
-      ignoredMarkupChunks = [ ],
-      ignoredCustomMarkupChunks = [ ],
+      ignoredMarkupChunks = [],
+      ignoredCustomMarkupChunks = [],
       uidIgnore,
       uidAttr;
 
@@ -719,6 +809,12 @@ function minify(value, options, partialMarkup) {
     });
   }
 
+  if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||
+      options.sortClassName && typeof options.sortClassName !== 'function') {
+    createSortFns(value, options, uidIgnore, uidAttr);
+    lint = null;
+  }
+
   function _canCollapseWhitespace(tag, attrs) {
     return canCollapseWhitespace(tag) || options.canCollapseWhitespace(tag, attrs);
   }
@@ -764,7 +860,7 @@ function minify(value, options, partialMarkup) {
 
   new HTMLParser(value, {
     partialMarkup: partialMarkup,
-    html5: typeof options.html5 !== 'undefined' ? options.html5 : true,
+    html5: typeof options.html5 === 'undefined' ? true : options.html5,
 
     start: function(tag, attrs, unary, unarySlash, autoGenerated) {
       var lowerTag = tag.toLowerCase();
@@ -834,16 +930,20 @@ function minify(value, options, partialMarkup) {
         lint.testElement(tag);
       }
 
-      var parts = [ ];
-      var token, isLast = true;
-      for (var i = attrs.length; --i >= 0; ) {
+      if (options.sortAttributes) {
+        options.sortAttributes(tag, attrs);
+      }
+
+      var parts = [];
+      for (var i = attrs.length, isLast = true; --i >= 0;) {
+        var attr = attrs[i];
         if (lint) {
-          lint.testAttribute(tag, attrs[i].name.toLowerCase(), attrs[i].value);
+          lint.testAttribute(tag, attr.name.toLowerCase(), attr.value);
         }
-        token = normalizeAttribute(attrs[i], attrs, tag, hasUnarySlash, i, options, isLast);
-        if (token) {
+        var normalized = normalizeAttr(attr, attrs, tag, options);
+        if (normalized) {
+          parts.unshift(buildAttr(normalized, hasUnarySlash, options, isLast));
           isLast = false;
-          parts.unshift(token);
         }
       }
       if (parts.length > 0) {
@@ -928,6 +1028,9 @@ function minify(value, options, partialMarkup) {
     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') {
@@ -964,12 +1067,12 @@ function minify(value, options, partialMarkup) {
           text = prevTag && nextTag || nextTag === 'html' ? text : collapseWhitespaceAll(text);
         }
       }
-      if (options.processScripts && (currentTag === 'script' || currentTag === 'style')) {
+      if (options.processScripts && specialContentTags(currentTag)) {
         text = processScript(text, options, currentAttrs);
       }
       if (options.minifyJS && isExecutableScript(currentTag, currentAttrs)) {
         text = minifyJS(text, options.minifyJS);
-        if (text.charAt(text.length - 1) === ';') {
+        if (/;$/.test(text)) {
           text = text.slice(0, -1);
         }
       }
@@ -991,6 +1094,11 @@ function minify(value, options, partialMarkup) {
         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;');
+      }
       currentChars += text;
       if (text) {
         hasChars = true;
@@ -1025,6 +1133,9 @@ function minify(value, options, partialMarkup) {
       buffer.push(text);
     },
     doctype: function(doctype) {
+      if (lint) {
+        lint.testDoctype(doctype);
+      }
       buffer.push(options.useShortDoctype ? '<!DOCTYPE html>' : collapseWhitespaceAll(doctype));
     },
     customAttrAssign: options.customAttrAssign,
@@ -1060,9 +1171,7 @@ function minify(value, options, partialMarkup) {
           conservativeCollapse: true
         }, /^\s/.test(chunk), /\s$/.test(chunk));
       }
-      else {
-        return chunk;
-      }
+      return chunk;
     });
   }
   if (uidIgnore) {