htmlnano 0.2.5 → 0.2.9

package/lib/modules/removeEmptyAttributes.js

@@ -1,33 +1,31 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = removeEmptyAttributes;
 // Source: https://www.w3.org/TR/html4/sgml/dtd.html#events (Generic Attributes)
-var safeToRemoveAttrs = new Set(['id', 'class', 'style', 'title', 'lang', 'dir', 'onclick', 'ondblclick', 'onmousedown', 'onmouseup', 'onmouseover', 'onmousemove', 'onmouseout', 'onkeypress', 'onkeydown', 'onkeyup']);
-
+const safeToRemoveAttrs = new Set(['id', 'class', 'style', 'title', 'lang', 'dir', 'onclick', 'ondblclick', 'onmousedown', 'onmouseup', 'onmouseover', 'onmousemove', 'onmouseout', 'onkeypress', 'onkeydown', 'onkeyup']);
 /** Removes empty attributes */
+
 function removeEmptyAttributes(tree) {
-    tree.walk(function (node) {
-        if (!node.attrs) {
-            return node;
-        }
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
 
-        Object.keys(node.attrs).forEach(function (attrName) {
-            var attrNameLower = attrName.toLowerCase();
-            if (!safeToRemoveAttrs.has(attrNameLower)) {
-                return;
-            }
+    Object.entries(node.attrs).forEach(([attrName, attrValue]) => {
+      const attrNameLower = attrName.toLowerCase();
 
-            var attrValue = node.attrs[attrName];
-            if (attrValue === '' || (attrValue || '').match(/^\s+$/)) {
-                delete node.attrs[attrName];
-            }
-        });
+      if (!safeToRemoveAttrs.has(attrNameLower)) {
+        return;
+      }
 
-        return node;
+      if (attrValue === '' || (attrValue || '').match(/^\s+$/)) {
+        delete node.attrs[attrName];
+      }
     });
-
-    return tree;
+    return node;
+  });
+  return tree;
 }

package/lib/modules/removeOptionalTags.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeOptionalTags;
+
+var _helpers = require("../helpers");
+
+const startWithWhitespacePattern = /^\s+/;
+const bodyStartTagCantBeOmittedWithFirstChildTags = new Set(['meta', 'link', 'script', 'style']);
+const tbodyStartTagCantBeOmittedWithPrecededTags = new Set(['tbody', 'thead', 'tfoot']);
+const tbodyEndTagCantBeOmittedWithFollowedTags = new Set(['tbody', 'tfoot']);
+
+function isEmptyTextNode(node) {
+  if (typeof node === 'string' && node.trim() === '') {
+    return true;
+  }
+
+  return false;
+}
+
+function isEmptyNode(node) {
+  if (!node.content) {
+    return true;
+  }
+
+  if (node.content.length) {
+    return !node.content.filter(n => typeof n === 'string' && isEmptyTextNode(n) ? false : true).length;
+  }
+
+  return true;
+}
+
+function getFirstChildTag(node, nonEmpty = true) {
+  if (node.content && node.content.length) {
+    if (nonEmpty) {
+      for (const childNode of node.content) {
+        if (childNode.tag) return childNode;
+        if (typeof childNode === 'string' && !isEmptyTextNode(childNode)) return childNode;
+      }
+    } else {
+      return node.content[0] || null;
+    }
+  }
+
+  return null;
+}
+
+function getPrevNode(tree, currentNodeIndex, nonEmpty = false) {
+  if (nonEmpty) {
+    for (let i = currentNodeIndex - 1; i >= 0; i--) {
+      const node = tree[i];
+      if (node.tag) return node;
+      if (typeof node === 'string' && !isEmptyTextNode(node)) return node;
+    }
+  } else {
+    return tree[currentNodeIndex - 1] || null;
+  }
+
+  return null;
+}
+
+function getNextNode(tree, currentNodeIndex, nonEmpty = false) {
+  if (nonEmpty) {
+    for (let i = currentNodeIndex + 1; i < tree.length; i++) {
+      const node = tree[i];
+      if (node.tag) return node;
+      if (typeof node === 'string' && !isEmptyTextNode(node)) return node;
+    }
+  } else {
+    return tree[currentNodeIndex + 1] || null;
+  }
+
+  return null;
+} // Specification https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+
+/** Remove optional tag in the DOM */
+
+
+function removeOptionalTags(tree) {
+  tree.forEach((node, index) => {
+    if (!node.tag) return node;
+    if (node.attrs && Object.keys(node.attrs).length) return node; // const prevNode = getPrevNode(tree, index);
+
+    const prevNonEmptyNode = getPrevNode(tree, index, true);
+    const nextNode = getNextNode(tree, index);
+    const nextNonEmptyNode = getNextNode(tree, index, true);
+    const firstChildNode = getFirstChildTag(node, false);
+    const firstNonEmptyChildNode = getFirstChildTag(node);
+    /**
+     * An "html" element's start tag may be omitted if the first thing inside the "html" element is not a comment.
+     * An "html" element's end tag may be omitted if the "html" element is not IMMEDIATELY followed by a comment.
+     */
+
+    if (node.tag === 'html') {
+      let isHtmlStartTagCanBeOmitted = true;
+      let isHtmlEndTagCanBeOmitted = true;
+
+      if (typeof firstNonEmptyChildNode === 'string' && (0, _helpers.isComment)(firstNonEmptyChildNode)) {
+        isHtmlStartTagCanBeOmitted = false;
+      }
+
+      if (typeof nextNonEmptyNode === 'string' && (0, _helpers.isComment)(nextNonEmptyNode)) {
+        isHtmlEndTagCanBeOmitted = false;
+      }
+
+      if (isHtmlStartTagCanBeOmitted && isHtmlEndTagCanBeOmitted) {
+        node.tag = false;
+      }
+    }
+    /**
+     * A "head" element's start tag may be omitted if the element is empty, or if the first thing inside the "head" element is an element.
+     * A "head" element's end tag may be omitted if the "head" element is not IMMEDIATELY followed by ASCII whitespace or a comment.
+     */
+
+
+    if (node.tag === 'head') {
+      let isHeadStartTagCanBeOmitted = false;
+      let isHeadEndTagCanBeOmitted = true;
+
+      if (isEmptyNode(node) || firstNonEmptyChildNode && firstNonEmptyChildNode.tag) {
+        isHeadStartTagCanBeOmitted = true;
+      }
+
+      if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && (0, _helpers.isComment)(nextNode)) {
+        isHeadEndTagCanBeOmitted = false;
+      }
+
+      if (isHeadStartTagCanBeOmitted && isHeadEndTagCanBeOmitted) {
+        node.tag = false;
+      }
+    }
+    /**
+     * A "body" element's start tag may be omitted if the element is empty, or if the first thing inside the "body" element is not ASCII whitespace or a comment, except if the first thing inside the "body" element is a "meta", "link", "script", "style", or "template" element.
+     * A "body" element's end tag may be omitted if the "body" element is not IMMEDIATELY followed by a comment.
+     */
+
+
+    if (node.tag === 'body') {
+      let isBodyStartTagCanBeOmitted = true;
+      let isBodyEndTagCanBeOmitted = true;
+
+      if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstNonEmptyChildNode === 'string' && (0, _helpers.isComment)(firstNonEmptyChildNode)) {
+        isBodyStartTagCanBeOmitted = false;
+      }
+
+      if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
+        isBodyStartTagCanBeOmitted = false;
+      }
+
+      if (nextNode && typeof nextNode === 'string' && (0, _helpers.isComment)(nextNode)) {
+        isBodyEndTagCanBeOmitted = false;
+      }
+
+      if (isBodyStartTagCanBeOmitted && isBodyEndTagCanBeOmitted) {
+        node.tag = false;
+      }
+    }
+    /**
+     * A "colgroup" element's start tag may be omitted if the first thing inside the "colgroup" element is a "col" element, and if the element is not IMMEDIATELY preceded by another "colgroup" element. It can't be omitted if the element is empty.
+     * A "colgroup" element's end tag may be omitted if the "colgroup" element is not IMMEDIATELY followed by ASCII whitespace or a comment.
+     */
+
+
+    if (node.tag === 'colgroup') {
+      let isColgroupStartTagCanBeOmitted = false;
+      let isColgroupEndTagCanBeOmitted = true;
+
+      if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
+        isColgroupStartTagCanBeOmitted = true;
+      }
+
+      if (prevNonEmptyNode && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
+        isColgroupStartTagCanBeOmitted = false;
+      }
+
+      if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && (0, _helpers.isComment)(nextNonEmptyNode)) {
+        isColgroupEndTagCanBeOmitted = false;
+      }
+
+      if (isColgroupStartTagCanBeOmitted && isColgroupEndTagCanBeOmitted) {
+        node.tag = false;
+      }
+    }
+    /**
+     * A "tbody" element's start tag may be omitted if the first thing inside the "tbody" element is a "tr" element, and if the element is not immediately preceded by another "tbody", "thead" or "tfoot" element. It can't be omitted if the element is empty.
+     * A "tbody" element's end tag may be omitted if the "tbody" element is not IMMEDIATELY followed by a "tbody" or "tfoot" element.
+     */
+
+
+    if (node.tag === 'tbody') {
+      let isTbodyStartTagCanBeOmitted = false;
+      let isTbodyEndTagCanBeOmitted = true;
+
+      if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
+        isTbodyStartTagCanBeOmitted = true;
+      }
+
+      if (prevNonEmptyNode && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
+        isTbodyStartTagCanBeOmitted = false;
+      }
+
+      if (nextNonEmptyNode && nextNonEmptyNode.tag && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextNonEmptyNode.tag)) {
+        isTbodyEndTagCanBeOmitted = false;
+      }
+
+      if (isTbodyStartTagCanBeOmitted && isTbodyEndTagCanBeOmitted) {
+        node.tag = false;
+      }
+    }
+
+    if (node.content && node.content.length) {
+      removeOptionalTags(node.content);
+    }
+
+    return node;
+  });
+  return tree;
+}

package/lib/modules/removeRedundantAttributes.js

@@ -1,87 +1,110 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = removeRedundantAttributes;
-var redundantAttributes = {
-    'form': {
-        'method': 'get'
-    },
+exports.redundantScriptTypes = void 0;
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#JavaScript_types
+const redundantScriptTypes = new Set(['application/javascript', 'application/ecmascript', 'application/x-ecmascript', 'application/x-javascript', 'text/javascript', 'text/ecmascript', 'text/javascript1.0', 'text/javascript1.1', 'text/javascript1.2', 'text/javascript1.3', 'text/javascript1.4', 'text/javascript1.5', 'text/jscript', 'text/livescript', 'text/x-ecmascript', 'text/x-javascript']);
+exports.redundantScriptTypes = redundantScriptTypes;
+const redundantAttributes = {
+  'form': {
+    'method': 'get'
+  },
+  'input': {
+    'type': 'text'
+  },
+  'button': {
+    'type': 'submit'
+  },
+  'script': {
+    'language': 'javascript',
+    'type': node => {
+      for (const [attrName, attrValue] of Object.entries(node.attrs)) {
+        if (attrName.toLowerCase() !== 'type') {
+          continue;
+        }
 
-    'input': {
-        'type': 'text'
-    },
+        return redundantScriptTypes.has(attrValue);
+      }
 
-    'button': {
-        'type': 'submit'
+      return false;
     },
+    // Remove attribute if the function returns false
+    'charset': node => {
+      // The charset attribute only really makes sense on “external” SCRIPT elements:
+      // http://perfectionkills.com/optimizing-html/#8_script_charset
+      return node.attrs && !node.attrs.src;
+    }
+  },
+  'style': {
+    'media': 'all',
+    'type': 'text/css'
+  },
+  'link': {
+    'media': 'all',
+    'type': node => {
+      // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
+      let isRelStyleSheet = false;
+      let isTypeTextCSS = false;
 
-    'script': {
-        'language': 'javascript',
-        'type': 'text/javascript',
-        // Remove attribute if the function returns false
-        'charset': function charset(node) {
-            // The charset attribute only really makes sense on “external” SCRIPT elements:
-            // http://perfectionkills.com/optimizing-html/#8_script_charset
-            return node.attrs && !node.attrs.src;
+      if (node.attrs) {
+        for (const [attrName, attrValue] of Object.entries(node.attrs)) {
+          if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
+            isRelStyleSheet = true;
+          }
+
+          if (attrName.toLowerCase() === 'type' && attrValue === 'text/css') {
+            isTypeTextCSS = true;
+          }
         }
-    },
+      } // Only "text/css" is redudant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
 
-    'style': {
-        'media': 'all',
-        'type': 'text/css'
-    },
 
-    'link': {
-        'media': 'all'
+      return isRelStyleSheet && isTypeTextCSS;
     }
+  },
+  // See: https://html.spec.whatwg.org/#lazy-loading-attributes
+  'img': {
+    'loading': 'eager'
+  },
+  'iframe': {
+    'loading': 'eager'
+  }
 };
-
+const tagsHaveRedundantAttributes = new Set(Object.keys(redundantAttributes));
 /** Removes redundant attributes */
+
 function removeRedundantAttributes(tree) {
-    var tags = Object.keys(redundantAttributes);
-    var tagMatchRegExp = new RegExp('^(' + tags.join('|') + ')$');
-    tree.match({ tag: tagMatchRegExp }, function (node) {
-        var tagRedundantAttributes = redundantAttributes[node.tag];
-        node.attrs = node.attrs || {};
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
+  tree.walk(node => {
+    if (!node.tag) {
+      return node;
+    }
 
-        try {
-            for (var _iterator = Object.keys(tagRedundantAttributes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var redundantAttributeName = _step.value;
+    if (!tagsHaveRedundantAttributes.has(node.tag)) {
+      return node;
+    }
 
-                var tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
-                var isRemove = false;
-                if (typeof tagRedundantAttributeValue === 'function') {
-                    isRemove = tagRedundantAttributeValue(node);
-                } else if (node.attrs[redundantAttributeName] === tagRedundantAttributeValue) {
-                    isRemove = true;
-                }
+    const tagRedundantAttributes = redundantAttributes[node.tag];
+    node.attrs = node.attrs || {};
 
-                if (isRemove) {
-                    delete node.attrs[redundantAttributeName];
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return) {
-                    _iterator.return();
-                }
-            } finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
+    for (const redundantAttributeName of Object.keys(tagRedundantAttributes)) {
+      let tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
+      let isRemove = false;
+
+      if (typeof tagRedundantAttributeValue === 'function') {
+        isRemove = tagRedundantAttributeValue(node);
+      } else if (node.attrs[redundantAttributeName] === tagRedundantAttributeValue) {
+        isRemove = true;
+      }
 
-        return node;
-    });
+      if (isRemove) {
+        delete node.attrs[redundantAttributeName];
+      }
+    }
 
-    return tree;
+    return node;
+  });
+  return tree;
 }