html-minifier 1.4.0 → 1.5.0

package/src/htmlparser.js

@@ -39,7 +39,7 @@ function makeMap(values) {
 // Regular Expressions for parsing tags and attributes
 var singleAttrIdentifier = /([^\s"'<>\/=]+)/,
     singleAttrAssign = /=/,
-    singleAttrAssigns = [ singleAttrAssign ],
+    singleAttrAssigns = [singleAttrAssign],
     singleAttrValues = [
       // attr value double quotes
       /"([^"]*)"+/.source,
@@ -86,17 +86,17 @@ var nonPhrasing = makeMap('address,article,aside,base,blockquote,body,caption,co
 var reCache = {};
 
 function attrForHandler(handler) {
-  var pattern = singleAttrIdentifier.source
-    + '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')'
-    + '\\s*(?:' + singleAttrValues.join('|') + '))?';
+  var pattern = singleAttrIdentifier.source +
+                '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
+                '\\s*(?:' + singleAttrValues.join('|') + '))?';
   if (handler.customAttrSurround) {
     var attrClauses = [];
-    for ( var i = handler.customAttrSurround.length - 1; i >= 0; i-- ) {
-      attrClauses[i] = '(?:'
-        + '(' + handler.customAttrSurround[i][0].source + ')\\s*'
-        + pattern
-        + '\\s*(' + handler.customAttrSurround[i][1].source + ')'
-        + ')';
+    for (var i = handler.customAttrSurround.length - 1; i >= 0; i--) {
+      attrClauses[i] = '(?:' +
+                       '(' + handler.customAttrSurround[i][0].source + ')\\s*' +
+                       pattern +
+                       '\\s*(' + handler.customAttrSurround[i][1].source + ')' +
+                       ')';
     }
     attrClauses.push('(?:' + pattern + ')');
     pattern = '(?:' + attrClauses.join('|') + ')';
@@ -104,75 +104,75 @@ function attrForHandler(handler) {
   return new RegExp('^\\s*' + pattern);
 }
 
-function joinSingleAttrAssigns( handler ) {
+function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
-  ).map(function (assign) {
+  ).map(function(assign) {
     return '(?:' + assign.source + ')';
   }).join('|');
 }
 
-function HTMLParser( html, handler ) {
+function HTMLParser(html, handler) {
   var stack = [], lastTag;
   var attribute = attrForHandler(handler);
   var last, prevTag, nextTag;
-  while ( html ) {
+  while (html) {
     last = html;
     // Make sure we're not in a script or style element
-    if ( !lastTag || !special(lastTag) ) {
+    if (!lastTag || !special(lastTag)) {
       var textEnd = html.indexOf('<');
       if (textEnd === 0) {
         // Comment:
-        if ( /^<!--/.test( html ) ) {
+        if (/^<!--/.test(html)) {
           var commentEnd = html.indexOf('-->');
 
-          if ( commentEnd >= 0 ) {
-            if ( handler.comment ) {
-              handler.comment( html.substring( 4, commentEnd ) );
+          if (commentEnd >= 0) {
+            if (handler.comment) {
+              handler.comment(html.substring(4, commentEnd));
             }
-            html = html.substring( commentEnd + 3 );
+            html = html.substring(commentEnd + 3);
             prevTag = '';
             continue;
           }
         }
 
         // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if ( /^<!\[/.test( html ) ) {
+        if (/^<!\[/.test(html)) {
           var conditionalEnd = html.indexOf(']>');
 
           if (conditionalEnd >= 0) {
-            if ( handler.comment ) {
-              handler.comment( html.substring(2, conditionalEnd + 1 ), true /* non-standard */ );
+            if (handler.comment) {
+              handler.comment(html.substring(2, conditionalEnd + 1), true /* non-standard */);
             }
-            html = html.substring( conditionalEnd + 2 );
+            html = html.substring(conditionalEnd + 2);
             prevTag = '';
             continue;
           }
         }
 
         // Doctype:
-        var doctypeMatch = html.match( doctype );
-        if ( doctypeMatch ) {
-          if ( handler.doctype ) {
-            handler.doctype( doctypeMatch[0] );
+        var doctypeMatch = html.match(doctype);
+        if (doctypeMatch) {
+          if (handler.doctype) {
+            handler.doctype(doctypeMatch[0]);
           }
-          html = html.substring( doctypeMatch[0].length );
+          html = html.substring(doctypeMatch[0].length);
           prevTag = '';
           continue;
         }
 
         // End tag:
-        var endTagMatch = html.match( endTag );
-        if ( endTagMatch ) {
-          html = html.substring( endTagMatch[0].length );
-          endTagMatch[0].replace( endTag, parseEndTag );
+        var endTagMatch = html.match(endTag);
+        if (endTagMatch) {
+          html = html.substring(endTagMatch[0].length);
+          endTagMatch[0].replace(endTag, parseEndTag);
           prevTag = '/' + endTagMatch[1].toLowerCase();
           continue;
         }
 
         // Start tag:
         var startTagMatch = parseStartTag(html);
-        if ( startTagMatch ) {
+        if (startTagMatch) {
           html = startTagMatch.rest;
           handleStartTag(startTagMatch);
           prevTag = startTagMatch.tagName.toLowerCase();
@@ -182,8 +182,8 @@ function HTMLParser( html, handler ) {
 
       var text;
       if (textEnd >= 0) {
-        text = html.substring( 0, textEnd );
-        html = html.substring( textEnd );
+        text = html.substring(0, textEnd);
+        html = html.substring(textEnd);
       }
       else {
         text = html;
@@ -196,7 +196,7 @@ function HTMLParser( html, handler ) {
         nextTag = nextTagMatch.tagName;
       }
       else {
-        nextTagMatch = html.match( endTag );
+        nextTagMatch = html.match(endTag);
         if (nextTagMatch) {
           nextTag = '/' + nextTagMatch[1];
         }
@@ -205,7 +205,7 @@ function HTMLParser( html, handler ) {
         }
       }
 
-      if ( handler.chars ) {
+      if (handler.chars) {
         handler.chars(text, prevTag, nextTag);
       }
       prevTag = '';
@@ -213,7 +213,7 @@ function HTMLParser( html, handler ) {
     }
     else {
       var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)<\/' + stackedTag + '[^>]*>', 'i'));
+      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') {
@@ -222,17 +222,17 @@ function HTMLParser( html, handler ) {
             .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1');
         }
 
-        if ( handler.chars ) {
-          handler.chars( text );
+        if (handler.chars) {
+          handler.chars(text);
         }
 
         return '';
       });
 
-      parseEndTag( '</' + stackedTag + '>', stackedTag );
+      parseEndTag('</' + stackedTag + '>', stackedTag);
     }
 
-    if ( html === last ) {
+    if (html === last) {
       throw new Error('Parse Error: ' + html);
     }
   }
@@ -268,41 +268,55 @@ function HTMLParser( html, handler ) {
     var unarySlash = match.unarySlash;
 
     if (handler.html5 && lastTag === 'p' && nonPhrasing(tagName)) {
-      parseEndTag( '', lastTag );
+      parseEndTag('', lastTag);
     }
 
     if (!handler.html5) {
       while (lastTag && inline(lastTag)) {
-        parseEndTag( '', lastTag );
+        parseEndTag('', lastTag);
       }
     }
 
-    if ( closeSelf(tagName) && lastTag === tagName ) {
-      parseEndTag( '', tagName );
+    if (closeSelf(tagName) && lastTag === tagName) {
+      parseEndTag('', tagName);
     }
 
     var unary = empty(tagName) || tagName === 'html' && lastTag === 'head' || !!unarySlash;
 
     var attrs = match.attrs.map(function(args) {
-      var name, value, fallbackValue, customOpen, customClose, customAssign, quote;
+      var name, value, customOpen, customClose, customAssign, quote;
       var ncp = 7; // number of captured parts, scalar
 
       // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
       if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
-        if (args[3] === '') { args[3] = undefined; }
-        if (args[4] === '') { args[4] = undefined; }
-        if (args[5] === '') { args[5] = undefined; }
+        if (args[3] === '') { delete args[3]; }
+        if (args[4] === '') { delete args[4]; }
+        if (args[5] === '') { delete args[5]; }
+      }
+
+      function populate(index) {
+        customAssign = args[index];
+        value = args[index + 1];
+        if (typeof value !== 'undefined') {
+          return '"';
+        }
+        value = args[index + 2];
+        if (typeof value !== 'undefined') {
+          return '\'';
+        }
+        value = args[index + 3];
+        if (typeof value === 'undefined' && fillAttrs(name)) {
+          value = name;
+        }
+        return '';
       }
 
       var j = 1;
       if (handler.customAttrSurround) {
         for (var i = 0, l = handler.customAttrSurround.length; i < l; i++, j += ncp) {
           name = args[j + 1];
-          customAssign = args[j + 2];
           if (name) {
-            fallbackValue = args[j + 3];
-            value = fallbackValue || args[j + 4] || args[j + 5];
-            quote = fallbackValue ? '"' : value ? '\'' : '';
+            quote = populate(j + 2);
             customOpen = args[j];
             customClose = args[j + 6];
             break;
@@ -311,14 +325,7 @@ function HTMLParser( html, handler ) {
       }
 
       if (!name && (name = args[j])) {
-        customAssign = args[j + 1];
-        fallbackValue = args[j + 2];
-        value = fallbackValue || args[j + 3] || args[j + 4];
-        quote = fallbackValue ? '"' : value ? '\'' : '';
-      }
-
-      if (value === undefined) {
-        value = fillAttrs(name) ? name : fallbackValue;
+        quote = populate(j + 1);
       }
 
       return {
@@ -331,45 +338,45 @@ function HTMLParser( html, handler ) {
       };
     });
 
-    if ( !unary ) {
-      stack.push( { tag: tagName, attrs: attrs } );
+    if (!unary) {
+      stack.push({ tag: tagName, attrs: attrs });
       lastTag = tagName;
       unarySlash = '';
     }
 
-    if ( handler.start ) {
-      handler.start( tagName, attrs, unary, unarySlash );
+    if (handler.start) {
+      handler.start(tagName, attrs, unary, unarySlash);
     }
   }
 
-  function parseEndTag( tag, tagName ) {
+  function parseEndTag(tag, tagName) {
     var pos;
 
-    // If no tag name is provided, clean shop
-    if ( !tagName ) {
-      pos = 0;
-    }
-    else {
-      // Find the closest opened tag of the same type
+    // Find the closest opened tag of the same type
+    if (tagName) {
       var needle = tagName.toLowerCase();
-      for ( pos = stack.length - 1; pos >= 0; pos-- ) {
-        if ( stack[ pos ].tag.toLowerCase() === needle ) {
+      for (pos = stack.length - 1; pos >= 0; pos--) {
+        if (stack[pos].tag.toLowerCase() === needle) {
           break;
         }
       }
     }
+    // If no tag name is provided, clean shop
+    else {
+      pos = 0;
+    }
 
-    if ( pos >= 0 ) {
+    if (pos >= 0) {
       // Close all the open elements, up the stack
-      for ( var i = stack.length - 1; i >= pos; i-- ) {
-        if ( handler.end ) {
-          handler.end( stack[ i ].tag, stack[ i ].attrs, i > pos || !tag );
+      for (var i = stack.length - 1; i >= pos; i--) {
+        if (handler.end) {
+          handler.end(stack[i].tag, stack[i].attrs, i > pos || !tag);
         }
       }
 
       // Remove the open elements from the stack
       stack.length = pos;
-      lastTag = pos && stack[ pos - 1 ].tag;
+      lastTag = pos && stack[pos - 1].tag;
     }
     else if (tagName.toLowerCase() === 'br') {
       if (handler.start) {
@@ -388,26 +395,26 @@ function HTMLParser( html, handler ) {
 }
 
 exports.HTMLParser = HTMLParser;
-exports.HTMLtoXML = function( html ) {
+exports.HTMLtoXML = function(html) {
   var results = '';
 
   new HTMLParser(html, {
-    start: function( tag, attrs, unary ) {
+    start: function(tag, attrs, unary) {
       results += '<' + tag;
 
-      for ( var i = 0; i < attrs.length; i++ ) {
+      for (var i = 0, len = attrs.length; i < len; i++) {
         results += ' ' + attrs[i].name + '="' + (attrs[i].value || '').replace(/"/g, '&#34;') + '"';
       }
 
       results += (unary ? '/' : '') + '>';
     },
-    end: function( tag ) {
+    end: function(tag) {
       results += '</' + tag + '>';
     },
-    chars: function( text ) {
+    chars: function(text) {
       results += text;
     },
-    comment: function( text ) {
+    comment: function(text) {
       results += '<!--' + text + '-->';
     },
     ignore: function(text) {
@@ -418,7 +425,7 @@ exports.HTMLtoXML = function( html ) {
   return results;
 };
 
-exports.HTMLtoDOM = function( html, doc ) {
+exports.HTMLtoDOM = function(html, doc) {
   // There can be only one of these elements
   var one = {
     html: true,
@@ -433,22 +440,17 @@ exports.HTMLtoDOM = function( html, doc ) {
     base: 'head'
   };
 
-  if ( !doc ) {
-    if ( typeof DOMDocument !== 'undefined' ) {
-      doc = new DOMDocument();
-    }
-    else if ( typeof document !== 'undefined' && document.implementation && document.implementation.createDocument ) {
-      doc = document.implementation.createDocument('', '', null);
-    }
-    else if ( typeof ActiveX !== 'undefined' ) {
-      doc = new ActiveXObject('Msxml.DOMDocument');
-    }
-
+  if (doc) {
+    doc = doc.ownerDocument || doc.getOwnerDocument && doc.getOwnerDocument() || doc;
+  }
+  else if (typeof DOMDocument !== 'undefined') {
+    doc = new DOMDocument();
   }
-  else {
-    doc = doc.ownerDocument ||
-      doc.getOwnerDocument && doc.getOwnerDocument() ||
-      doc;
+  else if (typeof document !== 'undefined' && document.implementation && document.implementation.createDocument) {
+    doc = document.implementation.createDocument('', '', null);
+  }
+  else if (typeof ActiveX !== 'undefined') {
+    doc = new ActiveXObject('Msxml.DOMDocument');
   }
 
   var elems = [],
@@ -457,21 +459,21 @@ exports.HTMLtoDOM = function( html, doc ) {
 
   // If we're dealing with an empty document then we
   // need to pre-populate it with the HTML document structure
-  if ( !documentElement && doc.createElement ) {
+  if (!documentElement && doc.createElement) {
     (function() {
       var html = doc.createElement('html');
       var head = doc.createElement('head');
-      head.appendChild( doc.createElement('title') );
-      html.appendChild( head );
-      html.appendChild( doc.createElement('body') );
-      doc.appendChild( html );
+      head.appendChild(doc.createElement('title'));
+      html.appendChild(head);
+      html.appendChild(doc.createElement('body'));
+      doc.appendChild(html);
     })();
   }
 
   // Find all the unique elements
-  if ( doc.getElementsByTagName ) {
-    for ( var i in one ) {
-      one[ i ] = doc.getElementsByTagName( i )[0];
+  if (doc.getElementsByTagName) {
+    for (var i in one) {
+      one[i] = doc.getElementsByTagName(i)[0];
     }
   }
 
@@ -479,46 +481,46 @@ exports.HTMLtoDOM = function( html, doc ) {
   // the body element
   var curParentNode = one.body;
 
-  new HTMLParser( html, {
-    start: function( tagName, attrs, unary ) {
+  new HTMLParser(html, {
+    start: function(tagName, attrs, unary) {
       // If it's a pre-built element, then we can ignore
       // its construction
-      if ( one[ tagName ] ) {
-        curParentNode = one[ tagName ];
+      if (one[tagName]) {
+        curParentNode = one[tagName];
         return;
       }
 
-      var elem = doc.createElement( tagName );
+      var elem = doc.createElement(tagName);
 
-      for ( var attr in attrs ) {
-        elem.setAttribute( attrs[ attr ].name, attrs[ attr ].value );
+      for (var attr in attrs) {
+        elem.setAttribute(attrs[attr].name, attrs[attr].value);
       }
 
-      if ( structure[ tagName ] && typeof one[ structure[ tagName ] ] !== 'boolean' ) {
-        one[ structure[ tagName ] ].appendChild( elem );
+      if (structure[tagName] && typeof one[structure[tagName]] !== 'boolean') {
+        one[structure[tagName]].appendChild(elem);
       }
-      else if ( curParentNode && curParentNode.appendChild ) {
-        curParentNode.appendChild( elem );
+      else if (curParentNode && curParentNode.appendChild) {
+        curParentNode.appendChild(elem);
       }
 
-      if ( !unary ) {
-        elems.push( elem );
+      if (!unary) {
+        elems.push(elem);
         curParentNode = elem;
       }
     },
-    end: function( /* tag */ ) {
+    end: function(/* tag */) {
       elems.length -= 1;
 
       // Init the new parentNode
-      curParentNode = elems[ elems.length - 1 ];
+      curParentNode = elems[elems.length - 1];
     },
-    chars: function( text ) {
-      curParentNode.appendChild( doc.createTextNode( text ) );
+    chars: function(text) {
+      curParentNode.appendChild(doc.createTextNode(text));
     },
-    comment: function( /* text */ ) {
+    comment: function(/* text */) {
       // create comment node
     },
-    ignore: function( /* text */ ) {
+    ignore: function(/* text */) {
       // What to do here?
     }
   });

package/src/tokenchain.js

@@ -0,0 +1,58 @@
+'use strict';
+
+function Sorter(tokens) {
+  this.tokens = tokens;
+}
+
+Sorter.prototype.sort = function(tokens, fromIndex) {
+  fromIndex = fromIndex || 0;
+  for (var i = 0, len = this.tokens.length; i < len; i++) {
+    var token = this.tokens[i];
+    var index = tokens.indexOf(token, fromIndex);
+    if (index !== -1) {
+      do {
+        if (index !== fromIndex) {
+          tokens.splice(index, 1);
+          tokens.splice(fromIndex, 0, token);
+        }
+        fromIndex++;
+      } while ((index = tokens.indexOf(token, fromIndex)) !== -1);
+      return this[token].sort(tokens, fromIndex);
+    }
+  }
+  return tokens;
+};
+
+function TokenChain() {
+}
+
+TokenChain.prototype = {
+  add: function(tokens) {
+    var self = this;
+    tokens.forEach(function(token) {
+      (self[token] || (self[token] = [])).push(tokens);
+    });
+  },
+  createSorter: function() {
+    var self = this;
+    var sorter = new Sorter(Object.keys(this).sort(function(j, k) {
+      var m = self[j].length;
+      var n = self[k].length;
+      return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0;
+    }));
+    sorter.tokens.forEach(function(token) {
+      var chain = new TokenChain();
+      self[token].forEach(function(tokens) {
+        var index;
+        while ((index = tokens.indexOf(token)) !== -1) {
+          tokens.splice(index, 1);
+        }
+        chain.add(tokens.slice(0));
+      });
+      sorter[token] = chain.createSorter();
+    });
+    return sorter;
+  }
+};
+
+module.exports = TokenChain;