htmlnano 0.2.7 → 0.2.8

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

@@ -3,21 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = removeRedundantAttributes;
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-var redundantAttributes = {
+exports.default = removeRedundantAttributes;
+// 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']);
+const redundantAttributes = {
   'form': {
     'method': 'get'
   },
@@ -29,9 +18,19 @@ var redundantAttributes = {
   },
   'script': {
     'language': 'javascript',
-    'type': 'text/javascript',
+    'type': node => {
+      for (const [attrName, attrValue] of Object.entries(node.attrs)) {
+        if (attrName.toLowerCase() !== 'type') {
+          continue;
+        }
+
+        return redundantScriptTypes.has(attrValue);
+      }
+
+      return false;
+    },
     // Remove attribute if the function returns false
-    'charset': function charset(node) {
+    '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;
@@ -43,17 +42,13 @@ var redundantAttributes = {
   },
   'link': {
     'media': 'all',
-    'type': function type(node) {
+    'type': node => {
       // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
-      var isRelStyleSheet = false;
-      var isTypeTextCSS = false;
+      let isRelStyleSheet = false;
+      let isTypeTextCSS = false;
 
       if (node.attrs) {
-        for (var _i = 0, _Object$entries = Object.entries(node.attrs); _i < _Object$entries.length; _i++) {
-          var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-              attrName = _Object$entries$_i[0],
-              attrValue = _Object$entries$_i[1];
-
+        for (const [attrName, attrValue] of Object.entries(node.attrs)) {
           if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
             isRelStyleSheet = true;
           }
@@ -67,22 +62,28 @@ var redundantAttributes = {
 
       return isRelStyleSheet && isTypeTextCSS;
     }
+  },
+  // See: https://html.spec.whatwg.org/#lazy-loading-attributes
+  'img': {
+    'loading': 'eager'
+  },
+  'iframe': {
+    'loading': 'eager'
   }
 };
-var TAG_MATCH_REGEXP = new RegExp('^(' + Object.keys(redundantAttributes).join('|') + ')$');
+const TAG_MATCH_REGEXP = new RegExp('^(' + Object.keys(redundantAttributes).join('|') + ')$');
 /** Removes redundant attributes */
 
 function removeRedundantAttributes(tree) {
   tree.match({
     tag: TAG_MATCH_REGEXP
-  }, function (node) {
-    var tagRedundantAttributes = redundantAttributes[node.tag];
+  }, node => {
+    const tagRedundantAttributes = redundantAttributes[node.tag];
     node.attrs = node.attrs || {};
 
-    for (var _i2 = 0, _Object$keys = Object.keys(tagRedundantAttributes); _i2 < _Object$keys.length; _i2++) {
-      var redundantAttributeName = _Object$keys[_i2];
-      var tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
-      var isRemove = false;
+    for (const redundantAttributeName of Object.keys(tagRedundantAttributes)) {
+      let tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
+      let isRemove = false;
 
       if (typeof tagRedundantAttributeValue === 'function') {
         isRemove = tagRedundantAttributeValue(node);

package/lib/modules/removeUnusedCss.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = removeUnusedCss;
+exports.default = removeUnusedCss;
 
 var _helpers = require("../helpers");
 
@@ -13,37 +13,17 @@ var _purgecss = _interopRequireDefault(require("purgecss"));
 
 var _posthtmlRender = _interopRequireDefault(require("posthtml-render"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // These options must be set and shouldn't be overriden to ensure uncss doesn't look at linked stylesheets.
-var uncssOptions = {
+const uncssOptions = {
   ignoreSheets: [/\s*/],
   stylesheets: []
 };
 
 function processStyleNodeUnCSS(html, styleNode, uncssOptions) {
-  var css = (0, _helpers.extractCssFromStyleNode)(styleNode);
-  return runUncss(html, css, uncssOptions).then(function (css) {
+  const css = (0, _helpers.extractCssFromStyleNode)(styleNode);
+  return runUncss(html, css, uncssOptions).then(css => {
     // uncss may have left some style tags empty
     if (css.trim().length === 0) {
       styleNode.tag = false;
@@ -56,15 +36,16 @@ function processStyleNodeUnCSS(html, styleNode, uncssOptions) {
 }
 
 function runUncss(html, css, userOptions) {
-  if (_typeof(userOptions) !== 'object') {
+  if (typeof userOptions !== 'object') {
     userOptions = {};
   }
 
-  var options = _objectSpread(_objectSpread({}, userOptions), uncssOptions);
-
-  return new Promise(function (resolve, reject) {
+  const options = { ...userOptions,
+    ...uncssOptions
+  };
+  return new Promise((resolve, reject) => {
     options.raw = css;
-    (0, _uncss["default"])(html, options, function (error, output) {
+    (0, _uncss.default)(html, options, (error, output) => {
       if (error) {
         reject(error);
         return;
@@ -75,25 +56,23 @@ function runUncss(html, css, userOptions) {
   });
 }
 
-var purgeFromHtml = function purgeFromHtml(tree) {
+const purgeFromHtml = function (tree) {
   // content is not used as we can directly used the parsed HTML,
   // making the process faster
-  var selectors = [];
-  tree.walk(function (node) {
-    var classes = node.attrs && node.attrs["class"] && node.attrs["class"].split(' ') || [];
-    var ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
-    selectors.push.apply(selectors, _toConsumableArray(classes).concat(_toConsumableArray(ids)));
+  const selectors = [];
+  tree.walk(node => {
+    const classes = node.attrs && node.attrs.class && node.attrs.class.split(' ') || [];
+    const ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
+    selectors.push(...classes, ...ids);
     node.tag && selectors.push(node.tag);
     return node;
   });
-  return function () {
-    return selectors;
-  };
+  return () => selectors;
 };
 
 function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions) {
-  var css = (0, _helpers.extractCssFromStyleNode)(styleNode);
-  return runPurgecss(tree, css, purgecssOptions).then(function (css) {
+  const css = (0, _helpers.extractCssFromStyleNode)(styleNode);
+  return runPurgecss(tree, css, purgecssOptions).then(css => {
     if (css.trim().length === 0) {
       styleNode.tag = false;
       styleNode.content = [];
@@ -105,11 +84,11 @@ function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions) {
 }
 
 function runPurgecss(tree, css, userOptions) {
-  if (_typeof(userOptions) !== 'object') {
+  if (typeof userOptions !== 'object') {
     userOptions = {};
   }
 
-  var options = _objectSpread(_objectSpread({}, userOptions), {}, {
+  const options = { ...userOptions,
     content: [{
       raw: tree,
       extension: 'html'
@@ -122,9 +101,8 @@ function runPurgecss(tree, css, userOptions) {
       extractor: purgeFromHtml(tree),
       extensions: ['html']
     }]
-  });
-
-  return new _purgecss["default"]().purge(options).then(function (result) {
+  };
+  return new _purgecss.default().purge(options).then(result => {
     return result[0].css;
   });
 }
@@ -132,9 +110,9 @@ function runPurgecss(tree, css, userOptions) {
 
 
 function removeUnusedCss(tree, options, userOptions) {
-  var promises = [];
-  var html = userOptions.tool !== 'purgeCSS' && (0, _posthtmlRender["default"])(tree);
-  tree.walk(function (node) {
+  const promises = [];
+  const html = userOptions.tool !== 'purgeCSS' && (0, _posthtmlRender.default)(tree);
+  tree.walk(node => {
     if ((0, _helpers.isStyleNode)(node)) {
       if (userOptions.tool === 'purgeCSS') {
         promises.push(processStyleNodePurgeCSS(tree, node, userOptions));
@@ -145,7 +123,5 @@ function removeUnusedCss(tree, options, userOptions) {
 
     return node;
   });
-  return Promise.all(promises).then(function () {
-    return tree;
-  });
+  return Promise.all(promises).then(() => tree);
 }

package/lib/modules/sortAttributes.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = sortAttributes;
+
+var _timsort = require("timsort");
+
+const validOptions = new Set(['frequency', 'alphabetical']);
+
+const processModuleOptions = options => {
+  if (options === true) return 'alphabetical';
+  return validOptions.has(options) ? options : false;
+};
+
+class AttributeTokenChain {
+  constructor() {
+    this.freqData = new Map(); // <attr, frequency>[]
+  }
+
+  addFromNodeAttrs(nodeAttrs) {
+    Object.keys(nodeAttrs).forEach(attrName => {
+      const attrNameLower = attrName.toLowerCase();
+
+      if (this.freqData.has(attrNameLower)) {
+        this.freqData.set(attrNameLower, this.freqData.get(attrNameLower) + 1);
+      } else {
+        this.freqData.set(attrNameLower, 1);
+      }
+    });
+  }
+
+  createSortOrder() {
+    let _sortOrder = [];
+
+    for (const item of this.freqData.entries()) {
+      _sortOrder.push(item);
+    }
+
+    (0, _timsort.sort)(_sortOrder, (a, b) => b[1] - a[1]);
+    this.sortOrder = _sortOrder.map(i => i[0]);
+  }
+
+  sortFromNodeAttrs(nodeAttrs) {
+    const newAttrs = {}; // Convert node.attrs attrName into lower case.
+
+    const loweredNodeAttrs = {};
+    Object.entries(nodeAttrs).forEach(([attrName, attrValue]) => {
+      loweredNodeAttrs[attrName.toLowerCase()] = attrValue;
+    });
+
+    if (!this.sortOrder) {
+      this.createSortOrder();
+    }
+
+    this.sortOrder.forEach(attrNameLower => {
+      // The attrName inside "sortOrder" has been lowered
+      if (loweredNodeAttrs[attrNameLower]) {
+        newAttrs[attrNameLower] = loweredNodeAttrs[attrNameLower];
+      }
+    });
+    return newAttrs;
+  }
+
+}
+/** Sort attibutes */
+
+
+function sortAttributes(tree, options, moduleOptions) {
+  const sortType = processModuleOptions(moduleOptions);
+
+  if (sortType === 'alphabetical') {
+    return sortAttributesInAlphabeticalOrder(tree);
+  }
+
+  if (sortType === 'frequency') {
+    return sortAttributesByFrequency(tree);
+  } // Invalid configuration
+
+
+  return tree;
+}
+
+function sortAttributesInAlphabeticalOrder(tree) {
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    const newAttrs = {};
+    Object.keys(node.attrs).sort((a, b) => typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b).forEach(attr => newAttrs[attr] = node.attrs[attr]);
+    node.attrs = newAttrs;
+    return node;
+  });
+  return tree;
+}
+
+function sortAttributesByFrequency(tree) {
+  const tokenchain = new AttributeTokenChain(); // Traverse through tree to get frequency
+
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    tokenchain.addFromNodeAttrs(node.attrs);
+    return node;
+  }); // Traverse through tree again, this time sort the attributes
+
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    node.attrs = tokenchain.sortFromNodeAttrs(node.attrs);
+    return node;
+  });
+  return tree;
+}