htmlnano 0.2.5 → 0.2.9

package/lib/modules/collapseAttributeWhitespace.js

@@ -1,30 +1,32 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseAttributeWhitespace;
-var attributesWithLists = exports.attributesWithLists = new Set(['class', 'rel', 'ping']);
-
+exports.attributesWithLists = void 0;
+const attributesWithLists = new Set(['class', 'rel', 'ping']);
 /** Collapse whitespaces inside list-like attributes (e.g. class, rel) */
+
+exports.attributesWithLists = attributesWithLists;
+
 function collapseAttributeWhitespace(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 (!attributesWithLists.has(attrNameLower)) {
-                return;
-            }
+    Object.entries(node.attrs).forEach(([attrName, attrValue]) => {
+      const attrNameLower = attrName.toLowerCase();
 
-            var attrValue = node.attrs[attrName].replace(/\s+/g, ' ').trim();
-            node.attrs[attrName] = attrValue;
-        });
+      if (!attributesWithLists.has(attrNameLower)) {
+        return;
+      }
 
-        return node;
+      const newAttrValue = attrValue.replace(/\s+/g, ' ').trim();
+      node.attrs[attrName] = newAttrValue;
     });
-
-    return tree;
+    return node;
+  });
+  return tree;
 }

package/lib/modules/collapseBooleanAttributes.js

@@ -1,56 +1,44 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseBooleanAttributes;
 // Source: https://github.com/kangax/html-minifier/issues/63
-var htmlBooleanAttributes = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowtransparency', '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 amphtmlBooleanAttributes = new Set(['⚡', 'amp', '⚡4ads', 'amp4ads', '⚡4email', 'amp4email', 'amp-custom', 'amp-boilerplate', 'amp4ads-boilerplate', 'amp4email-boilerplate', 'allow-blocked-ranges', 'amp-access-hide', 'amp-access-template', 'amp-keyframes', 'animate', 'arrows', 'data-block-on-consent', 'data-enable-refresh', 'data-multi-size', 'date-template', 'disable-double-tap', 'disable-session-states', 'disableremoteplayback', 'dots', 'expand-single-section', 'expanded', 'fallback', 'first', 'fullscreen', 'inline', 'lightbox', 'noaudio', 'noautoplay', 'noloading', 'once', 'open-after-clear', 'open-after-select', 'open-button', 'placeholder', 'preload', 'reset-on-refresh', 'reset-on-resize', 'resizable', 'rotate-to-fullscreen', 'second', 'standalone', 'stereo', 'submit-error', 'submit-success', 'submitting', 'subscriptions-actions', 'subscriptions-dialog']);
+const htmlBooleanAttributes = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowtransparency', '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']);
+const amphtmlBooleanAttributes = new Set(['⚡', 'amp', '⚡4ads', 'amp4ads', '⚡4email', 'amp4email', 'amp-custom', 'amp-boilerplate', 'amp4ads-boilerplate', 'amp4email-boilerplate', 'allow-blocked-ranges', 'amp-access-hide', 'amp-access-template', 'amp-keyframes', 'animate', 'arrows', 'data-block-on-consent', 'data-enable-refresh', 'data-multi-size', 'date-template', 'disable-double-tap', 'disable-session-states', 'disableremoteplayback', 'dots', 'expand-single-section', 'expanded', 'fallback', 'first', 'fullscreen', 'inline', 'lightbox', 'noaudio', 'noautoplay', 'noloading', 'once', 'open-after-clear', 'open-after-select', 'open-button', 'placeholder', 'preload', 'reset-on-refresh', 'reset-on-resize', 'resizable', 'rotate-to-fullscreen', 'second', 'standalone', 'stereo', 'submit-error', 'submit-success', 'submitting', 'subscriptions-actions', 'subscriptions-dialog']);
 
 function collapseBooleanAttributes(tree, options, moduleOptions) {
-    tree.match({ attrs: true }, function (node) {
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-            for (var _iterator = Object.keys(node.attrs)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var attrName = _step.value;
-
-                if (!node.tag) {
-                    continue;
-                }
-
-                if (node.tag.search('a-') === 0 && attrName === 'visible') {
-                    continue;
-                }
-
-                if (htmlBooleanAttributes.has(attrName)) {
-                    node.attrs[attrName] = true;
-                }
-                if (moduleOptions.amphtml && node.attrs[attrName] === '' && amphtmlBooleanAttributes.has(attrName)) {
-                    node.attrs[attrName] = true;
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return) {
-                    _iterator.return();
-                }
-            } finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-
-        return node;
-    });
-
-    return tree;
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    if (!node.tag) {
+      return node;
+    }
+
+    for (const attrName of Object.keys(node.attrs)) {
+      if (attrName === 'visible' && node.tag.startsWith('a-')) {
+        continue;
+      }
+
+      if (htmlBooleanAttributes.has(attrName)) {
+        node.attrs[attrName] = true;
+      }
+
+      if (moduleOptions.amphtml && amphtmlBooleanAttributes.has(attrName) && node.attrs[attrName] === '') {
+        node.attrs[attrName] = true;
+      } // collapse crossorigin attributes
+      // Specification: https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
+
+
+      if (attrName.toLowerCase() === 'crossorigin' && (node.attrs[attrName] === 'anonymous' || node.attrs[attrName] === '')) {
+        node.attrs[attrName] = true;
+      }
+    }
+
+    return node;
+  });
+  return tree;
 }

package/lib/modules/collapseWhitespace.js

@@ -1,50 +1,76 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseWhitespace;
 
-var _normalizeHtmlWhitespace = require('normalize-html-whitespace');
-
-var _normalizeHtmlWhitespace2 = _interopRequireDefault(_normalizeHtmlWhitespace);
-
-var _helpers = require('../helpers');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var noWhitespaceCollapseElements = new Set(['script', 'style', 'pre', 'textarea']);
+var _helpers = require("../helpers");
 
+const noWhitespaceCollapseElements = new Set(['script', 'style', 'pre', 'textarea']);
+const noTrimWhitespacesArroundElements = new Set([// non-empty tags that will maintain whitespace around them
+'a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'ins', 'kbd', 'label', 'mark', 'math', 'nobr', 'object', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', // self-closing tags that will maintain whitespace around them
+'comment', 'img', 'input', 'wbr']);
+const noTrimWhitespacesInsideElements = new Set([// non-empty tags that will maintain whitespace within them
+'a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
+const whitespacePattern = /\s+/g;
+const NONE = '';
+const SINGLE_SPACE = ' ';
+const validOptions = ['all', 'aggressive', 'conservative'];
 /** Collapses redundant whitespaces */
+
 function collapseWhitespace(tree, options, collapseType, tag) {
-    if (collapseType !== 'all') {
-        collapseType = 'conservative';
+  collapseType = validOptions.includes(collapseType) ? collapseType : 'conservative';
+  tree.forEach((node, index) => {
+    if (typeof node === 'string') {
+      const prevNode = tree[index - 1];
+      const nextNode = tree[index + 1];
+      const prevNodeTag = prevNode && prevNode.tag;
+      const nextNodeTag = nextNode && nextNode.tag;
+      const isTopLevel = !tag || tag === 'html' || tag === 'head';
+      const shouldTrim = collapseType === 'all' || isTopLevel ||
+      /*
+       * When collapseType is set to 'aggressive', and the tag is not inside 'noTrimWhitespacesInsideElements'.
+       * the first & last space inside the tag will be trimmed
+       */
+      collapseType === 'aggressive' && !noTrimWhitespacesInsideElements.has(tag);
+      node = collapseRedundantWhitespaces(node, collapseType, shouldTrim, tag, prevNodeTag, nextNodeTag);
     }
 
-    tree.forEach(function (node, index) {
-        if (typeof node === 'string' && !(0, _helpers.isComment)(node)) {
-            var isTopLevel = !tag || tag === 'html' || tag === 'head';
-            node = collapseRedundantWhitespaces(node, collapseType, isTopLevel);
-        }
+    const isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
 
-        var isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
-        if (node.content && node.content.length && isAllowCollapseWhitespace) {
-            node.content = collapseWhitespace(node.content, options, collapseType, node.tag);
-        }
-
-        tree[index] = node;
-    });
+    if (node.content && node.content.length && isAllowCollapseWhitespace) {
+      node.content = collapseWhitespace(node.content, options, collapseType, node.tag);
+    }
 
-    return tree;
+    tree[index] = node;
+  });
+  return tree;
 }
 
-function collapseRedundantWhitespaces(text, collapseType) {
-    var isTopLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+function collapseRedundantWhitespaces(text, collapseType, shouldTrim = false, currentTag, prevNodeTag, nextNodeTag) {
+  if (!text || text.length === 0) {
+    return NONE;
+  }
+
+  if (!(0, _helpers.isComment)(text)) {
+    text = text.replace(whitespacePattern, SINGLE_SPACE);
+  }
+
+  if (shouldTrim) {
+    if (collapseType === 'aggressive') {
+      if (!noTrimWhitespacesArroundElements.has(prevNodeTag)) {
+        text = text.trimStart();
+      }
 
-    text = text && text.length > 0 ? (0, _normalizeHtmlWhitespace2.default)(text) : '';
-    if (collapseType === 'all' || isTopLevel) {
-        text = text.trim();
+      if (!noTrimWhitespacesArroundElements.has(nextNodeTag)) {
+        text = text.trimEnd();
+      }
+    } else {
+      // collapseType is 'all', trim spaces
+      text = text.trim();
     }
+  }
 
-    return text;
+  return text;
 }

package/lib/modules/custom.js

@@ -1,22 +1,22 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = custom;
+
 /** Meta-module that runs custom modules  */
 function custom(tree, options, customModules) {
-    if (!customModules) {
-        return tree;
-    }
-
-    if (!Array.isArray(customModules)) {
-        customModules = [customModules];
-    }
+  if (!customModules) {
+    return tree;
+  }
 
-    customModules.forEach(function (customModule) {
-        tree = customModule(tree, options);
-    });
+  if (!Array.isArray(customModules)) {
+    customModules = [customModules];
+  }
 
-    return tree;
+  customModules.forEach(customModule => {
+    tree = customModule(tree, options);
+  });
+  return tree;
 }

package/lib/modules/deduplicateAttributeValues.js

@@ -1,48 +1,46 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseAttributeWhitespace;
 
-var _collapseAttributeWhitespace = require('./collapseAttributeWhitespace');
+var _collapseAttributeWhitespace = require("./collapseAttributeWhitespace");
 
 /** Deduplicate values inside list-like attributes (e.g. class, rel) */
 function collapseAttributeWhitespace(tree) {
-    tree.walk(function (node) {
-        if (!node.attrs) {
-            return node;
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    Object.keys(node.attrs).forEach(attrName => {
+      const attrNameLower = attrName.toLowerCase();
+
+      if (!_collapseAttributeWhitespace.attributesWithLists.has(attrNameLower)) {
+        return;
+      }
+
+      const attrValues = node.attrs[attrName].split(/\s/);
+      const uniqeAttrValues = new Set();
+      const deduplicatedAttrValues = [];
+      attrValues.forEach(attrValue => {
+        if (!attrValue) {
+          // Keep whitespaces
+          deduplicatedAttrValues.push('');
+          return;
         }
 
-        Object.keys(node.attrs).forEach(function (attrName) {
-            var attrNameLower = attrName.toLowerCase();
-            if (!_collapseAttributeWhitespace.attributesWithLists.has(attrNameLower)) {
-                return;
-            }
-
-            var attrValues = node.attrs[attrName].split(/\s/);
-            var uniqeAttrValues = new Set();
-            var deduplicatedAttrValues = [];
-            attrValues.forEach(function (attrValue) {
-                if (!attrValue) {
-                    // Keep whitespaces
-                    deduplicatedAttrValues.push('');
-                    return;
-                }
-
-                if (uniqeAttrValues.has(attrValue)) {
-                    return;
-                }
-
-                deduplicatedAttrValues.push(attrValue);
-                uniqeAttrValues.add(attrValue);
-            });
-
-            node.attrs[attrName] = deduplicatedAttrValues.join(' ');
-        });
-
-        return node;
-    });
+        if (uniqeAttrValues.has(attrValue)) {
+          return;
+        }
 
-    return tree;
+        deduplicatedAttrValues.push(attrValue);
+        uniqeAttrValues.add(attrValue);
+      });
+      node.attrs[attrName] = deduplicatedAttrValues.join(' ');
+    });
+    return node;
+  });
+  return tree;
 }

package/lib/modules/mergeScripts.js

@@ -1,83 +1,63 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = mergeScripts;
+
 /* Merge multiple <script> into one */
 function mergeScripts(tree) {
-    var scriptNodesIndex = {};
-    var scriptSrcIndex = 1;
-
-    tree.match({ tag: 'script' }, function (node) {
-        var nodeAttrs = node.attrs || {};
-        if (nodeAttrs.src) {
-            scriptSrcIndex++;
-            return node;
-        }
+  let scriptNodesIndex = {};
+  let scriptSrcIndex = 1;
+  tree.match({
+    tag: 'script'
+  }, node => {
+    const nodeAttrs = node.attrs || {};
+
+    if (nodeAttrs.src) {
+      scriptSrcIndex++;
+      return node;
+    }
 
-        var scriptType = nodeAttrs.type || 'text/javascript';
-        if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
-            return node;
-        }
+    const scriptType = nodeAttrs.type || 'text/javascript';
 
-        var scriptKey = JSON.stringify({
-            id: nodeAttrs.id,
-            class: nodeAttrs.class,
-            type: scriptType,
-            defer: nodeAttrs.defer !== undefined,
-            async: nodeAttrs.async !== undefined,
-            index: scriptSrcIndex
-        });
-        if (!scriptNodesIndex[scriptKey]) {
-            scriptNodesIndex[scriptKey] = [];
-        }
+    if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+      return node;
+    }
 
-        scriptNodesIndex[scriptKey].push(node);
-        return node;
+    const scriptKey = JSON.stringify({
+      id: nodeAttrs.id,
+      class: nodeAttrs.class,
+      type: scriptType,
+      defer: nodeAttrs.defer !== undefined,
+      async: nodeAttrs.async !== undefined,
+      index: scriptSrcIndex
     });
 
-    var _loop = function _loop(scriptKey) {
-        var scriptNodes = scriptNodesIndex[scriptKey];
-        var lastScriptNode = scriptNodes.pop();
-        scriptNodes.reverse().forEach(function (scriptNode) {
-            var scriptContent = (scriptNode.content || []).join(' ');
-            scriptContent = scriptContent.trim();
-            if (scriptContent.slice(-1) !== ';') {
-                scriptContent += ';';
-            }
-
-            lastScriptNode.content.unshift(scriptContent);
+    if (!scriptNodesIndex[scriptKey]) {
+      scriptNodesIndex[scriptKey] = [];
+    }
 
-            scriptNode.tag = false;
-            scriptNode.content = [];
-        });
-    };
+    scriptNodesIndex[scriptKey].push(node);
+    return node;
+  });
 
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+  for (const scriptNodes of Object.values(scriptNodesIndex)) {
+    let lastScriptNode = scriptNodes.pop();
+    scriptNodes.reverse().forEach(scriptNode => {
+      let scriptContent = (scriptNode.content || []).join(' ');
+      scriptContent = scriptContent.trim();
 
-    try {
-        for (var _iterator = Object.keys(scriptNodesIndex)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var scriptKey = _step.value;
+      if (scriptContent.slice(-1) !== ';') {
+        scriptContent += ';';
+      }
 
-            _loop(scriptKey);
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally {
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return) {
-                _iterator.return();
-            }
-        } finally {
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
+      lastScriptNode.content = lastScriptNode.content || [];
+      lastScriptNode.content.unshift(scriptContent);
+      scriptNode.tag = false;
+      scriptNode.content = [];
+    });
+  }
 
-    return tree;
+  return tree;
 }

package/lib/modules/mergeStyles.js

@@ -1,41 +1,42 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = mergeStyles;
 
-var _helpers = require('../helpers');
+var _helpers = require("../helpers");
 
 /* Merge multiple <style> into one */
 function mergeStyles(tree) {
-    var styleNodes = {};
-
-    tree.match({ tag: 'style' }, function (node) {
-        var nodeAttrs = node.attrs || {};
-        // Skip <style scoped></style>
-        // https://developer.mozilla.org/en/docs/Web/HTML/Element/style
-        if (nodeAttrs.scoped !== undefined) {
-            return node;
-        }
-
-        if ((0, _helpers.isAmpBoilerplate)(node)) {
-            return node;
-        }
-
-        var styleType = nodeAttrs.type || 'text/css';
-        var styleMedia = nodeAttrs.media || 'all';
-        var styleKey = styleType + '_' + styleMedia;
-        if (styleNodes[styleKey]) {
-            var styleContent = (node.content || []).join(' ');
-            styleNodes[styleKey].content.push(' ' + styleContent);
-            return '';
-        }
-
-        node.content = node.content || [];
-        styleNodes[styleKey] = node;
-        return node;
-    });
-
-    return tree;
+  const styleNodes = {};
+  tree.match({
+    tag: 'style'
+  }, node => {
+    const nodeAttrs = node.attrs || {}; // Skip <style scoped></style>
+    // https://developer.mozilla.org/en/docs/Web/HTML/Element/style
+
+    if (nodeAttrs.scoped !== undefined) {
+      return node;
+    }
+
+    if ((0, _helpers.isAmpBoilerplate)(node)) {
+      return node;
+    }
+
+    const styleType = nodeAttrs.type || 'text/css';
+    const styleMedia = nodeAttrs.media || 'all';
+    const styleKey = styleType + '_' + styleMedia;
+
+    if (styleNodes[styleKey]) {
+      const styleContent = (node.content || []).join(' ');
+      styleNodes[styleKey].content.push(' ' + styleContent);
+      return '';
+    }
+
+    node.content = node.content || [];
+    styleNodes[styleKey] = node;
+    return node;
+  });
+  return tree;
 }

package/lib/modules/minifyConditionalComments.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = minifyConditionalComments;
+
+var _htmlnano = _interopRequireDefault(require("../htmlnano"));
+
+var _helpers = require("../helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Spec: https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/compatibility/ms537512(v=vs.85)
+const CONDITIONAL_COMMENT_REGEXP = /(<!--\[if\s+?[^<>[\]]+?]>)([\s\S]+?)(<!\[endif\]-->)/gm;
+/** Minify content inside conditional comments */
+
+async function minifyConditionalComments(tree, htmlnanoOptions) {
+  // forEach, tree.walk, tree.match just don't support Promise.
+  for (let i = 0, len = tree.length; i < len; i++) {
+    const node = tree[i];
+
+    if (typeof node === 'string' && (0, _helpers.isConditionalComment)(node)) {
+      tree[i] = await minifycontentInsideConditionalComments(node, htmlnanoOptions);
+    }
+
+    if (node.content && node.content.length) {
+      tree[i].content = await minifyConditionalComments(node.content, htmlnanoOptions);
+    }
+  }
+
+  return tree;
+}
+
+async function minifycontentInsideConditionalComments(text, htmlnanoOptions) {
+  let match;
+  const matches = []; // FIXME!
+  // String#matchAll is supported since Node.js 12
+
+  while ((match = CONDITIONAL_COMMENT_REGEXP.exec(text)) !== null) {
+    matches.push([match[1], match[2], match[3]]);
+  }
+
+  if (!matches.length) {
+    return Promise.resolve(text);
+  }
+
+  return Promise.all(matches.map(async match => {
+    const result = await _htmlnano.default.process(match[1], htmlnanoOptions, {}, {});
+    let minified = result.html;
+
+    if (match[1].includes('<html') && minified.includes('</html>')) {
+      minified = minified.replace('</html>', '');
+    }
+
+    return match[0] + minified + match[2];
+  }));
+}